@classytic/labs 0.2.0 → 0.3.0

package/dist/domains/physics/projectile-lab/runtime/svg.mjs

@@ -0,0 +1,208 @@
+'use client';
+
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Circle, Dot, Label, Polyline, Segment, Stage, StageAssetDefs, fmt, useCoords } from "@classytic/stage";
+
+//#region src/domains/physics/projectile-lab/runtime/svg.tsx
+const WORLD_W = 130;
+/** A field cannon at the origin, elevated to `angle`. Static local coords rotated via an
+*  SVG transform (no transcendental-derived coordinate is serialized — SSR-deterministic). */
+function CannonGlyph({ angle }) {
+	const c = useCoords();
+	const [ox, oy] = c.toPx(0, 0);
+	const s = c.sx(1);
+	const L = 13 * s, hw = 1.7 * s;
+	const grad = "url(#stage-grad-metal)";
+	const metal = "var(--stage-metal)";
+	const edge = "color-mix(in oklab, var(--stage-metal) 60%, black)";
+	const dark = "color-mix(in oklab, var(--stage-metal) 42%, black)";
+	const sheen = "color-mix(in oklab, var(--stage-sheen) 45%, transparent)";
+	const T = `translate(${fmt(ox)},${fmt(oy)})`;
+	const spokes = Array.from({ length: 6 }, (_, i) => {
+		const a = i * Math.PI / 3;
+		return {
+			x: fmt(s * 2.2 * Math.cos(a)),
+			y: fmt(s * 2.2 * Math.sin(a))
+		};
+	});
+	return /* @__PURE__ */ jsxs("g", { children: [
+		/* @__PURE__ */ jsx(StageAssetDefs, {}),
+		/* @__PURE__ */ jsxs("g", {
+			transform: `${T} rotate(${fmt(-angle)})`,
+			children: [
+				/* @__PURE__ */ jsx("circle", {
+					cx: -s * 1.3,
+					cy: 0,
+					r: hw * 1.15,
+					fill: grad,
+					stroke: edge,
+					strokeWidth: .7
+				}),
+				/* @__PURE__ */ jsx("path", {
+					d: `M 0 ${-hw * .92} L ${L * .84} ${-hw * .78} L ${L * .84} ${-hw} L ${L} ${-hw} L ${L} ${hw} L ${L * .84} ${hw} L ${L * .84} ${hw * .78} L 0 ${hw * .92} Z`,
+					fill: grad,
+					stroke: edge,
+					strokeWidth: .7,
+					strokeLinejoin: "round"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: L * .4,
+					y1: -hw * .95,
+					x2: L * .4,
+					y2: hw * .95,
+					stroke: dark,
+					strokeWidth: 1.6
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: L * .72,
+					y1: -hw,
+					x2: L * .72,
+					y2: hw,
+					stroke: dark,
+					strokeWidth: 1.6
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: s * .4,
+					y1: -hw * .5,
+					x2: L * .8,
+					y2: -hw * .5,
+					stroke: sheen,
+					strokeWidth: 1.2,
+					strokeLinecap: "round"
+				}),
+				/* @__PURE__ */ jsx("ellipse", {
+					cx: L,
+					cy: 0,
+					rx: hw * .22,
+					ry: hw * .9,
+					fill: dark
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs("g", {
+			transform: T,
+			children: [
+				/* @__PURE__ */ jsx("circle", {
+					cx: 0,
+					cy: 0,
+					r: s * 2.2,
+					fill: "var(--stage-bg)",
+					stroke: metal,
+					strokeWidth: 2
+				}),
+				spokes.map((p, i) => /* @__PURE__ */ jsx("line", {
+					x1: 0,
+					y1: 0,
+					x2: p.x,
+					y2: p.y,
+					stroke: metal,
+					strokeWidth: 1.2
+				}, i)),
+				/* @__PURE__ */ jsx("circle", {
+					cx: 0,
+					cy: 0,
+					r: s * .7,
+					fill: metal
+				})
+			]
+		})
+	] });
+}
+function ProjectileSvg({ angle, target, peak, arc, ball }) {
+	const view = {
+		xMin: -5,
+		xMax: WORLD_W,
+		yMin: -4,
+		yMax: Math.max(40, peak + 12)
+	};
+	return /* @__PURE__ */ jsxs(Stage, {
+		view,
+		height: 300,
+		ariaLabel: `Projectile launched at ${angle}°; target at ${target} m`,
+		children: [
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: view.xMin,
+					y: 0
+				},
+				to: {
+					x: WORLD_W,
+					y: 0
+				},
+				color: "var(--stage-fg)",
+				opacity: .5,
+				weight: 1.5
+			}),
+			[
+				0,
+				20,
+				40,
+				60,
+				80,
+				100,
+				120
+			].map((m) => /* @__PURE__ */ jsx(Label, {
+				x: m,
+				y: 0,
+				text: `${m}m`,
+				color: "var(--stage-fg)",
+				size: 10,
+				dy: 14
+			}, m)),
+			/* @__PURE__ */ jsx(Circle, {
+				center: {
+					x: target,
+					y: 2.6
+				},
+				r: 2.6,
+				color: "var(--stage-accent-2)",
+				fill: "none",
+				weight: 2
+			}),
+			/* @__PURE__ */ jsx(Circle, {
+				center: {
+					x: target,
+					y: 2.6
+				},
+				r: 1.1,
+				color: "var(--stage-accent-2)",
+				fill: "var(--stage-accent-2)",
+				fillOpacity: .9,
+				weight: 0
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: target,
+				y: 2.6,
+				text: "target",
+				color: "var(--stage-accent-2)",
+				size: 11,
+				dy: -22
+			}),
+			/* @__PURE__ */ jsx(CannonGlyph, { angle }),
+			/* @__PURE__ */ jsx(Polyline, {
+				points: arc,
+				color: "var(--stage-accent)",
+				opacity: .55,
+				weight: 1.5,
+				dashed: true
+			}),
+			/* @__PURE__ */ jsx(Circle, {
+				center: ball,
+				r: 1.4,
+				color: "var(--stage-good)",
+				fill: "var(--stage-good)",
+				fillOpacity: .25,
+				weight: 0
+			}),
+			/* @__PURE__ */ jsx(Dot, {
+				x: ball.x,
+				y: ball.y,
+				r: 5,
+				color: "var(--stage-good)"
+			})
+		]
+	});
+}
+
+//#endregion
+export { ProjectileSvg };

package/dist/domains/physics/quantum-gates/activity.mjs

@@ -0,0 +1,3 @@
+import { quantumGatesActivity } from "../../../physics/modern/quantum/gates-activity.mjs";
+
+export { quantumGatesActivity as activity };

package/dist/domains/physics/quantum-gates/manifest.mjs

@@ -0,0 +1,68 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/quantum-gates/manifest.ts
+var manifest_default = defineLab({
+	id: "quantum-gates",
+	tag: "QuantumGateJourneyLab",
+	domain: "physics",
+	group: "Modern Physics",
+	title: "Quantum gate journey",
+	description: "Build short quantum programs and watch unitary gates transform one shared qubit state.",
+	schema: z.object({
+		targetSequence: z.array(z.enum([
+			"x",
+			"z",
+			"h",
+			"s"
+		])).max(12).default([
+			"h",
+			"z",
+			"h"
+		]),
+		activity: authoredActivitySchema.optional(),
+		...commonLabProps
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"physics",
+			"quantum",
+			"qubit",
+			"quantum-gates",
+			"unitary",
+			"amplitude"
+		],
+		durationMinutes: 20,
+		interaction: "build",
+		authorability: "moderate",
+		prerequisites: ["bloch-sphere"],
+		related: ["bloch-sphere"]
+	},
+	experience: {
+		objectives: [
+			"Interpret gates as reversible state transformations",
+			"Connect H to superposition and phase gates to longitude",
+			"Predict a short gate sequence"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/quantum-gates/runtime.mjs

@@ -0,0 +1,3 @@
+import { QuantumGateJourneyLab } from "../../../physics/modern/quantum/gates-preset.mjs";
+
+export { QuantumGateJourneyLab, QuantumGateJourneyLab as default };

package/dist/domains/physics/rain-relative/manifest.mjs

@@ -0,0 +1,54 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/rain-relative/manifest.ts
+var manifest_default = defineLab({
+	id: "rain-relative",
+	domain: "physics",
+	group: "Physics",
+	title: "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.",
+	schema: z.object({
+		maxSpeed: z.number().finite().min(1).max(40).default(10),
+		start: z.number().finite().min(0).max(40).default(0),
+		title: z.string().trim().min(1).optional(),
+		prompt: z.string().trim().min(1).optional(),
+		objectives: z.array(z.string().trim().min(1)).min(1).optional(),
+		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+	}).refine(({ start, maxSpeed }) => start <= maxSpeed, {
+		message: "start speed must not exceed maxSpeed",
+		path: ["start"]
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: ["vectors", "relative-velocity"],
+		durationMinutes: 10,
+		interaction: "explorer",
+		authorability: "simple"
+	},
+	experience: {
+		objectives: [
+			"Subtract velocities in different frames",
+			"Relate relative components to apparent angle",
+			"Transfer relative velocity to a new moving observer"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/rain-relative/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { RainRelativeLab } from "../../../physics/rain-relative/preset.mjs";
+
+export { RainRelativeLab as default };

package/dist/domains/physics/ramp-forces/manifest.mjs

@@ -0,0 +1,65 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { controlConfigSchema } from "../../../schemas/index.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/ramp-forces/manifest.ts
+var manifest_default = defineLab({
+	id: "ramp-forces",
+	domain: "physics",
+	group: "Physics",
+	title: "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θ).",
+	schema: z.object({
+		angleDeg: z.number().min(0).max(75).finite().default(25),
+		mass: z.number().min(1).max(10).finite().default(2),
+		friction: z.number().min(0).max(1).finite().default(.4),
+		frictionKinetic: z.number().min(0).max(1).finite().default(.3),
+		appliedN: z.number().min(-30).max(30).finite().default(0),
+		g: z.number().positive().max(30).finite().default(9.8),
+		showComponents: z.boolean().default(false),
+		title: z.string().trim().min(1).optional(),
+		prompt: z.string().trim().min(1).optional(),
+		objectives: z.array(z.string().trim().min(1)).min(1).optional(),
+		controls: controlConfigSchema.optional(),
+		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+	}).refine(({ friction, frictionKinetic }) => frictionKinetic <= friction, {
+		message: "kinetic friction must not exceed static friction",
+		path: ["frictionKinetic"]
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"dynamics",
+			"friction",
+			"inclined-plane"
+		],
+		durationMinutes: 15,
+		interaction: "explorer",
+		authorability: "advanced"
+	},
+	experience: {
+		objectives: [
+			"Resolve weight into ramp-aligned components",
+			"Distinguish static and kinetic friction",
+			"Use the force sum to predict acceleration"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/ramp-forces/runtime.mjs

@@ -0,0 +1,25 @@
+'use client';
+
+import { RampForcesLab } from "../../../physics/ramp-forces/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/physics/ramp-forces/runtime.tsx
+function RampForces(a) {
+	return /* @__PURE__ */ jsx(RampForcesLab, {
+		angleDeg: a.angleDeg,
+		mass: a.mass,
+		friction: a.friction,
+		frictionKinetic: a.frictionKinetic,
+		appliedN: a.appliedN,
+		g: a.g,
+		showComponents: a.showComponents,
+		title: a.title,
+		prompt: a.prompt,
+		objectives: a.objectives,
+		activity: a.activity,
+		controlConfig: a.controls
+	});
+}
+
+//#endregion
+export { RampForces as default };

package/dist/domains/physics/refraction/manifest.mjs

@@ -0,0 +1,60 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/refraction/manifest.ts
+var manifest_default = defineLab({
+	id: "refraction",
+	domain: "physics",
+	group: "Physics",
+	title: "Refraction & total internal reflection (Snell’s law)",
+	description: "A ray crossing between two media bends per n₁sinθ₁ = n₂sinθ₂: toward the normal into a denser medium, away out of it. Past the critical angle (dense → rare) it can’t escape — total internal reflection (optical fibres). Author the two indices (or material presets) and the angle to spin up air→glass, glass→water, diamond… endless quiz variants. Predict-first.",
+	schema: z.object({
+		n1: z.number().finite().positive().max(5).optional().describe("refractive index of the top medium"),
+		n2: z.number().finite().positive().max(5).optional().describe("refractive index of the bottom medium"),
+		angle: z.number().finite().min(0).max(89).optional().describe("angle of incidence, degrees from the normal"),
+		materials: z.array(z.object({
+			label: z.string().trim().min(1),
+			n: z.number().finite().positive().max(5)
+		})).min(2).optional().describe("material presets offered as chips"),
+		height: z.number().int().min(280).max(720).optional(),
+		...commonLabProps,
+		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"optics",
+			"refraction",
+			"snells-law"
+		],
+		durationMinutes: 12,
+		interaction: "predict",
+		authorability: "moderate"
+	},
+	experience: {
+		objectives: [
+			"Apply Snell’s law",
+			"Predict whether light bends toward or away from the normal",
+			"Identify the critical angle and total internal reflection"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/refraction/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { RefractionLab } from "../../../physics/optics/refraction.mjs";
+
+export { RefractionLab as default };

package/dist/domains/physics/relativity-light-clock/activity.mjs

@@ -0,0 +1,3 @@
+import { lightClockActivity } from "../../../physics/modern/relativity/activity.mjs";
+
+export { lightClockActivity as activity };

package/dist/domains/physics/relativity-light-clock/manifest.mjs

@@ -0,0 +1,67 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/relativity-light-clock/manifest.ts
+var manifest_default = defineLab({
+	id: "relativity-light-clock",
+	tag: "RelativityLightClockLab",
+	domain: "physics",
+	group: "Modern Physics",
+	title: "Light clocks and time dilation",
+	description: "Link a moving light-clock experiment, clock ledger, and spacetime diagram through one relativistic event model.",
+	schema: z.object({
+		beta: z.number().min(0).max(.995).default(.6),
+		properTick: z.number().positive().max(100).default(2),
+		view: z.enum([
+			"experiment",
+			"spacetime",
+			"linked"
+		]).default("linked"),
+		betaMin: z.number().min(0).max(.99).default(0),
+		betaMax: z.number().positive().max(.995).default(.95),
+		activity: authoredActivitySchema.optional(),
+		...commonLabProps
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"physics",
+			"modern-physics",
+			"special-relativity",
+			"time-dilation",
+			"proper-time",
+			"spacetime"
+		],
+		durationMinutes: 18,
+		interaction: "explorer",
+		authorability: "moderate",
+		prerequisites: ["vector-types"],
+		related: ["spatial-lorentz"]
+	},
+	experience: {
+		objectives: [
+			"Distinguish proper time from coordinate time",
+			"Derive time dilation from a longer light path",
+			"Read the same events in a spacetime diagram"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/relativity-light-clock/runtime.mjs

@@ -0,0 +1,12 @@
+'use client';
+
+import { RelativityLightClockLab } from "../../../physics/modern/relativity/preset.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/physics/relativity-light-clock/runtime.tsx
+function Runtime(p) {
+	return /* @__PURE__ */ jsx(RelativityLightClockLab, { ...p });
+}
+
+//#endregion
+export { Runtime as default };

package/dist/domains/physics/relativity-simultaneity/activity.mjs

@@ -0,0 +1,3 @@
+import { simultaneityActivity } from "../../../physics/modern/relativity/simultaneity-activity.mjs";
+
+export { simultaneityActivity as activity };

package/dist/domains/physics/relativity-simultaneity/manifest.mjs

@@ -0,0 +1,59 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { commonLabProps } from "../../../blocks/lab-block.mjs";
+import { authoredActivitySchema } from "../../../schemas/activity-authoring.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/relativity-simultaneity/manifest.ts
+var manifest_default = defineLab({
+	id: "relativity-simultaneity",
+	tag: "RelativitySimultaneityLab",
+	domain: "physics",
+	group: "Modern Physics",
+	title: "Relativity of simultaneity",
+	description: "Transform the same pair of separated flash events between platform and train frames.",
+	schema: z.object({
+		beta: z.number().min(-.995).max(.995).default(.6),
+		separationM: z.number().positive().max(1e7).default(300),
+		activity: authoredActivitySchema.optional(),
+		...commonLabProps
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"physics",
+			"modern-physics",
+			"special-relativity",
+			"simultaneity",
+			"lorentz-transform"
+		],
+		durationMinutes: 16,
+		interaction: "explorer",
+		authorability: "moderate",
+		prerequisites: ["relativity-light-clock"],
+		related: ["relativity-light-clock", "muon-survival"]
+	},
+	experience: {
+		objectives: [
+			"Define simultaneity using synchronized clocks",
+			"Transform separated events between frames",
+			"Distinguish emission time from light-arrival time"
+		],
+		phases: [
+			"predict",
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/relativity-simultaneity/runtime.mjs

@@ -0,0 +1,3 @@
+import { RelativitySimultaneityLab } from "../../../physics/modern/relativity/simultaneity-preset.mjs";
+
+export { RelativitySimultaneityLab, RelativitySimultaneityLab as default };