@classytic/labs 0.3.0 → 0.4.0

package/dist/domains/chem/ratio-normalizer/manifest.mjs

@@ -0,0 +1,61 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/chem/ratio-normalizer/manifest.ts
+var manifest_default = defineLab({
+	id: "ratio-normalizer",
+	tag: "RatioNormalizer",
+	domain: "chem",
+	group: "Chemistry",
+	title: "Empirical and Molecular Formula Route",
+	description: "Reveal the calculation path from composition data to an empirical or molecular formula.",
+	schema: z.object({
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		mode: z.enum(["mass", "percentage"]).default("mass"),
+		elements: z.array(z.object({
+			symbol: z.string().min(1).max(3),
+			name: z.string().optional(),
+			value: z.number().positive(),
+			relativeAtomicMass: z.number().positive()
+		})).min(2).max(6).default([{
+			symbol: "H",
+			name: "hydrogen",
+			value: 2,
+			relativeAtomicMass: 1
+		}, {
+			symbol: "O",
+			name: "oxygen",
+			value: 16,
+			relativeAtomicMass: 16
+		}]),
+		molecularMass: z.number().positive().optional(),
+		revealThrough: z.enum([
+			"input",
+			"moles",
+			"ratio",
+			"whole",
+			"molecular"
+		]).optional()
+	}),
+	taxonomy: {
+		grades: [
+			"10",
+			"11",
+			"12"
+		],
+		outcomes: [
+			"chemistry",
+			"stoichiometry",
+			"empirical-formula",
+			"molecular-formula"
+		],
+		durationMinutes: 6,
+		interaction: "guided",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/chem/ratio-normalizer/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { RatioNormalizer } from "../../../chem/ratio-normalizer/preset.mjs";
+
+export { RatioNormalizer as default };

package/dist/domains/chem/reaction-evidence/manifest.mjs

@@ -0,0 +1,51 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/chem/reaction-evidence/manifest.ts
+var manifest_default = defineLab({
+	id: "reaction-evidence",
+	tag: "ReactionEvidenceLab",
+	domain: "chem",
+	group: "Chemistry",
+	title: "Reaction evidence lab",
+	description: "Run a macroscopic chemistry comparison, record what is observed, then choose only the inference supported by that evidence.",
+	schema: z.object({
+		prompt: z.string().optional(),
+		title: z.string().optional(),
+		scenario: z.enum([
+			"displacement",
+			"rusting",
+			"eutrophication",
+			"acid-metal"
+		]).optional()
+	}),
+	taxonomy: {
+		grades: ["9", "10"],
+		outcomes: [
+			"chemistry",
+			"experimental-evidence",
+			"reactions"
+		],
+		durationMinutes: 7,
+		interaction: "guided",
+		authorability: "moderate"
+	},
+	experience: {
+		objectives: ["Separate observation from inference", "Explain a reaction from visible evidence"],
+		phases: [
+			"act",
+			"observe",
+			"explain"
+		],
+		responses: ["choice"],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/chem/reaction-evidence/runtime.mjs

@@ -0,0 +1,5 @@
+'use client';
+
+import { ReactionEvidenceLab } from "../../../chem/o-level-concepts.mjs";
+
+export { ReactionEvidenceLab as default };

package/dist/domains/chem/reaction-lab/manifest.mjs

@@ -7,8 +7,9 @@ var manifest_default = defineLab({
 	domain: "chem",
 	group: "Chemistry",
 	title: "Reaction lab",
-	description: "Atoms collide and bond, A + B → A–B, with a temperature/kinetics knob.",
+	description: "A slowed-down collision model. Below the activation-energy threshold particles bounce apart; above it they form A–B while conserving the authored atoms.",
 	schema: z.object({
+		prompt: z.string().optional(),
 		a: z.string().optional(),
 		b: z.string().optional(),
 		title: z.string().optional()

package/dist/domains/chem/reaction-profile/manifest.mjs

@@ -9,6 +9,7 @@ var manifest_default = defineLab({
 	title: "Reaction profile",
 	description: "Energy diagram, activation energy, ΔH (exo/endothermic), catalyst toggle.",
 	schema: z.object({
+		prompt: z.string().optional(),
 		deltaH: z.number().min(-80).max(80).optional(),
 		activationEnergy: z.number().min(5).max(120).optional(),
 		catalyst: z.boolean().optional(),

package/dist/domains/chem/reagent-ladder/activity.mjs

@@ -0,0 +1,85 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/domains/chem/reagent-ladder/activity.ts
+const activity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Reagent Ladder",
+	objectives: [
+		"Predict which solid a weak reagent will dissolve before adding it.",
+		"Use reagents of increasing strength to separate solids of similar colour.",
+		"Name the ion each solid proves, and say why one reagent alone is not enough."
+	],
+	success: [
+		{
+			id: "predict",
+			source: "metric",
+			key: "predict",
+			pendingLabel: "Commit to a prediction first."
+		},
+		{
+			id: "weak",
+			source: "metric",
+			key: "weak",
+			pendingLabel: "Add the weaker reagent."
+		},
+		{
+			id: "strong",
+			source: "metric",
+			key: "strong",
+			pendingLabel: "Add the stronger reagent."
+		},
+		{
+			id: "identify",
+			source: "metric",
+			key: "identify",
+			pendingLabel: "Name the ions."
+		}
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Commit before you pour",
+			lead: "Three solids, similar colours. Which will the weaker reagent dissolve?",
+			controls: true,
+			success: "predict"
+		},
+		{
+			id: "weak",
+			phase: "act",
+			title: "Add the weaker reagent",
+			lead: "Watch which tube clears and which does not.",
+			controls: true,
+			reveal: ["model"],
+			success: "weak"
+		},
+		{
+			id: "strong",
+			phase: "act",
+			title: "Add the stronger reagent",
+			lead: "One reagent was not enough to tell all three apart.",
+			controls: true,
+			reveal: ["model", "evidence"],
+			success: "strong"
+		},
+		{
+			id: "identify",
+			phase: "explain",
+			title: "Name the ions",
+			lead: "The ORDER in which they dissolved is the identification.",
+			controls: true,
+			reveal: ["model", "evidence"],
+			success: "identify"
+		},
+		{
+			id: "complete",
+			phase: "transfer",
+			title: "Ladder secured",
+			lead: "A colour alone can be ambiguous. A ladder of reagents is not.",
+			reveal: ["model", "evidence"]
+		}
+	]
+});
+
+//#endregion
+export { activity };

package/dist/domains/chem/reagent-ladder/manifest.mjs

@@ -0,0 +1,58 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { LADDER_CASES } from "./model.mjs";
+import { z } from "zod";
+
+//#region src/domains/chem/reagent-ladder/manifest.ts
+const setIds = LADDER_CASES.map((item) => item.id);
+var manifest_default = defineLab({
+	id: "reagent-ladder",
+	tag: "ReagentLadder",
+	domain: "chem",
+	group: "Chemistry",
+	title: "Reagent Ladder",
+	description: "Solids of similar colour, separated by reagents of increasing strength. Silver chloride dissolves in dilute ammonia, silver bromide only in concentrated ammonia, and silver iodide in neither, so the ORDER of dissolving is the identification. Ships a predict-first question and the amphoteric hydroxide set.",
+	schema: z.object({
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		set: z.enum(setIds).optional().describe("which ladder: silver halides, or the amphoteric hydroxides")
+	}),
+	taxonomy: {
+		grades: [
+			"10",
+			"11",
+			"12"
+		],
+		outcomes: [
+			"chemistry",
+			"qualitative-analysis",
+			"practical-skills"
+		],
+		durationMinutes: 9,
+		interaction: "guided",
+		authorability: "simple"
+	},
+	experience: {
+		objectives: [
+			"Predict which solid the weaker reagent dissolves before adding it.",
+			"Separate solids of similar colour with reagents of increasing strength.",
+			"Name the ion each solid proves, and explain why one reagent is not enough."
+		],
+		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/chem/reagent-ladder/model.mjs

@@ -0,0 +1,120 @@
+//#region src/domains/chem/reagent-ladder/model.ts
+const LADDER_CASES = [{
+	id: "silver-halides",
+	title: "Three silver halides",
+	reagents: [{
+		id: "dilute",
+		label: "dilute aqueous ammonia",
+		short: "dilute NH₃"
+	}, {
+		id: "concentrated",
+		label: "concentrated aqueous ammonia",
+		short: "concentrated NH₃"
+	}],
+	solids: [
+		{
+			id: "agcl",
+			formula: "AgCl",
+			name: "silver chloride",
+			from: "chloride",
+			colour: "white",
+			dissolvesAt: 0
+		},
+		{
+			id: "agbr",
+			formula: "AgBr",
+			name: "silver bromide",
+			from: "bromide",
+			colour: "cream",
+			dissolvesAt: 1
+		},
+		{
+			id: "agi",
+			formula: "AgI",
+			name: "silver iodide",
+			from: "iodide",
+			colour: "yellow",
+			dissolvesAt: null
+		}
+	],
+	rule: "Silver chloride dissolves in dilute ammonia, silver bromide only in concentrated ammonia, and silver iodide in neither."
+}, {
+	id: "amphoteric-hydroxides",
+	title: "Three white hydroxides",
+	reagents: [{
+		id: "excess-naoh",
+		label: "excess sodium hydroxide",
+		short: "excess NaOH"
+	}, {
+		id: "excess-ammonia",
+		label: "excess aqueous ammonia",
+		short: "excess NH₃"
+	}],
+	solids: [
+		{
+			id: "zn",
+			formula: "Zn(OH)₂",
+			name: "zinc hydroxide",
+			from: "zinc",
+			colour: "white",
+			dissolvesAt: 0
+		},
+		{
+			id: "al",
+			formula: "Al(OH)₃",
+			name: "aluminium hydroxide",
+			from: "aluminium",
+			colour: "white",
+			dissolvesAt: 0
+		},
+		{
+			id: "ca",
+			formula: "Ca(OH)₂",
+			name: "calcium hydroxide",
+			from: "calcium",
+			colour: "white",
+			dissolvesAt: null
+		}
+	],
+	rule: "Zinc and aluminium hydroxides are amphoteric and dissolve in excess alkali; calcium hydroxide does not. Only zinc then dissolves in excess ammonia."
+}];
+const createLadderState = (caseIndex = 0) => ({
+	caseIndex,
+	added: 0,
+	identified: false
+});
+function currentLadderCase(state) {
+	return LADDER_CASES[Math.min(state.caseIndex, LADDER_CASES.length - 1)] ?? LADDER_CASES[0];
+}
+/** True once `added` reagents have been used and this solid has met the one that dissolves it. */
+function hasDissolved(solid, added) {
+	return solid.dissolvesAt !== null && added > solid.dissolvesAt;
+}
+function transitionLadder(state, event) {
+	if (event.type === "RESET") return createLadderState(state.caseIndex);
+	const ladder = currentLadderCase(state);
+	if (event.type === "ADD_REAGENT") {
+		if (state.added >= ladder.reagents.length) return state;
+		return {
+			...state,
+			added: state.added + 1
+		};
+	}
+	if (state.added < ladder.reagents.length) return state;
+	return {
+		...state,
+		identified: true
+	};
+}
+/** What the learner can currently say, in the order the mark scheme wants it. */
+function ladderVerdict(state) {
+	const ladder = currentLadderCase(state);
+	if (state.added === 0) return `All three look similar. ${ladder.solids.length} solids, no reagent added yet.`;
+	const reagent = ladder.reagents[state.added - 1];
+	const dissolved = ladder.solids.filter((solid) => hasDissolved(solid, state.added));
+	if (!dissolved.length) return `Nothing dissolved in ${reagent?.short ?? "the reagent"}.`;
+	return `${dissolved.map((solid) => solid.formula).join(" and ")} dissolved in ${reagent?.short ?? "the reagent"}.`;
+}
+
+//#endregion
+export { LADDER_CASES, createLadderState, currentLadderCase, hasDissolved, ladderVerdict, transitionLadder };

package/dist/domains/chem/reagent-ladder/runtime.mjs

@@ -0,0 +1,107 @@
+'use client';
+
+import { AssessedChoiceGroup, CheckButton } from "../../../kit/controls.mjs";
+import { LiveRegion, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { LADDER_CASES, createLadderState, currentLadderCase, hasDissolved, ladderVerdict, transitionLadder } from "./model.mjs";
+import { activity } from "./activity.mjs";
+import { ReagentLadderScene } from "./scene.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/domains/chem/reagent-ladder/runtime.tsx
+function ReagentLadder({ title = "Reagent Ladder", prompt = "Colours can be ambiguous. Use reagents of increasing strength to separate the solids.", set = "silver-halides" }) {
+	const caseIndex = Math.max(0, LADDER_CASES.findIndex((item) => item.id === set));
+	const [state, setState] = useState(() => createLadderState(caseIndex));
+	const [hint, setHint] = useState();
+	const ladder = currentLadderCase(state);
+	const weakest = ladder.reagents[0];
+	const firstToGo = ladder.solids.filter((solid) => solid.dissolvesAt === 0).map((solid) => solid.formula);
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		activity,
+		activityId: "reagent-ladder",
+		eyebrow: "Chemistry practical",
+		title,
+		description: prompt,
+		presentation: "investigation",
+		focusLayout: "immersive",
+		transcriptMode: "sr-only",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", { children: ladder.title }), /* @__PURE__ */ jsxs("span", { children: [
+			state.added,
+			"/",
+			ladder.reagents.length
+		] })] }),
+		controls: ({ sequence, complete }) => {
+			const step = sequence.current.id;
+			if (step === "predict") {
+				const options = ladder.solids.map((solid) => ({
+					value: solid.formula,
+					label: `${solid.formula} only`
+				}));
+				return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
+					ariaLabel: `Which solid dissolves in ${weakest?.label ?? "the weaker reagent"}`,
+					options: [...options, {
+						value: "none",
+						label: "none of them"
+					}],
+					onChange: (choice) => {
+						if (firstToGo.length === 1 && choice === firstToGo[0]) {
+							setHint(void 0);
+							complete("predict", choice);
+							return;
+						}
+						if (choice === "none" && firstToGo.length === 0) {
+							setHint(void 0);
+							complete("predict", choice);
+							return;
+						}
+						setHint("Not that one. The weaker reagent dissolves only the most soluble solid.");
+					}
+				});
+			}
+			if (step === "weak" || step === "strong") {
+				const next = ladder.reagents[state.added];
+				return /* @__PURE__ */ jsx(CheckButton, {
+					disabled: !next,
+					onClick: () => {
+						const after = transitionLadder(state, { type: "ADD_REAGENT" });
+						setState(after);
+						complete(step, ladderVerdict(after));
+					},
+					children: next ? `Add ${next.short}` : "All reagents added"
+				});
+			}
+			if (step === "identify") {
+				const never = ladder.solids.find((solid) => solid.dissolvesAt === null);
+				return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
+					ariaLabel: "Which solid is the one that never dissolved",
+					options: ladder.solids.map((solid) => ({
+						value: solid.id,
+						label: `${solid.formula}, from ${solid.from}`
+					})),
+					onChange: (choice) => {
+						if (choice !== never?.id) {
+							setHint("That one dissolved at some stage. Pick the tube that still holds its solid.");
+							return;
+						}
+						setHint(void 0);
+						const after = transitionLadder(state, { type: "IDENTIFY" });
+						setState(after);
+						complete("identify", ladder.rule);
+					}
+				});
+			}
+			return null;
+		},
+		evidence: state.added > 0 ? /* @__PURE__ */ jsx(Readout, {
+			value: hint ?? ladderVerdict(state),
+			sub: hint ? "try again" : "bench observation"
+		}) : null,
+		observation: state.identified ? ladder.rule : void 0,
+		transcript: /* @__PURE__ */ jsx(LiveRegion, { children: `${ladderVerdict(state)} ${ladder.solids.map((solid) => `${solid.formula} ${hasDissolved(solid, state.added) ? "dissolved" : "remains"}`).join(". ")}.` }),
+		children: /* @__PURE__ */ jsx(ReagentLadderScene, { state })
+	});
+}
+
+//#endregion
+export { ReagentLadder as default };

package/dist/domains/chem/reagent-ladder/scene.mjs

@@ -0,0 +1,174 @@
+import { Figure, HUE, STROKE, alpha, tint } from "../../../kit/figure/figure.mjs";
+import { FigText } from "../../../kit/figure/text.mjs";
+import { Glass } from "../../../kit/figure/container.mjs";
+import { OBSERVED, Precipitate } from "../../../kit/chemistry/observation.mjs";
+import { currentLadderCase, hasDissolved } from "./model.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/domains/chem/reagent-ladder/scene.tsx
+/**
+* Three tubes on one bench, told apart by colour and then by what dissolves.
+*
+* Built to the layout discipline the other chem scenes now follow: one margin, one bench that
+* everything RESTS on, one caption band, hairlines instead of nested cards, and no apparatus
+* floating above its own support.
+*
+* The comparison is the whole point, so the three tubes share a row and a scale. Drawing them in
+* separate figures, or one at a time, would leave the learner holding two colours in memory to
+* compare them, which is exactly the confusion the ammonia ladder is taught to resolve.
+*/
+const M = 40;
+const W = 620;
+const BENCH = 250;
+const TUBE = {
+	w: 96,
+	h: 150
+};
+/** Caption bands, measured down from the bench so nothing can drift. */
+const BAND = {
+	formula: 276,
+	state: 298,
+	rule: 320,
+	verdict: 348,
+	height: 370
+};
+function Rule({ y }) {
+	return /* @__PURE__ */ jsx("path", {
+		d: `M${M} ${y}H580`,
+		stroke: alpha(HUE.soft, 30),
+		strokeWidth: STROKE.hair
+	});
+}
+function ReagentLadderScene({ state }) {
+	const ladder = currentLadderCase(state);
+	const reagent = state.added > 0 ? ladder.reagents[state.added - 1] : void 0;
+	const slot = 422 / ladder.solids.length;
+	const label = `${ladder.title}. ${ladder.solids.map((solid) => `${solid.formula} ${hasDissolved(solid, state.added) ? "has dissolved" : `is a ${solid.colour} solid`}`).join(". ")}. ${state.identified ? ladder.rule : ""}`;
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, BAND.height],
+		domain: "chem",
+		label,
+		children: [
+			/* @__PURE__ */ jsx(FigText, {
+				x: M,
+				y: 30,
+				size: "eyebrow",
+				tone: "soft",
+				children: reagent ? `ADDED: ${reagent.label.toUpperCase()}` : "THREE UNKNOWN PRECIPITATES"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: M,
+				y: 62,
+				size: "title",
+				children: ladder.title
+			}),
+			/* @__PURE__ */ jsx(Rule, { y: 84 }),
+			ladder.solids.map((solid, index) => {
+				const cx = M + slot * (index + .5);
+				const gone = hasDissolved(solid, state.added);
+				return /* @__PURE__ */ jsxs("g", { children: [
+					/* @__PURE__ */ jsx(Glass, {
+						x: cx - TUBE.w / 2,
+						y: BENCH - TUBE.h + STROKE.edge,
+						w: TUBE.w,
+						h: TUBE.h,
+						shape: "tube",
+						fill: .5,
+						liquid: HUE.liquid,
+						liquidOpacity: gone ? .22 : .3,
+						children: gone ? null : /* @__PURE__ */ jsx(Precipitate, {
+							cx,
+							bottom: 236,
+							colour: OBSERVED[solid.colour]
+						})
+					}),
+					/* @__PURE__ */ jsx(FigText, {
+						x: cx,
+						y: BAND.formula,
+						size: "measure",
+						anchor: "middle",
+						children: solid.formula
+					}),
+					/* @__PURE__ */ jsx(FigText, {
+						x: cx,
+						y: BAND.state,
+						size: "note",
+						anchor: "middle",
+						tone: gone ? "good" : "soft",
+						children: gone ? "dissolved" : `${solid.colour} solid`
+					}),
+					/* @__PURE__ */ jsx(FigText, {
+						x: cx,
+						y: BAND.rule,
+						size: "note",
+						anchor: "middle",
+						tone: state.identified ? "ink" : "soft",
+						children: state.identified ? solid.from : "—"
+					})
+				] }, solid.id);
+			}),
+			/* @__PURE__ */ jsx("path", {
+				d: `M${M} ${BENCH}H580`,
+				stroke: HUE.wood,
+				strokeWidth: STROKE.line,
+				strokeLinecap: "round"
+			}),
+			reagent ? /* @__PURE__ */ jsxs("g", {
+				className: "fig-ease",
+				children: [
+					/* @__PURE__ */ jsx("path", {
+						d: `M504 ${BENCH} V 184 Q 504 174 514 174 H 526 V 160 H 572 V 174 H 584 Q 594 174 594 184 V ${BENCH} Z`,
+						fill: tint(HUE[2], 10),
+						stroke: HUE.metal,
+						strokeWidth: STROKE.edge,
+						strokeLinejoin: "round"
+					}),
+					/* @__PURE__ */ jsx("rect", {
+						x: 524,
+						y: 149,
+						width: 50,
+						height: 13,
+						rx: 4,
+						fill: HUE.metal
+					}),
+					/* @__PURE__ */ jsx("rect", {
+						x: 504,
+						y: 184,
+						width: 90,
+						height: 9,
+						fill: alpha(HUE[2], 42)
+					}),
+					reagent.short.split(" ").map((word, line) => /* @__PURE__ */ jsx(FigText, {
+						x: 549,
+						y: 206 + line * 19,
+						size: "note",
+						anchor: "middle",
+						tone: "ink",
+						children: word
+					}, word))
+				]
+			}) : null,
+			/* @__PURE__ */ jsx(Rule, { y: BAND.rule + 12 }),
+			/* @__PURE__ */ jsx(FigText, {
+				x: M,
+				y: BAND.verdict,
+				size: "eyebrow",
+				baseline: "middle",
+				tone: state.identified ? "good" : "soft",
+				children: state.identified ? "ALL THREE SEPARATED" : `REAGENT ${state.added} OF ${ladder.reagents.length}`
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 580,
+				y: BAND.verdict,
+				size: "measure",
+				baseline: "middle",
+				anchor: "end",
+				tone: state.identified ? "good" : "soft",
+				children: state.identified ? `${ladder.solids.length} ions named` : reagent ? reagent.short : "none added"
+			})
+		]
+	});
+}
+
+//#endregion
+export { ReagentLadderScene };