@classytic/labs 0.1.0

package/dist/blocks/physics.mjs

@@ -0,0 +1,868 @@
+import { LeverBalanceLab } from "../physics/lever/preset.mjs";
+import { OpticsLab } from "../physics/optics/preset.mjs";
+import { ProjectileLab } from "../physics/projectile-lab.mjs";
+import { GravityDrop } from "../physics/gravity-drop.mjs";
+import { RiverBoat } from "../physics/river-boat.mjs";
+import { VectorTypesLab } from "../physics/vector-types/preset.mjs";
+import { RainRelativeLab } from "../physics/rain-relative/preset.mjs";
+import { StoppingDistanceLab } from "../physics/stopping-distance/preset.mjs";
+import { RampForcesLab } from "../physics/ramp-forces/preset.mjs";
+import { CollisionTrackLab } from "../physics/collision-track/preset.mjs";
+import { ImpulseLab } from "../physics/impulse/preset.mjs";
+import { BulletWallsLab } from "../physics/bullet-walls/preset.mjs";
+import { CircularMotionLab } from "../physics/circular-motion/preset.mjs";
+import { EnergySkateLab } from "../physics/energy-skate/preset.mjs";
+import { SimpleHarmonicLab } from "../physics/shm/preset.mjs";
+import { AtwoodLab } from "../physics/atwood/preset.mjs";
+import { TerminalVelocityLab } from "../physics/terminal-velocity/preset.mjs";
+import { KeplerLab } from "../physics/kepler/preset.mjs";
+import { GravitationLab } from "../physics/gravitation/preset.mjs";
+import { OrbitLab } from "../physics/orbit-lab.mjs";
+import { WaveLab } from "../physics/waves/preset.mjs";
+import { RippleTankLab } from "../physics/waves/ripple.mjs";
+import { DopplerLab } from "../physics/waves/doppler.mjs";
+import { StringReflectionLab } from "../physics/waves/string.mjs";
+import { MagnetismLab } from "../physics/magnetism/preset.mjs";
+import { LorentzForceLab } from "../physics/lorentz/preset.mjs";
+import { HeatingCurveLab } from "../physics/thermal/preset.mjs";
+import { HeatTransferLab } from "../physics/heat-transfer/preset.mjs";
+import { ThermalExpansionLab } from "../physics/expansion/preset.mjs";
+import { TemperatureScalesLab } from "../physics/temperature-scales/preset.mjs";
+import { WaterDensityLab } from "../physics/water-density/preset.mjs";
+import { GasProcessLab } from "../physics/gas-process/preset.mjs";
+import { CarnotCycleLab } from "../physics/carnot/preset.mjs";
+import { EntropyLab } from "../physics/entropy/preset.mjs";
+import { EfficiencyLab } from "../physics/efficiency/preset.mjs";
+import { ChipToggle, ConfigPanel, ConfigRow, JsonArea, NumField, RowsEditor, TagsField, TextField, coerceArray } from "./authoring.mjs";
+import { VECTOR_BOARD_DEMO, VectorBoardView } from "../physics/vector-board/view.mjs";
+import { controlConfigSchema, flatVecSchema, typePanelSchema } from "../schemas/index.mjs";
+import { buildComponents, commonLabProps, labBlock } from "./lab-block.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { z } from "zod";
+import { defineBlock } from "@classytic/cms-ui/contract";
+
+//#region src/blocks/physics.tsx
+const ProjectileLabBlock = defineBlock({
+	key: "projectile-lab",
+	void: true,
+	label: "Projectile lab",
+	description: "Interactive projectile motion — tune angle & speed, hit a target.",
+	category: "interactive",
+	schema: z.object({
+		targetMeters: z.number().optional(),
+		g: z.number().optional()
+	}),
+	Component: ({ attributes }) => /* @__PURE__ */ jsx(ProjectileLab, {
+		targetMeters: attributes.targetMeters,
+		g: attributes.g
+	})
+});
+const OrbitLabBlock = defineBlock({
+	key: "orbit-lab",
+	void: true,
+	label: "Orbit lab",
+	description: "Interactive orbit — launch a satellite: crash, orbit, or escape.",
+	category: "interactive",
+	schema: z.object({}),
+	Component: () => /* @__PURE__ */ jsx(OrbitLab, {})
+});
+const GravityDropBlock = defineBlock({
+	key: "gravity-drop",
+	void: true,
+	label: "Gravity drop",
+	description: "Drop balls on three worlds — compare how gravity changes the fall.",
+	category: "interactive",
+	schema: z.object({ height: z.number().optional() }),
+	Component: ({ attributes }) => /* @__PURE__ */ jsx(GravityDrop, { height: attributes.height })
+});
+const RiverBoatBlock = defineBlock({
+	key: "river-boat",
+	void: true,
+	label: "River crossing (vectors)",
+	description: "Boat-and-river vector problem — step through tip-to-tail addition + component resolution.",
+	category: "interactive",
+	schema: z.object({
+		boatSpeed: z.number().optional(),
+		current: z.number().optional(),
+		riverWidth: z.number().optional(),
+		title: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const boatSpeed = typeof attributes.boatSpeed === "number" ? attributes.boatSpeed : 4;
+		const current = typeof attributes.current === "number" ? attributes.current : 2;
+		const riverWidth = typeof attributes.riverWidth === "number" ? attributes.riverWidth : 8;
+		const title = attributes.title ?? "Crossing a flowing river";
+		const widget = /* @__PURE__ */ jsx(RiverBoat, {
+			boatSpeed,
+			current,
+			riverWidth,
+			title
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "Title",
+				children: /* @__PURE__ */ jsx(TextField, {
+					value: title,
+					onChange: (v) => updateAttributes({ title: v }),
+					className: "flex-1"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "boat vᵦ",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: boatSpeed,
+					onChange: (v) => updateAttributes({ boatSpeed: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "current vᵧ",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: current,
+					onChange: (v) => updateAttributes({ current: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "river width",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: riverWidth,
+					onChange: (v) => updateAttributes({ riverWidth: v })
+				})
+			})
+		] }), widget] });
+	}
+});
+/** Simple lever authoring → the labs component's items[] API. */
+function LeverPuzzle({ knownWeight = 4, knownDist = 3, unknownDist = 2, maxWeight = 12, controlId }) {
+	return /* @__PURE__ */ jsx(LeverBalanceLab, {
+		items: [{
+			side: "L",
+			dist: knownDist,
+			weight: knownWeight
+		}, {
+			side: "R",
+			dist: unknownDist,
+			weight: "unknown"
+		}],
+		maxWeight,
+		controlId
+	});
+}
+const OpticsBlock = defineBlock({
+	key: "optics",
+	tag: "Optics",
+	void: true,
+	label: "Optics (reflect the ray)",
+	description: "Drag the source / mirrors so the light ray reflects into the target.",
+	category: "interactive",
+	schema: z.object({}),
+	Component: ({ mode }) => mode === "editing" ? /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(ConfigPanel, { children: /* @__PURE__ */ jsx("span", {
+		style: { opacity: .7 },
+		children: "No settings — drag the source, aim, or mirrors in the lesson."
+	}) }), /* @__PURE__ */ jsx(OpticsLab, {})] }) : /* @__PURE__ */ jsx(OpticsLab, {})
+});
+const LeverBlock = defineBlock({
+	key: "lever",
+	tag: "Lever",
+	void: true,
+	label: "Lever (balance the torque)",
+	description: "A known weight at a distance vs an unknown — set the unknown so turning effects match.",
+	category: "interactive",
+	schema: z.object({
+		knownWeight: z.number().default(4),
+		knownDist: z.number().default(3),
+		unknownDist: z.number().default(2),
+		controlId: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const { knownWeight = 4, knownDist = 3, unknownDist = 2 } = attributes;
+		const widget = /* @__PURE__ */ jsx(LeverPuzzle, {
+			knownWeight,
+			knownDist,
+			unknownDist,
+			controlId: attributes.controlId
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "known weight",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: knownWeight,
+					onChange: (v) => updateAttributes({ knownWeight: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "its distance",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: knownDist,
+					onChange: (v) => updateAttributes({ knownDist: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "unknown distance",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: unknownDist,
+					onChange: (v) => updateAttributes({ unknownDist: v })
+				})
+			})
+		] }), widget] });
+	}
+});
+const VectorBoardBlock = defineBlock({
+	key: "vector-board",
+	tag: "VectorBoard",
+	void: true,
+	label: "Vector board (resultant / relative)",
+	description: "Drag vector heads; live resultant (sum) or relative velocity (diff, the rain case) + angle. Optional drag-to-match goal.",
+	category: "interactive",
+	schema: z.object({
+		vectors: z.array(flatVecSchema).default(VECTOR_BOARD_DEMO),
+		combine: z.enum([
+			"sum",
+			"diff",
+			"none"
+		]).default("sum"),
+		goalX: z.union([z.number(), z.string()]).optional(),
+		goalY: z.union([z.number(), z.string()]).optional(),
+		components: z.boolean().optional(),
+		angle: z.boolean().default(true),
+		objectives: z.array(z.string()).optional(),
+		hints: z.array(z.string()).optional(),
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const vectors = coerceArray(attributes.vectors, VECTOR_BOARD_DEMO);
+		const objectives = coerceArray(attributes.objectives);
+		const hints = coerceArray(attributes.hints);
+		const widget = /* @__PURE__ */ jsx(VectorBoardView, {
+			vectors,
+			combine: attributes.combine,
+			goalX: attributes.goalX,
+			goalY: attributes.goalY,
+			components: attributes.components,
+			angle: attributes.angle,
+			objectives,
+			hints,
+			title: attributes.title,
+			prompt: attributes.prompt
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsxs(ConfigRow, {
+				label: "combine",
+				children: [/* @__PURE__ */ jsx(ChipToggle, {
+					active: attributes.combine === "sum",
+					onClick: () => updateAttributes({ combine: "sum" }),
+					children: "sum"
+				}), /* @__PURE__ */ jsx(ChipToggle, {
+					active: attributes.combine === "diff",
+					onClick: () => updateAttributes({ combine: "diff" }),
+					children: "diff (relative)"
+				})]
+			}),
+			/* @__PURE__ */ jsxs(ConfigRow, {
+				label: "show",
+				children: [/* @__PURE__ */ jsx(ChipToggle, {
+					active: !!attributes.components,
+					onClick: () => updateAttributes({ components: !attributes.components }),
+					children: "components"
+				}), /* @__PURE__ */ jsx(ChipToggle, {
+					active: attributes.angle !== false,
+					onClick: () => updateAttributes({ angle: attributes.angle === false }),
+					children: "angle"
+				})]
+			}),
+			/* @__PURE__ */ jsxs(ConfigRow, {
+				label: "target",
+				children: [/* @__PURE__ */ jsx(TextField, {
+					value: String(attributes.goalX ?? ""),
+					onChange: (v) => updateAttributes({ goalX: v }),
+					placeholder: "x"
+				}), /* @__PURE__ */ jsx(TextField, {
+					value: String(attributes.goalY ?? ""),
+					onChange: (v) => updateAttributes({ goalY: v }),
+					placeholder: "y"
+				})]
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "objectives",
+				children: /* @__PURE__ */ jsx(TagsField, {
+					value: objectives,
+					onChange: (v) => updateAttributes({ objectives: v }),
+					placeholder: "comma-separated goals"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "hints",
+				children: /* @__PURE__ */ jsx(TagsField, {
+					value: hints,
+					onChange: (v) => updateAttributes({ hints: v }),
+					placeholder: "comma-separated hints"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "vectors",
+				children: /* @__PURE__ */ jsx(RowsEditor, {
+					rows: vectors,
+					onChange: (v) => updateAttributes({ vectors: v }),
+					columns: [
+						{
+							key: "label",
+							label: "label"
+						},
+						{
+							key: "dx",
+							label: "dx"
+						},
+						{
+							key: "dy",
+							label: "dy"
+						},
+						{
+							key: "color",
+							label: "color",
+							grow: true
+						},
+						{
+							key: "drag",
+							label: "drag",
+							type: "bool"
+						}
+					],
+					newRow: () => ({
+						label: "",
+						dx: 1,
+						dy: 1,
+						drag: true
+					}),
+					addLabel: "vector"
+				})
+			})
+		] }), widget] });
+	}
+});
+const VectorTypesBlock = defineBlock({
+	key: "vector-types",
+	tag: "VectorTypes",
+	void: true,
+	label: "Vector types (reference figure)",
+	description: "Labeled gallery: equal, negative, null, unit, parallel, position. The vectors-chapter opener.",
+	category: "interactive",
+	schema: z.object({
+		title: z.string().optional(),
+		types: z.array(typePanelSchema).optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const types = attributes.types;
+		const widget = /* @__PURE__ */ jsx(VectorTypesLab, {
+			title: attributes.title,
+			types
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [/* @__PURE__ */ jsx(ConfigRow, {
+			label: "title",
+			children: /* @__PURE__ */ jsx(TextField, {
+				value: attributes.title ?? "",
+				onChange: (v) => updateAttributes({ title: v }),
+				placeholder: "Types of vectors"
+			})
+		}), /* @__PURE__ */ jsx(ConfigRow, {
+			label: "panels (advanced)",
+			children: /* @__PURE__ */ jsx(JsonArea, {
+				value: types ?? [],
+				onChange: (v) => updateAttributes({ types: v }),
+				rows: 6
+			})
+		})] }), widget] });
+	}
+});
+const RainRelativeBlock = defineBlock({
+	key: "rain-relative",
+	tag: "RainRelative",
+	void: true,
+	label: "Rain on a moving car (relative velocity)",
+	description: "Animated rain that slants as the car speeds up — apparent velocity V_rain − V_car, with a live triangle + angle.",
+	category: "interactive",
+	schema: z.object({
+		maxSpeed: z.number().default(10),
+		start: z.number().default(0),
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const widget = /* @__PURE__ */ jsx(RainRelativeLab, {
+			maxSpeed: attributes.maxSpeed,
+			start: attributes.start,
+			title: attributes.title,
+			prompt: attributes.prompt
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [/* @__PURE__ */ jsx(ConfigRow, {
+			label: "title",
+			children: /* @__PURE__ */ jsx(TextField, {
+				value: attributes.title ?? "",
+				onChange: (v) => updateAttributes({ title: v }),
+				placeholder: "Rain on a moving car"
+			})
+		}), /* @__PURE__ */ jsx(ConfigRow, {
+			label: "max speed",
+			children: /* @__PURE__ */ jsx(NumField, {
+				value: attributes.maxSpeed ?? 10,
+				onChange: (v) => updateAttributes({ maxSpeed: v })
+			})
+		})] }), widget] });
+	}
+});
+const StoppingDistanceBlock = defineBlock({
+	key: "stopping-distance",
+	tag: "StoppingDistance",
+	void: true,
+	label: "Stopping distance (drive & brake)",
+	description: "1-D kinematics: a car reacts then brakes; the road paints a blue thinking stripe + red braking stripe while synced v–t (area = distance) and s–t graphs share a playhead. ×2 speed shows thinking double but braking quadruple.",
+	category: "interactive",
+	schema: z.object({
+		speed: z.number().default(20),
+		reactionTime: z.number().default(.7),
+		deceleration: z.number().default(6),
+		predict: z.boolean().default(false),
+		showGraphs: z.boolean().default(false),
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const widget = /* @__PURE__ */ jsx(StoppingDistanceLab, {
+			speed: attributes.speed,
+			reactionTime: attributes.reactionTime,
+			deceleration: attributes.deceleration,
+			predict: attributes.predict,
+			showGraphs: attributes.showGraphs,
+			title: attributes.title,
+			prompt: attributes.prompt
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "title",
+				children: /* @__PURE__ */ jsx(TextField, {
+					value: attributes.title ?? "",
+					onChange: (v) => updateAttributes({ title: v }),
+					placeholder: "Drive & Brake"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "speed (m/s)",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.speed ?? 20,
+					onChange: (v) => updateAttributes({ speed: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "reaction (s)",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.reactionTime ?? .7,
+					onChange: (v) => updateAttributes({ reactionTime: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "brake (m/s²)",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.deceleration ?? 6,
+					onChange: (v) => updateAttributes({ deceleration: v })
+				})
+			})
+		] }), widget] });
+	}
+});
+const RampForcesBlock = defineBlock({
+	key: "ramp-forces",
+	tag: "RampForces",
+	void: true,
+	label: "Ramp forces (F = ma on an incline)",
+	description: "Tilt the incline: the weight vector splits into mg sinθ (down-slope) + mg cosθ (into-slope), the normal force shrinks as you tilt (N = mg cosθ), a friction slider spans frictionless→sticky, and the crate slides at a = g(sinθ − μcosθ).",
+	category: "interactive",
+	schema: z.object({
+		angleDeg: z.number().default(30),
+		mass: z.number().default(2),
+		friction: z.number().default(.3),
+		showComponents: z.boolean().default(false),
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		controls: controlConfigSchema.optional().describe("hide/lock knobs: angle, push, mass, frictionStatic, frictionKinetic, components, release")
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const widget = /* @__PURE__ */ jsx(RampForcesLab, {
+			angleDeg: attributes.angleDeg,
+			mass: attributes.mass,
+			friction: attributes.friction,
+			showComponents: attributes.showComponents,
+			title: attributes.title,
+			prompt: attributes.prompt,
+			controlConfig: attributes.controls
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "title",
+				children: /* @__PURE__ */ jsx(TextField, {
+					value: attributes.title ?? "",
+					onChange: (v) => updateAttributes({ title: v }),
+					placeholder: "Tilt the Ramp"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "angle (°)",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.angleDeg ?? 30,
+					onChange: (v) => updateAttributes({ angleDeg: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "friction μ",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.friction ?? .3,
+					onChange: (v) => updateAttributes({ friction: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "controls — e.g. { \"hide\": [\"mass\"], \"lock\": [\"angle\"] }",
+				children: /* @__PURE__ */ jsx(JsonArea, {
+					value: attributes.controls ?? {},
+					onChange: (v) => updateAttributes({ controls: v }),
+					rows: 3
+				})
+			})
+		] }), widget] });
+	}
+});
+const CollisionTrackBlock = defineBlock({
+	key: "collision-track",
+	tag: "CollisionTrack",
+	void: true,
+	label: "Collision track (momentum & elasticity)",
+	description: "Two carts collide; one elasticity slider morphs inelastic↔elastic. The momentum bar stays full while the KE bar leaks when sticky, and a constant-velocity centre-of-mass marker proves momentum is conserved either way.",
+	category: "interactive",
+	schema: z.object({
+		m1: z.number().default(1),
+		m2: z.number().default(1),
+		u1: z.number().default(4),
+		u2: z.number().default(-2),
+		elasticity: z.number().default(1),
+		showCenterOfMass: z.boolean().default(true),
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	Component: ({ attributes, mode, updateAttributes }) => {
+		const widget = /* @__PURE__ */ jsx(CollisionTrackLab, {
+			m1: attributes.m1,
+			m2: attributes.m2,
+			u1: attributes.u1,
+			u2: attributes.u2,
+			elasticity: attributes.elasticity,
+			showCenterOfMass: attributes.showCenterOfMass,
+			title: attributes.title,
+			prompt: attributes.prompt
+		});
+		if (mode !== "editing" || !updateAttributes) return widget;
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs(ConfigPanel, { children: [
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "title",
+				children: /* @__PURE__ */ jsx(TextField, {
+					value: attributes.title ?? "",
+					onChange: (v) => updateAttributes({ title: v }),
+					placeholder: "Sticky or Bouncy?"
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "elasticity",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.elasticity ?? 1,
+					onChange: (v) => updateAttributes({ elasticity: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "m₁",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.m1 ?? 1,
+					onChange: (v) => updateAttributes({ m1: v })
+				})
+			}),
+			/* @__PURE__ */ jsx(ConfigRow, {
+				label: "m₂",
+				children: /* @__PURE__ */ jsx(NumField, {
+					value: attributes.m2 ?? 1,
+					onChange: (v) => updateAttributes({ m2: v })
+				})
+			})
+		] }), widget] });
+	}
+});
+const common = commonLabProps;
+const wlab = (key, label, description, schema, Comp, tag) => labBlock({
+	key,
+	label,
+	description,
+	schema,
+	Component: Comp,
+	tag
+});
+const waveSchema = z.object({
+	mode: z.enum([
+		"travelling",
+		"superpose",
+		"standing"
+	]).optional(),
+	amplitude: z.number().optional(),
+	wavelength: z.number().optional(),
+	frequency: z.number().optional(),
+	...common
+});
+const WaveBlock = wlab("wave-lab", "Waves (travelling / superposition / standing)", "One waves playground: shape a travelling wave (v=fλ), add a second for interference/beats, or lock two opposite waves into a standing wave with nodes/antinodes. Optional sound.", waveSchema, (a) => /* @__PURE__ */ jsx(WaveLab, { ...a }));
+const rippleSchema = z.object({
+	wavelength: z.number().optional(),
+	view: z.enum(["ripples", "fringes"]).optional(),
+	...common
+});
+const RippleTankBlock = wlab("ripple-tank", "Ripple tank (2-D interference)", "Two draggable sources → live circular ripples or the static bright/dark interference fringes (Δ=nλ vs (n+½)λ).", rippleSchema, (a) => /* @__PURE__ */ jsx(RippleTankLab, { ...a }));
+const dopplerSchema = z.object({
+	mach: z.number().optional(),
+	...common
+});
+const DopplerBlock = wlab("doppler", "Doppler effect", "A moving source bunches wavefronts ahead (higher pitch) and stretches them behind; past Mach 1 a shock cone forms. Drive-by siren via Web Audio.", dopplerSchema, (a) => /* @__PURE__ */ jsx(DopplerLab, { ...a }));
+const stringSchema = z.object({
+	mode: z.enum(["pulse", "resonance"]).optional(),
+	end: z.enum(["fixed", "free"]).optional(),
+	frequency: z.number().optional(),
+	...common
+});
+const StringReflectionBlock = wlab("string-reflection", "Reflection & standing waves on a string", "A pulse reflects (fixed end inverts, free end upright); a continuous wave + its reflection lock into a standing wave at the resonant harmonics fₙ=n·c/2L.", stringSchema, (a) => /* @__PURE__ */ jsx(StringReflectionLab, { ...a }));
+const magnetismSchema = z.object({ ...common });
+const MagnetismBlock = wlab("magnetism", "Magnetism — field lines & compass", "Drag a bar magnet (or switch to a current-carrying wire); the field lines retrace live and a draggable compass needle aligns to the field.", magnetismSchema, (a) => /* @__PURE__ */ jsx(MagnetismLab, { ...a }));
+const lorentzSchema = z.object({
+	charge: z.union([z.literal(1), z.literal(-1)]).optional(),
+	fieldOut: z.boolean().optional(),
+	B: z.number().optional(),
+	speed: z.number().optional(),
+	...common
+});
+const LorentzBlock = wlab("lorentz", "Lorentz force F = q·v×B", "A charge fired into a magnetic field curves (cyclotron motion); v, B, F shown perpendicular with the right-hand rule. Flip charge or field → the curve reverses. Cyclotron / aurora framing.", lorentzSchema, (a) => /* @__PURE__ */ jsx(LorentzForceLab, { ...a }));
+const impulseSchema = z.object({
+	mass: z.number().optional(),
+	speed: z.number().optional(),
+	contact: z.number().optional(),
+	crackForce: z.number().optional(),
+	...common
+});
+const ImpulseBlock = wlab("impulse", "Impulse — catch the egg (J = F·Δt = Δp)", "Same ball, same speed → fixed impulse. Stretch the contact time and the force–time pulse morphs from a tall spike to a low bump with EQUAL shaded area, so the peak force plummets. A fragile egg cracks above its force limit — the number behind airbags, crumple zones and bending your knees.", impulseSchema, (a) => /* @__PURE__ */ jsx(ImpulseLab, { ...a }));
+const bulletWallsSchema = z.object({
+	speed: z.number().optional(),
+	toughness: z.number().optional(),
+	planks: z.number().optional(),
+	mass: z.number().optional(),
+	...common
+});
+const BulletWallsBlock = wlab("bullet-walls", "Bullet through N planks (penetration)", "The classic \"how many planks?\" problem, predict-first: each plank drains a fixed chunk of energy (a fixed Δv²), so the bullet slows plank-by-plank and lodges when its kinetic energy runs out. Guess the count, fire, and watch v² = u² − 2as play out with a draining energy bar.", bulletWallsSchema, (a) => /* @__PURE__ */ jsx(BulletWallsLab, { ...a }));
+const ccSchema = z.object({
+	hide: z.array(z.string()).optional(),
+	lock: z.array(z.string()).optional()
+}).optional();
+const circularSchema = z.object({
+	speed: z.number().optional(),
+	radius: z.number().optional(),
+	mass: z.number().optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const CircularMotionBlock = wlab("circular-motion", "Circular motion — centripetal force & cut the string", "A ball whirls on a string: velocity stays tangent while the tension (centripetal force F = mv²/r) points to the centre, bending the path without changing speed. Cut the string and it flies off along the TANGENT — not radially outward — killing the classic misconception. Live F, ω and period.", circularSchema, (a) => /* @__PURE__ */ jsx(CircularMotionLab, { ...a }));
+const energySkateSchema = z.object({
+	startHeight: z.number().optional(),
+	friction: z.boolean().optional(),
+	mass: z.number().optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const EnergySkateBlock = wlab("energy-skate", "Energy skate park — KE ⇄ PE (+ heat)", "A skater released on a ramp: potential, kinetic and thermal bars always sum to the same total. Friction off → it returns to the same height forever; friction on → the heat bar grows and every peak is lower. Energy conservation and conversion, animated (the LOL bar chart).", energySkateSchema, (a) => /* @__PURE__ */ jsx(EnergySkateLab, { ...a }));
+const shmSchema = z.object({
+	mode: z.enum(["spring", "pendulum"]).optional(),
+	k: z.number().optional(),
+	length: z.number().optional(),
+	mass: z.number().optional(),
+	amplitude: z.number().optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const SimpleHarmonicBlock = wlab("shm", "Simple harmonic motion — spring & pendulum", "One a = −ω²x kernel, two skins. A restoring force ∝ displacement gives x(t) = A·cos(ωt), and a pen traces it out as a SINE — the bridge to the waves lessons. Spring: ω=√(k/m). Pendulum: ω=√(g/L), with the period independent of mass and amplitude. Live ω/T/f and a PE⇄KE energy split.", shmSchema, (a) => /* @__PURE__ */ jsx(SimpleHarmonicLab, { ...a }), "SimpleHarmonic");
+const atwoodSchema = z.object({
+	m1: z.number().optional(),
+	m2: z.number().optional(),
+	...common
+});
+const AtwoodBlock = wlab("atwood", "Atwood machine — two masses over a pulley", "Two masses share one rope over a pulley. Only the difference in weight drives the system while the total mass resists it: a = (m₁−m₂)g/(m₁+m₂), tension T = 2m₁m₂g/(m₁+m₂). Equal masses balance; a tiny difference on big masses gives a slow, measurable a — how Atwood weighed gravity. Predict which side falls, then release.", atwoodSchema, (a) => /* @__PURE__ */ jsx(AtwoodLab, { ...a }));
+const terminalSchema = z.object({
+	mass: z.number().optional(),
+	drag: z.number().optional(),
+	parachute: z.boolean().optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const TerminalVelocityBlock = wlab("terminal-velocity", "Terminal velocity — the skydiver (air drag)", "A fall with air resistance: drag grows with speed (∝v²) until it balances gravity, so the speed levels off at v_t = √(mg/b). The weight arrow stays fixed while the drag arrow rises to meet it and the v–t curve flattens onto its asymptote (exact tanh solution). Pop the parachute and v_t collapses to a survivable speed.", terminalSchema, (a) => /* @__PURE__ */ jsx(TerminalVelocityLab, { ...a }));
+const keplerSchema = z.object({
+	semiMajor: z.number().optional(),
+	eccentricity: z.number().optional(),
+	wedges: z.boolean().optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const KeplerBlock = wlab("kepler", "Kepler’s laws — orbits & equal areas", "A planet on a true ellipse with the star at a focus (Kepler 1). Solving Kepler’s equation makes it genuinely speed up at perihelion, and the equal-time wedges it sweeps come out equal in area (Kepler 2) — fat-and-short near the star, thin-and-long far out. Stretch the orbit and the period grows as T² ∝ a³ (Kepler 3).", keplerSchema, (a) => /* @__PURE__ */ jsx(KeplerLab, { ...a }));
+const gravitationSchema = z.object({
+	planetMass: z.number().optional(),
+	satMass: z.number().optional(),
+	...common
+});
+const GravitationBlock = wlab("gravitation", "Universal gravitation — the inverse-square law", "Newton’s F = G·M·m / r². Drag the satellite and the pull tracks 1/r²: double the distance and the force drops to a quarter (not a half). A live F–r curve marks your spot on the steep fall-off; the same law thins weight with altitude (g = GM/r²) and sets orbital speed v = √(GM/r).", gravitationSchema, (a) => /* @__PURE__ */ jsx(GravitationLab, { ...a }));
+const heatTransferSchema = z.object({
+	mode: z.enum([
+		"conduction",
+		"convection",
+		"radiation"
+	]).optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const HeatTransferBlock = wlab("heat-transfer", "Heat transfer — conduction / convection / radiation", "The three ways heat moves, each with its rate law and animation. Author a survey (all three) OR a focused lesson: set mode + controlConfig.hide=['mechanism'] to show conduction (or convection / radiation) on its own.", heatTransferSchema, (a) => /* @__PURE__ */ jsx(HeatTransferLab, { ...a }));
+const thermalExpansionSchema = z.object({
+	mode: z.enum([
+		"length",
+		"area",
+		"volume",
+		"bimetallic"
+	]).optional(),
+	controlConfig: ccSchema,
+	...common
+});
+const ThermalExpansionBlock = wlab("thermal-expansion", "Thermal expansion — length / area / volume / bimetallic", "Heat a solid and it grows: ΔL=αLΔT, ΔA=2αAΔT, ΔV=3αVΔT, plus a bimetallic-strip thermostat. Author one case (e.g. mode:'area', controlConfig.hide=['what expands']) or the full set.", thermalExpansionSchema, (a) => /* @__PURE__ */ jsx(ThermalExpansionLab, { ...a }));
+const heatingCurveSchema = z.object({
+	substance: z.enum(["water", "ethanol"]).optional().describe("preset to start from"),
+	substanceName: z.string().optional().describe("custom substance name (overrides the preset)"),
+	cSolid: z.number().optional(),
+	cLiquid: z.number().optional(),
+	cGas: z.number().optional(),
+	lFusion: z.number().optional().describe("latent heat of fusion, J/g"),
+	lVapor: z.number().optional().describe("latent heat of vaporisation, J/g"),
+	tMelt: z.number().optional(),
+	tBoil: z.number().optional(),
+	mass: z.number().optional().describe("initial sample mass, g"),
+	power: z.number().optional().describe("initial heating power, W (negative cools)"),
+	...common
+});
+const HeatingCurveBlock = wlab("heating-curve", "Heating curve — q=mcΔθ runs + latent plateaus", "Pour heat into ice and watch temperature climb in steps: sloped runs where a phase warms (q=mcΔθ) and flat plateaus where it melts/boils (q=mL). Burner + beaker + thermometer beside the live curve. AUTHOR the model: pick a preset OR declare a custom substance (specific + latent heats, melt/boil points) and the starting mass/power.", heatingCurveSchema, (a) => /* @__PURE__ */ jsx(HeatingCurveLab, { ...a }));
+const gasProcessSchema = z.object({
+	kind: z.enum([
+		"isothermal",
+		"adiabatic",
+		"isobaric",
+		"isochoric"
+	]).optional(),
+	gas: z.enum(["monatomic", "diatomic"]).optional(),
+	moles: z.number().optional(),
+	tempK: z.number().optional().describe("initial temperature, K"),
+	volumeL: z.number().optional().describe("initial volume, L"),
+	...common
+});
+const GasProcessBlock = wlab("gas-process", "Gas processes — work = area under P–V", "Expand/compress an ideal gas isothermally, adiabatically, isobarically or isochorically. The shaded area under the P–V curve is the work; the first law ΔU = Q − W balances every term. A faint reference isotherm shows the adiabatic falling steeper.", gasProcessSchema, (a) => /* @__PURE__ */ jsx(GasProcessLab, { ...a }));
+const carnotSchema = z.object({
+	hotK: z.number().optional().describe("hot reservoir temperature, K"),
+	coldK: z.number().optional().describe("cold reservoir temperature, K"),
+	gas: z.enum(["monatomic", "diatomic"]).optional(),
+	expansionRatio: z.number().optional().describe("isothermal expansion V₂/V₁"),
+	...common
+});
+const CarnotBlock = wlab("carnot", "Carnot cycle — P–V loop + T–S rectangle", "The most efficient heat engine, shown as a P–V loop (enclosed area = net work) and the same cycle as a T–S rectangle (heat in at Th, out at Tc). Efficiency η = 1 − Tc/Th, with the entropy bookkeeping ΔS = Qh/Th = Qc/Tc → net 0.", carnotSchema, (a) => /* @__PURE__ */ jsx(CarnotCycleLab, { ...a }));
+const entropySchema = z.object({
+	mode: z.enum(["heat", "expansion"]).optional(),
+	...common
+});
+const EntropyBlock = wlab("entropy", "Entropy & the 2nd law — the one-way arrow", "Why heat flows hot→cold (ΔS_total = Q/Tc − Q/Th > 0) and a gas spreads into a vacuum (ΔS = nR·ln Vf/Vi). The total entropy of the universe always increases. Two modes: heat flow and free expansion.", entropySchema, (a) => /* @__PURE__ */ jsx(EntropyLab, { ...a }));
+const tempScalesSchema = z.object({ ...common });
+const TemperatureScalesBlock = wlab("temperature-scales", "Temperature scales — °C / °F / K", "One mercury column read against Celsius, Fahrenheit and Kelvin at once (F = 9⁄5·C + 32, K = C + 273.15). Fixed points marked; jump to absolute zero, ice, body, boiling. Shows why Kelvin starts at absolute zero.", tempScalesSchema, (a) => /* @__PURE__ */ jsx(TemperatureScalesLab, { ...a }));
+const waterDensitySchema = z.object({
+	mode: z.enum(["anomaly", "lake"]).optional(),
+	...common
+});
+const WaterDensityBlock = wlab("water-density", "Water’s 4 °C anomaly — why ice floats", "Water is densest at 4 °C and expands again toward freezing, so ice floats. Drag the temperature on the density curve, or switch to the lake view to see why a pond freezes top-down (4 °C water and fish survive below the ice).", waterDensitySchema, (a) => /* @__PURE__ */ jsx(WaterDensityLab, { ...a }));
+const efficiencySchema = z.object({
+	device: z.enum([
+		"incandescent",
+		"led",
+		"petrol-engine",
+		"electric-motor",
+		"power-station",
+		"human"
+	]).optional(),
+	deviceName: z.string().optional(),
+	inputJoules: z.number().optional().describe("energy supplied, J (100 → shares read as %)"),
+	streams: z.array(z.object({
+		label: z.string(),
+		share: z.number(),
+		kind: z.enum(["useful", "waste"]),
+		color: z.string().optional()
+	})).optional().describe("author your own energy breakdown"),
+	...common
+});
+const EfficiencyBlock = wlab("efficiency", "Efficiency — input→output ratio (Sankey)", "Efficiency as the fraction of energy that comes out useful: η = useful ÷ input, drawn as a Sankey energy flow that splits into a useful stream and wasted heat. Compare real devices (incandescent vs LED, engine vs motor) or AUTHOR your own breakdown via the streams field.", efficiencySchema, (a) => /* @__PURE__ */ jsx(EfficiencyLab, { ...a }));
+const physicsBlocks = [
+	ProjectileLabBlock,
+	OrbitLabBlock,
+	GravityDropBlock,
+	RiverBoatBlock,
+	OpticsBlock,
+	LeverBlock,
+	VectorBoardBlock,
+	VectorTypesBlock,
+	RainRelativeBlock,
+	StoppingDistanceBlock,
+	RampForcesBlock,
+	CollisionTrackBlock,
+	WaveBlock,
+	RippleTankBlock,
+	DopplerBlock,
+	StringReflectionBlock,
+	MagnetismBlock,
+	LorentzBlock,
+	ImpulseBlock,
+	BulletWallsBlock,
+	CircularMotionBlock,
+	EnergySkateBlock,
+	SimpleHarmonicBlock,
+	AtwoodBlock,
+	TerminalVelocityBlock,
+	KeplerBlock,
+	GravitationBlock,
+	HeatTransferBlock,
+	ThermalExpansionBlock,
+	HeatingCurveBlock,
+	GasProcessBlock,
+	CarnotBlock,
+	EntropyBlock,
+	TemperatureScalesBlock,
+	WaterDensityBlock,
+	EfficiencyBlock
+];
+const physicsComponents = {
+	...buildComponents(physicsBlocks),
+	VectorBoard: VectorBoardView,
+	VectorTypes: VectorTypesLab,
+	RainRelative: RainRelativeLab,
+	StoppingDistance: StoppingDistanceLab,
+	RampForces: RampForcesLab,
+	CollisionTrack: CollisionTrackLab,
+	Optics: OpticsLab,
+	Lever: LeverPuzzle,
+	ProjectileLab,
+	RiverBoat,
+	OrbitLab,
+	GravityDrop
+};
+
+//#endregion
+export { AtwoodBlock, BulletWallsBlock, CarnotBlock, CircularMotionBlock, CollisionTrackBlock, DopplerBlock, EfficiencyBlock, EnergySkateBlock, EntropyBlock, GasProcessBlock, GravitationBlock, GravityDropBlock, HeatTransferBlock, HeatingCurveBlock, ImpulseBlock, KeplerBlock, LeverBlock, LeverPuzzle, LorentzBlock, MagnetismBlock, OpticsBlock, OrbitLabBlock, ProjectileLabBlock, RainRelativeBlock, RampForcesBlock, RippleTankBlock, RiverBoatBlock, SimpleHarmonicBlock, StoppingDistanceBlock, StringReflectionBlock, TemperatureScalesBlock, TerminalVelocityBlock, ThermalExpansionBlock, VectorBoardBlock, VectorTypesBlock, WaterDensityBlock, WaveBlock, physicsBlocks, physicsComponents };