@classytic/labs 0.4.0 → 0.5.0

package/dist/domains/physics/gas-process/manifest.mjs

@@ -22,7 +22,11 @@ var manifest_default = defineLab({
 		tempK: z.number().finite().min(100).max(1200).optional(),
 		volumeL: z.number().finite().min(1).max(100).optional(),
 		...commonLabProps,
-		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+		activity: z.union([
+			z.literal(false),
+			z.string().trim().min(1),
+			authoredActivitySchema
+		]).optional()
 	}),
 	taxonomy: {
 		grades: ["11", "12"],

package/dist/domains/physics/gas-theory/manifest.mjs

@@ -0,0 +1,70 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/gas-theory/manifest.ts
+var manifest_default = defineLab({
+	id: "gas-theory",
+	tag: "GasTheory",
+	domain: "physics",
+	group: "Physics",
+	title: "Molecular gas theory",
+	description: "Connect molecular speeds and energy to ideal and real gas behaviour.",
+	schema: z.object({
+		focus: z.enum([
+			"rms",
+			"energy",
+			"real-gas"
+		]).default("rms"),
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		temperatureK: z.number().positive().optional(),
+		speeds: z.array(z.number().nonnegative()).min(1).optional()
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"rms-speed",
+			"molecular-energy",
+			"real-gas-deviation"
+		],
+		durationMinutes: 5,
+		interaction: "explorer",
+		authorability: "simple",
+		representation: "carrier",
+		levels: ["a-level"],
+		qualityTier: "flagship",
+		primaryMechanic: "particle-investigation",
+		learnerAction: "change gas conditions and compare molecular and macroscopic models",
+		evidenceTypes: ["calculation", "observation"],
+		mobileMode: "investigation",
+		misconceptions: [
+			"rms speed is the arithmetic mean",
+			"all gases move at the same speed at equal temperature",
+			"the ideal gas law is exact at every density"
+		],
+		related: ["gas-box", "gas-process"]
+	},
+	experience: {
+		objectives: [
+			"Calculate an rms speed.",
+			"Relate temperature to mean translational energy.",
+			"Explain why real gases depart from the ideal model."
+		],
+		phases: [
+			"act",
+			"observe",
+			"explain",
+			"transfer"
+		],
+		responses: ["numeric", "reflection"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/physics/gas-theory/runtime.mjs

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

package/dist/domains/physics/generator-grid-mission/manifest.mjs

@@ -49,7 +49,7 @@ var manifest_default = defineLab({
 			"frequency is read directly from horizontal divisions"
 		],
 		related: [
-			"magnetic-field-mission",
+			"ac-generator",
 			"alternating-current",
 			"wave-lab",
 			"magnetism"

package/dist/domains/physics/generator-grid-mission/model.mjs

@@ -0,0 +1,26 @@
+import { oscilloscopeReading } from "../../../physics/magnetism/formula-core.mjs";
+import { createSignalScopeWorld, sampleElectronicsInstruments } from "@classytic/stage/circuit";
+
+//#region src/domains/physics/generator-grid-mission/model.ts
+/** Convert screen divisions into a real Stage generator/scope bench and verify both peaks. */
+function generatorScopeBench(verticalDivisions, voltsPerDivision, periodDivisions, secondsPerDivision) {
+	const scale = oscilloscopeReading(verticalDivisions, voltsPerDivision, periodDivisions, secondsPerDivision);
+	const world = createSignalScopeWorld({
+		waveform: "sine",
+		amplitudeV: scale.peakVoltageV,
+		frequencyHz: scale.frequencyHz
+	});
+	const scopeAt = (timeS) => {
+		const scope = sampleElectronicsInstruments(world, timeS).find((reading) => reading.id === "scope");
+		if (scope?.channelA === void 0) throw new Error("Generator scope channel is unavailable.");
+		return scope.channelA;
+	};
+	return {
+		...scale,
+		positivePeakV: scopeAt(scale.periodS / 4),
+		negativePeakV: scopeAt(3 * scale.periodS / 4)
+	};
+}
+
+//#endregion
+export { generatorScopeBench };

package/dist/domains/physics/generator-grid-mission/runtime.mjs

@@ -1,13 +1,14 @@
 'use client';
 
 import { Tex } from "../../../core/tex.mjs";
-import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
 import { Figure } from "../../../kit/figure/figure.mjs";
 import { GAUGE } from "../../../kit/figure/gauge.mjs";
 import { FigText } from "../../../kit/figure/text.mjs";
-import { oscilloscopeReading, transformerSecondaryVoltageV, transmissionCurrentA, transmissionLossW } from "../../../physics/magnetism/formula-core.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { transformerSecondaryVoltageV, transmissionCurrentA, transmissionLossW } from "../../../physics/magnetism/formula-core.mjs";
 import { activity } from "./activity.mjs";
 import { HALL, LAMP } from "./palette.mjs";
+import { generatorScopeBench } from "./model.mjs";
 import { jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/domains/physics/generator-grid-mission/runtime.tsx
@@ -331,7 +332,7 @@ function GridFigure() {
 	});
 }
 function ScopeFigure() {
-	const reading = oscilloscopeReading(3, 2, 4, .005);
+	const reading = generatorScopeBench(3, 2, 4, .005);
 	const gx = 72, gy = 42, cw = 44, ch = 30;
 	return /* @__PURE__ */ jsxs(Figure, {
 		viewBox: [520, 300],

package/dist/domains/physics/glass-block-refraction/runtime.mjs

@@ -2,18 +2,19 @@
 
 import { CheckButton, Chip, Slider } from "../../../kit/controls.mjs";
 import { Field, LiveRegion, Readout, Stat, StatList } from "../../../kit/frame.mjs";
-import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../../kit/authored-activity-runtime.mjs";
 import { Figure, HUE } from "../../../kit/figure/figure.mjs";
 import { FigText } from "../../../kit/figure/text.mjs";
 import { Ball } from "../../../kit/figure/body.mjs";
 import { Ray } from "../../../kit/figure/beam.mjs";
 import { Curve, Marker, PlotFrame, scale } from "../../../kit/figure/plot.mjs";
+import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../../kit/authored-activity-runtime.mjs";
 import { createInvestigationMachine } from "../../../physics/investigation/engine.mjs";
 import { glassBlockRefractionScenario } from "../../../physics/investigation/refraction.mjs";
 import { activity } from "./activity.mjs";
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-import { refractAngleDeg } from "@classytic/stage/optics";
+import { createLightPathWorld } from "@classytic/stage/optics";
+import { createWorldSnapshot } from "@classytic/stage/world";
 
 //#region src/domains/physics/glass-block-refraction/runtime.tsx
 function GlassBlockRefraction({ title = "Laser Vault", prompt = "Aim through glass. Can you predict the bend and catch a false alignment?", seed = 53 }) {
@@ -27,7 +28,17 @@ function GlassBlockRefraction({ title = "Laser Vault", prompt = "Aim through gla
 	const anomalous = Boolean(latest?.flags?.includes("anomalous"));
 	const i = state.controls.incidenceDeg;
 	const { incidentIndex, blockIndex } = glassBlockRefractionScenario.setup;
-	const r = refractAngleDeg(i, incidentIndex, blockIndex) ?? 0;
+	const opticalWorld = useMemo(() => createLightPathWorld("glass-block", {
+		incidenceDeg: i,
+		outsideIndex: incidentIndex,
+		materialIndex: blockIndex
+	}), [
+		blockIndex,
+		i,
+		incidentIndex
+	]);
+	const opticalState = useMemo(() => createWorldSnapshot(opticalWorld), [opticalWorld]).doc.entities[0].state;
+	const r = Number(opticalState.refractionDeg);
 	const toggle = (id) => dispatch({
 		type: "select-apparatus",
 		ids: state.apparatus.includes(id) ? state.apparatus.filter((x) => x !== id) : [...state.apparatus, id]

package/dist/domains/physics/graph-craft/manifest.mjs

@@ -0,0 +1,67 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/graph-craft/manifest.ts
+var manifest_default = defineLab({
+	id: "graph-craft",
+	tag: "GraphCraft",
+	domain: "physics",
+	group: "Physics",
+	title: "Graph craft",
+	description: "Compare graph scales and gradient triangles using calculated coverage, gradient and intercept. Lessons can pass their own readings and axis labels, and the two scales are worked out from that data.",
+	schema: z.object({
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		mode: z.enum(["scale", "gradient"]).default("scale"),
+		points: z.array(z.tuple([z.number().finite(), z.number().finite()])).min(3).max(12).optional().describe("the lesson's own [x, y] readings; for gradient mode they should lie on a line"),
+		xLabel: z.string().trim().max(32).optional().describe("x-axis label as quantity / unit, e.g. \"time / s\""),
+		yLabel: z.string().trim().max(32).optional().describe("y-axis label as quantity / unit, e.g. \"volume of gas / cm³\"")
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"graph-scale",
+			"gradient",
+			"intercept"
+		],
+		durationMinutes: 4,
+		interaction: "explorer",
+		authorability: "simple",
+		representation: "carrier",
+		levels: ["a-level"],
+		qualityTier: "flagship",
+		primaryMechanic: "classification",
+		learnerAction: "compare graph choices and identify the stronger measurement",
+		evidenceTypes: ["calculation", "observation"],
+		mobileMode: "observation",
+		misconceptions: [
+			"a graph should always start at zero",
+			"gradient points must be raw data points",
+			"a small gradient triangle is equally reliable"
+		],
+		related: ["paper5-analysis-lab", "physics-practical-studio"]
+	},
+	experience: {
+		objectives: [
+			"Choose a readable scale.",
+			"Measure a line with a large triangle.",
+			"Calculate a true intercept when the origin is suppressed."
+		],
+		phases: [
+			"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/graph-craft/runtime.mjs

@@ -0,0 +1,161 @@
+'use client';
+
+import { Segmented } from "../../../kit/controls.mjs";
+import { Activity } from "../../../kit/activity.mjs";
+import { Stat, StatList } from "../../../kit/frame.mjs";
+import { Figure, HUE } from "../../../kit/figure/figure.mjs";
+import { FigText } from "../../../kit/figure/text.mjs";
+import { Curve, Marker, PlotFrame, scale } from "../../../kit/figure/plot.mjs";
+import { decimalsFor, fittingStep, nextNiceStep, niceCeil } from "../../../physics/practical-data/scale.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { graphCoverage, straightLineThrough } from "@classytic/stage/physics";
+
+//#region src/domains/physics/graph-craft/runtime.tsx
+const POINTS = [
+	[.2, 1.4],
+	[.35, 2.25],
+	[.5, 3.02],
+	[.65, 3.91],
+	[.8, 4.7]
+];
+/** Squares across the grid the scale is judged against. */
+const SQUARES = 10;
+function GraphCraft({ title = "Make the graph earn its space", prompt = "Compare two choices. A useful graph spreads the evidence out and measures the line, not a convenient dot.", mode = "scale", points: authored, xLabel = "x", yLabel = "y" }) {
+	const [caseId, setCaseId] = useState("good");
+	const own = authored && authored.length >= 3 ? [...authored].sort((a, b) => a[0] - b[0]) : null;
+	const data = own ?? POINTS;
+	const xs = data.map((p) => p[0]);
+	const ys = data.map((p) => p[1]);
+	const xMin = Math.min(...xs);
+	const xMax = Math.max(...xs);
+	const goodStep = own ? fittingStep(xMin, xMax, SQUARES) : .05;
+	let weakStep = own ? nextNiceStep(goodStep) : .1;
+	for (let guard = 0; own && guard < 6 && graphCoverage(xMin, xMax, weakStep, SQUARES).meetsHalfGridRule; guard++) weakStep = nextNiceStep(weakStep);
+	const unitsPerSquare = caseId === "good" ? goodStep : weakStep;
+	const scaleData = own ? {
+		min: xMin,
+		max: xMax
+	} : {
+		min: .12,
+		max: .44
+	};
+	const coverage = graphCoverage(scaleData.min, scaleData.max, unitsPerSquare, SQUARES);
+	const goodFrom = Math.floor(scaleData.min / goodStep + 1e-9) * goodStep;
+	const weakFrom = scaleData.max <= SQUARES * weakStep ? 0 : Math.floor(scaleData.min / weakStep + 1e-9) * weakStep;
+	const yTop = own ? niceCeil(Math.max(...ys)) : .5;
+	const yBottom = own ? Math.min(0, Math.min(...ys)) : 0;
+	const first = data[0];
+	const lastPoint = data[data.length - 1];
+	const line = straightLineThrough(first, lastPoint);
+	const mid = Math.floor((data.length - 1) / 2);
+	const selectedPoints = caseId === "good" ? [first, lastPoint] : own ? [data[mid], data[mid + 1]] : [POINTS[2], POINTS[3]];
+	const selectedLine = straightLineThrough(selectedPoints[0], selectedPoints[1]);
+	const plot = {
+		x: 58,
+		y: 24,
+		w: 390,
+		h: 176
+	};
+	const xPad = (xMax - xMin) * .15 || 1;
+	const yMinData = Math.min(...ys);
+	const yMaxData = Math.max(...ys);
+	const yPad = (yMaxData - yMinData) * .15 || 1;
+	const axes = mode === "scale" ? scale(plot, caseId === "good" ? [goodFrom, goodFrom + (own ? SQUARES * goodStep : .5)] : [weakFrom, weakFrom + (own ? SQUARES * weakStep : 1)], [yBottom, yTop]) : own ? scale(plot, [xMin - xPad, xMax + xPad], [yMinData - yPad, yMaxData + yPad]) : scale(plot, [.1, .9], [.5, 5.2]);
+	const plotted = mode === "scale" && !own ? [
+		[.12, .1],
+		[.2, .18],
+		[.28, .26],
+		[.36, .34],
+		[.44, .42]
+	] : data;
+	const lineFrom = own ? xMin - xPad * .5 : .15;
+	const lineTo = own ? xMax + xPad * .5 : .85;
+	const feedback = mode === "scale" ? coverage.meetsHalfGridRule ? "Good scale: the data uses more than half the available width." : "Too compressed: this scale uses less than half the available width." : caseId === "good" ? "Large triangle: distant points reduce the effect of reading error." : "Small triangle: the same coordinate error changes the gradient more.";
+	const stepDecimals = decimalsFor(goodStep);
+	const stepLabel = (step) => `${step.toFixed(stepDecimals)} per square`;
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		focusLayout: "compact",
+		children: [
+			/* @__PURE__ */ jsx(Activity.Header, { children: /* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Graph craft",
+				title,
+				description: prompt
+			}) }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [/* @__PURE__ */ jsx(Activity.Canvas, {
+				"aria-label": feedback,
+				children: /* @__PURE__ */ jsxs(Figure, {
+					viewBox: [500, 235],
+					domain: "physics",
+					label: feedback,
+					children: [/* @__PURE__ */ jsxs(PlotFrame, {
+						...plot,
+						arrows: false,
+						xLabel,
+						yLabel,
+						children: [
+							mode === "gradient" ? /* @__PURE__ */ jsx(Curve, {
+								points: [[axes.x(lineFrom), axes.y(line.gradient * lineFrom + line.intercept)], [axes.x(lineTo), axes.y(line.gradient * lineTo + line.intercept)]],
+								color: HUE[1]
+							}) : null,
+							plotted.map(([x, y]) => /* @__PURE__ */ jsx(Marker, {
+								x: axes.x(x),
+								y: axes.y(y),
+								r: 4,
+								color: HUE[1]
+							}, `${x}-${y}`)),
+							mode === "gradient" ? selectedPoints.map(([x, y]) => /* @__PURE__ */ jsx(Marker, {
+								x: axes.x(x),
+								y: axes.y(y),
+								r: 8,
+								color: HUE.good
+							}, `selected-${x}`)) : null
+						]
+					}), /* @__PURE__ */ jsx(FigText, {
+						x: 58,
+						y: 224,
+						size: "label",
+						tone: mode === "scale" && !coverage.meetsHalfGridRule ? "warn" : "good",
+						children: feedback
+					})]
+				})
+			}), /* @__PURE__ */ jsxs(Activity.Dock, { children: [/* @__PURE__ */ jsx(Segmented, {
+				value: caseId,
+				onChange: setCaseId,
+				ariaLabel: mode === "scale" ? "Scale choice" : "Gradient triangle size",
+				options: mode === "scale" ? [{
+					value: "good",
+					label: stepLabel(goodStep)
+				}, {
+					value: "weak",
+					label: stepLabel(weakStep)
+				}] : [{
+					value: "good",
+					label: "Large triangle"
+				}, {
+					value: "weak",
+					label: "Small triangle"
+				}]
+			}), /* @__PURE__ */ jsx(StatList, {
+				ariaLabel: "Graph result",
+				children: mode === "scale" ? /* @__PURE__ */ jsx(Stat, {
+					label: "grid width used",
+					value: `${(coverage.coverage * 100).toFixed(0)}%`
+				}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Stat, {
+					label: "gradient",
+					value: selectedLine.gradient.toFixed(2)
+				}), /* @__PURE__ */ jsx(Stat, {
+					label: "y-intercept",
+					value: selectedLine.intercept.toFixed(2)
+				})] })
+			})] })] }),
+			/* @__PURE__ */ jsx(Activity.Feedback, {
+				tone: mode === "scale" && !coverage.meetsHalfGridRule ? "warning" : "success",
+				children: /* @__PURE__ */ jsx("span", { children: mode === "scale" ? "Use a simple 1, 2 or 5 scale and let the data occupy at least half the grid." : "Choose two distant coordinates on the best-fit line, then calculate c = y − mx." })
+			})
+		]
+	});
+}
+
+//#endregion
+export { GraphCraft as default };

package/dist/domains/physics/harmonic-modes/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/harmonic-modes/manifest.ts
+var manifest_default = defineLab({
+	id: "harmonic-modes",
+	domain: "physics",
+	group: "Physics",
+	title: "Allowed harmonic modes",
+	description: "Select a mode and connect its loops, nodes, wavelength and frequency.",
+	schema: z.object({
+		harmonic: z.union([
+			z.literal(1),
+			z.literal(2),
+			z.literal(3),
+			z.literal(4)
+		]).default(1),
+		lengthM: z.number().min(.5).max(2).default(1),
+		speedMPerS: z.number().positive().default(120),
+		...commonLabProps,
+		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"stationary waves",
+			"harmonics",
+			"resonance"
+		],
+		durationMinutes: 5,
+		interaction: "guided",
+		authorability: "simple"
+	},
+	experience: {
+		objectives: [
+			"Count nodes and antinodes",
+			"Use λ = 2L/n",
+			"Connect mode number to frequency"
+		],
+		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/harmonic-modes/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { HarmonicModesLab } from "../../../physics/waves/harmonic-modes.mjs";
+
+export { HarmonicModesLab as default };

package/dist/domains/physics/heat-transfer/manifest.mjs

@@ -16,6 +16,7 @@ var manifest_default = defineLab({
 			"convection",
 			"radiation"
 		]).optional(),
+		presentation: z.enum(["qualitative", "quantitative"]).optional(),
 		...commonLabProps,
 		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
 	}),

package/dist/domains/physics/heat-transfer-cases/manifest.mjs

@@ -0,0 +1,45 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/physics/heat-transfer-cases/manifest.ts
+var manifest_default = defineLab({
+	id: "heat-transfer-cases",
+	domain: "physics",
+	group: "Physics",
+	title: "Heat transfer in everyday situations",
+	description: "Classify conduction, convection, and radiation across four focused real-world cases.",
+	schema: z.object({
+		title: z.string().optional(),
+		prompt: z.string().optional()
+	}),
+	taxonomy: {
+		grades: ["9", "10"],
+		outcomes: ["heat", "thermal-transfer"],
+		durationMinutes: 6,
+		interaction: "guided",
+		authorability: "simple"
+	},
+	experience: {
+		objectives: [
+			"Distinguish conduction, convection, and radiation",
+			"Connect each mechanism to a familiar situation",
+			"Explain why a vacuum blocks two mechanisms but not radiation"
+		],
+		phases: [
+			"predict",
+			"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/heat-transfer-cases/runtime.mjs

@@ -0,0 +1,3 @@
+import { HeatTransferCasesLab } from "../../../physics/heat-transfer/cases.mjs";
+
+export { HeatTransferCasesLab as default };

package/dist/domains/physics/heating-curve/manifest.mjs

@@ -10,6 +10,12 @@ var manifest_default = defineLab({
 	title: "Heating curve, q=mcΔθ runs + latent plateaus",
 	description: "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.",
 	schema: z.object({
+		focus: z.enum([
+			"full",
+			"curve",
+			"fusion",
+			"vaporisation"
+		]).default("full"),
 		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(),

package/dist/domains/physics/hydrogen-spectrum/manifest.mjs

@@ -0,0 +1,55 @@
+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/hydrogen-spectrum/manifest.ts
+var manifest_default = defineLab({
+	id: "hydrogen-spectrum",
+	domain: "physics",
+	group: "Physics",
+	tag: "HydrogenSpectrum",
+	title: "Read an atom from its light",
+	description: "The Bohr energy levels drawn at their true energies beside the photon each jump emits, landed on a real visible-spectrum strip at its own wavelength. Moving the jump moves the line, which is the whole of atomic spectroscopy: the size of the gap IS the colour of the light. Because the levels crowd toward the ionisation limit, jumps from high n differ less and less and their lines pile up at the series limit; and because only the Balmer series lands between 380 and 700 nm, a hydrogen tube glows pink while most of its spectrum stays invisible. Energies come from the Bohr kernel and line colours from the CIE observer, so a 486 nm line is the colour 486 nm actually is.",
+	schema: z.object({
+		from: z.number().int().min(2).max(8).optional().describe("Level the electron falls from"),
+		to: z.number().int().min(1).max(7).optional().describe("Level the electron lands on"),
+		...commonLabProps,
+		activity: z.union([z.string().trim().min(1), authoredActivitySchema]).optional()
+	}),
+	taxonomy: {
+		grades: ["11", "12"],
+		outcomes: [
+			"atomic-structure",
+			"spectra",
+			"quantum"
+		],
+		durationMinutes: 12,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	experience: {
+		objectives: [
+			"Relate an energy-level gap to the colour of the photon it emits",
+			"Explain why only one hydrogen series is visible",
+			"Use the level spacing to explain why lines crowd together"
+		],
+		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/hydrogen-spectrum/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { HydrogenSpectrumLab } from "../../../physics/modern/quantum/spectra-preset.mjs";
+
+export { HydrogenSpectrumLab as default };