@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/math/number/fraction-bar/model.mjs

@@ -1,6 +1,7 @@
 import { defineLabModel } from "../../../../model/define.mjs";
 import { refuse } from "../../../../model/index.mjs";
 import { z } from "zod";
+import { readFractionExchange, readFractionUnits, transitionFractionExchange } from "@classytic/stage/math";
 
 //#region src/domains/math/number/fraction-bar/model.ts
 /**
@@ -9,15 +10,31 @@ import { z } from "zod";
 * quantity. An optional second strip at a different denominator shows the same length as an
 * equivalent fraction.
 *
-* Pure arithmetic (the content being taught, the same way `balance-algebra` and `distribute-strip`
-* compute their own equation's value): no law of nature is involved, so nothing here calls stage.
+* The multi-whole builder uses Stage's fixed fractional-unit grouping and quantity readings.
+* The original single-strip representation retains its existing arithmetic and spatial writer.
 */
+function exchangeMove(st, operation) {
+	if (!st.exchange) return st;
+	const next = transitionFractionExchange(st.exchange, operation);
+	if (!next.ok) return st;
+	const exchanged = st.exchanged || operation === "exchange-whole" || operation === "combine-pieces";
+	const removed = st.removed || operation === "remove-whole" || operation === "remove-piece";
+	return {
+		num: next.value.totalUnitCount,
+		touched: true,
+		exchange: next.value,
+		exchanged,
+		removed
+	};
+}
 const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
 const fractionBarModel = defineLabModel({
 	id: "fraction-bar",
 	params: z.object({
 		denom: z.number().int().min(1).max(100).default(4).describe("n: how many equal parts the strip is cut into"),
 		num: z.number().int().min(0).default(0).describe("starting shaded parts"),
+		wholeCount: z.number().int().min(1).max(4).default(1).describe("equal wholes available; more than one enables the fractional-unit builder (denominator at most 6)"),
+		exchangeMode: z.boolean().default(false).describe("exchange intact wholes for equal loose pieces, then remove material explicitly"),
 		target: z.number().int().min(0).optional().describe("a goal numerator; omit to explore freely"),
 		whole: z.number().finite().positive().optional().describe("show the fraction of this quantity"),
 		unit: z.string().default("").describe("the quantity’s unit, printed after its number"),
@@ -26,45 +43,139 @@ const fractionBarModel = defineLabModel({
 		scene: z.string().default("none").describe("an optional concrete twin (pie, jar, …) from the scene kit")
 	}),
 	resolve(p) {
-		if (p.target != null && p.target > p.denom) {
-			return refuse("target-out-of-range", `target (${p.target}) cannot be more than denom (${p.denom}).`);
+		const isMultiWhole = p.wholeCount > 1;
+		if (p.exchangeMode && !isMultiWhole) return refuse("exchange-needs-wholes", "Exchange mode needs two to four equal wholes of capacity.");
+		if (isMultiWhole && p.denom > 6) return refuse("multiwhole-denominator", "The fractional-unit builder supports at most six equal parts per whole.");
+		if (isMultiWhole && p.compareDenom != null) return refuse("multiwhole-comparison", "The fractional-unit builder does not use an equivalent-denominator comparison strip.");
+		if (isMultiWhole && p.scene !== "none") return refuse("multiwhole-scene", "The fractional-unit builder uses equal whole bars without a concrete twin.");
+		const units = isMultiWhole ? readFractionUnits({
+			unitCount: p.num,
+			denominator: p.denom,
+			wholeCapacity: p.wholeCount,
+			wholeValue: p.whole ?? 1
+		}) : null;
+		if (units && !units.ok) return units;
+		const capacity = units?.ok ? units.value.capacity : p.denom;
+		const unitReadings = [];
+		if (isMultiWhole) {
+			for (let unitCount = 0; unitCount <= capacity; unitCount++) {
+				const reading = readFractionUnits({
+					unitCount,
+					denominator: p.denom,
+					wholeCapacity: p.wholeCount,
+					wholeValue: p.whole ?? 1
+				});
+				if (!reading.ok) return reading;
+				unitReadings.push(reading.value);
+			}
 		}
-		const startNum = Math.min(Math.max(p.num, 0), p.denom);
+		if (p.target != null && p.target > capacity) {
+			return refuse("target-out-of-range", isMultiWhole ? `target (${p.target}) exceeds the ${capacity} fractional units available.` : `target (${p.target}) cannot be more than denom (${p.denom}).`);
+		}
+		let exchangeStart = null;
+		let exchangeWitness = null;
+		if (p.exchangeMode && units?.ok) {
+			const start = readFractionExchange({
+				wholeGroups: units.value.completeWholes,
+				looseUnits: units.value.remainderUnits,
+				denominator: p.denom,
+				wholeCapacity: p.wholeCount,
+				wholeValue: p.whole ?? 1
+			});
+			if (!start.ok) return start;
+			if (!start.value.permitted["exchange-whole"]) return refuse("exchange-needs-whole", "Start with at least one intact whole to exchange.");
+			if (p.target != null && p.target >= p.num) return refuse("exchange-target-not-smaller", "An exchange-and-remove target must be smaller than the opening amount.");
+			exchangeStart = start.value;
+			exchangeWitness = exchangeMove({
+				num: p.num,
+				touched: false,
+				exchange: exchangeStart,
+				exchanged: false,
+				removed: false
+			}, "exchange-whole");
+			while (p.target != null && exchangeWitness.num > p.target) {
+				if (!exchangeWitness.exchange.permitted["remove-piece"]) exchangeWitness = exchangeMove(exchangeWitness, "exchange-whole");
+				exchangeWitness = exchangeMove(exchangeWitness, "remove-piece");
+			}
+		}
+		const startNum = isMultiWhole ? p.num : Math.min(Math.max(p.num, 0), p.denom);
 		const hasTarget = p.target != null;
 		const hasCompare = p.compareDenom != null;
 		return {
 			...p,
 			startNum,
 			hasTarget,
-			hasCompare
+			hasCompare,
+			isMultiWhole,
+			capacity,
+			unitReadings,
+			exchangeStart,
+			exchangeWitness
 		};
 	},
-	initial: (s) => ({
+	initial: (s) => s.exchangeMode ? {
+		num: s.startNum,
+		touched: false,
+		exchange: s.exchangeStart,
+		exchanged: false,
+		removed: false
+	} : {
 		num: s.startNum,
 		touched: false
-	}),
-	controls: (c) => ({ num: c.number({
-		label: "shaded parts",
-		step: 1,
-		range: (s) => [0, s.denom],
-		get: (st) => st.num,
-		set: (_st, v) => ({
-			num: v,
-			touched: true
+	},
+	controls: (c) => ({
+		num: c.number({
+			when: (s) => !s.exchangeMode,
+			label: (s) => s.isMultiWhole ? "fractional units" : "shaded parts",
+			step: 1,
+			range: (s) => [0, s.capacity],
+			get: (st) => st.num,
+			set: (st, v, s) => ({
+				num: v,
+				touched: s.isMultiWhole ? st.touched || v !== st.num : true
+			})
+		}),
+		exchangeWhole: c.action({
+			label: (s) => `Exchange 1 whole for ${s.denom} ${s.denom === 1 ? "piece" : "pieces"}`,
+			when: (s) => s.exchangeMode,
+			enabled: (_s, st) => !!st.exchange?.permitted["exchange-whole"],
+			run: (_s, st) => exchangeMove(st, "exchange-whole")
+		}),
+		combinePieces: c.action({
+			label: (s) => `Combine ${s.denom} ${s.denom === 1 ? "piece" : "pieces"} into 1 whole`,
+			when: (s) => s.exchangeMode,
+			enabled: (_s, st) => !!st.exchange?.permitted["combine-pieces"],
+			run: (_s, st) => exchangeMove(st, "combine-pieces")
+		}),
+		removeWhole: c.action({
+			label: "Remove 1 whole",
+			when: (s) => s.exchangeMode,
+			enabled: (_s, st) => !!st.exchange?.permitted["remove-whole"],
+			run: (_s, st) => exchangeMove(st, "remove-whole")
+		}),
+		removePiece: c.action({
+			label: "Remove 1 piece",
+			when: (s) => s.exchangeMode,
+			enabled: (_s, st) => !!st.exchange?.permitted["remove-piece"],
+			run: (_s, st) => exchangeMove(st, "remove-piece")
 		})
-	}) }),
+	}),
 	read(s, st) {
-		const frac = st.num / s.denom;
-		const common = gcd(st.num, s.denom);
-		const simplified = st.num > 0 && common > 1 ? {
+		const units = st.exchange?.units ?? (s.isMultiWhole ? s.unitReadings[st.num] : null);
+		const frac = units ? units.value : st.num / s.denom;
+		const common = units ? 1 : gcd(st.num, s.denom);
+		const simplified = units ? st.num > 0 && units.reduced.numerator !== st.num ? {
+			num: units.reduced.numerator,
+			denom: units.reduced.denominator
+		} : null : st.num > 0 && common > 1 ? {
 			num: st.num / common,
 			denom: s.denom / common
 		} : null;
-		const solved = s.hasTarget ? st.touched && st.num === s.target : false;
+		const solved = s.hasTarget ? st.touched && st.num === s.target && (!s.exchangeMode || !!st.exchanged && !!st.removed) : false;
 		const cmpPosition = s.hasCompare ? frac * s.compareDenom : 0;
 		const cmpShaded = Math.round(cmpPosition);
 		const cmpExact = s.hasCompare ? Math.abs(frac * s.compareDenom - cmpShaded) < 1e-9 : false;
-		const quantity = s.whole != null ? frac * s.whole : null;
+		const quantity = s.whole != null ? units ? units.totalQuantity : frac * s.whole : null;
 		return {
 			frac,
 			decimal: frac,
@@ -74,18 +185,28 @@ const fractionBarModel = defineLabModel({
 			cmpShaded,
 			cmpPosition,
 			cmpExact,
-			quantity
+			quantity,
+			units,
+			exchange: st.exchange ?? null
 		};
 	},
-	goals: { shaded: (r, st, s) => s.hasTarget ? r.solved : st.touched },
-	witness: (s) => s.hasTarget ? {
+	goals: { shaded: (r, st, s) => s.hasTarget ? r.solved : s.exchangeMode ? !!st.exchanged : st.touched },
+	witness: (s) => s.exchangeMode ? s.exchangeWitness : s.hasTarget ? {
 		num: s.target,
 		touched: true
 	} : {
-		num: s.startNum === s.denom ? 0 : s.startNum + 1,
+		num: s.startNum === s.capacity ? 0 : s.startNum + 1,
 		touched: true
 	},
 	describe: (s, st, r) => {
+		if (r.exchange) {
+			const e = r.exchange;
+			return `${e.wholeGroups} intact ${e.wholeGroups === 1 ? "whole" : "wholes"} plus ${e.looseUnits} loose ${e.looseUnits === 1 ? "piece" : "pieces"}, each 1/${s.denom} of the same whole. Total: ${st.num}/${s.denom} wholes${r.quantity != null ? `, ${r.quantity}${s.unit ? ` ${s.unit}` : ""}` : ""}. Exchanging or combining keeps the total unchanged; removing material reduces it.`;
+		}
+		if (r.units) {
+			const mixed = r.units.remainderUnits === 0 ? `${r.units.completeWholes} wholes` : `${r.units.completeWholes} + ${r.units.remainderUnits}/${s.denom} wholes`;
+			return `${st.num} fractional units, each 1/${s.denom} of the same whole: ${st.num}/${s.denom} wholes = ${mixed}. Each whole has ${s.denom} equal parts${s.whole != null ? ` and represents ${s.whole}${s.unit ? ` ${s.unit}` : ""}` : ""}.`;
+		}
 		const parts = [`${st.num}/${s.denom} shaded`];
 		if (s.hasCompare) parts.push(`${r.cmpExact ? "=" : "≈"} ${r.cmpShaded}/${s.compareDenom}`);
 		if (r.simplified) parts.push(`= ${r.simplified.num}/${r.simplified.denom}`);

package/dist/domains/math/number/fraction-bar/runtime.mjs

@@ -18,12 +18,14 @@ function FractionBar(props) {
 		sceneLabel: "Interactive fraction model",
 		status: ({ state, scenario, reading }) => /* @__PURE__ */ jsxs(Fragment, { children: [
 			/* @__PURE__ */ jsx("strong", { children: `${state.num}/${scenario.denom}` }),
+			reading.exchange && /* @__PURE__ */ jsx("span", { children: ` = ${reading.exchange.wholeGroups} intact ${reading.exchange.wholeGroups === 1 ? "whole" : "wholes"} + ${reading.exchange.looseUnits}/${scenario.denom} in loose pieces` }),
+			!reading.exchange && reading.units && /* @__PURE__ */ jsx("span", { children: ` = ${reading.units.remainderUnits === 0 ? `${reading.units.completeWholes} ${reading.units.completeWholes === 1 ? "whole" : "wholes"}` : `${reading.units.completeWholes} + ${reading.units.remainderUnits}/${scenario.denom} wholes`}` }),
 			scenario.hasCompare && /* @__PURE__ */ jsx("span", { children: ` ${reading.cmpExact ? "=" : "≈"} ${reading.cmpShaded}/${scenario.compareDenom}` }),
-			reading.simplified && /* @__PURE__ */ jsx("span", { children: ` = ${reading.simplified.num}/${reading.simplified.denom}` }),
+			!reading.units && reading.simplified && /* @__PURE__ */ jsx("span", { children: ` = ${reading.simplified.num}/${reading.simplified.denom}` }),
 			scenario.showEquiv && /* @__PURE__ */ jsx("span", { children: ` ${Number(reading.decimal.toFixed(2)) === reading.decimal ? "=" : "≈"} ${reading.decimal.toFixed(2)}; ${Number(reading.percent.toFixed(0)) === reading.percent ? "=" : "≈"} ${reading.percent.toFixed(0)}%` }),
-			reading.quantity != null && /* @__PURE__ */ jsx("span", { children: ` ${Number(reading.quantity.toFixed(2)) === reading.quantity ? "=" : "≈"} ${reading.quantity.toFixed(2)}${scenario.unit ? ` ${scenario.unit}` : ""} of ${scenario.whole}` })
+			reading.quantity != null && /* @__PURE__ */ jsx("span", { children: ` ${Number(reading.quantity.toFixed(2)) === reading.quantity ? "=" : "≈"} ${reading.quantity.toFixed(2)}${scenario.unit ? ` ${scenario.unit}` : ""}${reading.units ? " total" : ` of ${scenario.whole}`}` })
 		] }),
-		observation: "Both strips shade the same fraction of the same whole. A boundary may cut through a comparison cell; rounded numeric names use ≈ rather than exact equality.",
+		observation: ({ scenario }) => scenario.exchangeMode ? "Exchanging one intact whole releases its equal pieces. Combining reverses that exchange. Both keep the total unchanged; only removing material reduces the amount. Loose pieces keep their original unit even when there are enough to form another whole." : scenario.isMultiWhole ? `All bars are equal-sized wholes. Each whole has ${scenario.denom} equal parts, so each new piece is still 1/${scenario.denom} of one whole. Complete wholes plus remaining fractional units name the same total.` : scenario.hasCompare ? "Both strips shade the same fraction of the same whole. A boundary may cut through a comparison cell; rounded numeric names use ≈ rather than exact equality." : "The strip is divided into equal parts. The fraction names how many parts are shaded. Rounded numeric names use ≈ rather than exact equality.",
 		children: /* @__PURE__ */ jsx(FractionBarScene, {})
 	});
 }

package/dist/domains/math/number/fraction-bar/scene.mjs

@@ -1,14 +1,17 @@
 'use client';
 
+import { ControlButton, Stepper } from "../../../../kit/controls.mjs";
 import { LinkedViews } from "../../../../kit/frame.mjs";
 import { useControl } from "../../../../runtime/use-control.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
-import { MovableDot as MovableDot$1 } from "../../../../kit/movable-dot.mjs";
+import { MovableDot } from "../../../../kit/movable-dot.mjs";
+import { Cluster, Stack } from "../../../../kit/layout.mjs";
 import { BarStrip } from "../../../../kit/bar-strip.mjs";
 import { getScene } from "../../../../kit/scenes.mjs";
 import { fractionBarModel } from "./model.mjs";
-import { Segment, Stage } from "@classytic/stage";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Stage } from "@classytic/stage/view";
+import { Label, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/number/fraction-bar/scene.tsx
 function FractionBarScene() {
@@ -16,6 +19,50 @@ function FractionBarScene() {
 	const num = useControl(fractionBarModel, "num");
 	const n = s.denom;
 	const fillColor = reading.solved ? "var(--stage-good)" : "var(--stage-accent)";
+	if (s.exchangeMode) return /* @__PURE__ */ jsx(ExchangeScene, {});
+	if (s.isMultiWhole && reading.units) {
+		return /* @__PURE__ */ jsxs("div", { children: [
+			/* @__PURE__ */ jsx(Stage, {
+				view: {
+					xMin: -.55,
+					xMax: n + .55,
+					yMin: -1,
+					yMax: s.wholeCount * 2 - .5
+				},
+				height: s.wholeCount * 96 + 32,
+				preserveAspect: false,
+				pad: 14,
+				ariaLabel: `${s.wholeCount} equal wholes, each divided into ${n} parts; ${state.num} fractional units shaded`,
+				children: reading.units.perWhole.map((shaded, index) => {
+					const y = (s.wholeCount - 1 - index) * 2;
+					return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx(BarStrip, {
+						span: n,
+						cells: n,
+						shaded,
+						y,
+						color: fillColor,
+						weight: 44
+					}), /* @__PURE__ */ jsx(Label, {
+						x: n / 2,
+						y: y + .85,
+						text: `Whole ${index + 1}: ${s.whole != null ? `${s.whole}${s.unit ? ` ${s.unit}` : ""}` : "1 whole"}`,
+						size: 12
+					})] }, index);
+				})
+			}),
+			/* @__PURE__ */ jsx(Stepper, { control: num }),
+			/* @__PURE__ */ jsxs("p", { children: [
+				!num.hidden && /* @__PURE__ */ jsxs(Fragment, { children: [
+					"Each step adds or removes one 1/",
+					n,
+					" unit. "
+				] }),
+				"Every whole keeps the same size and the same ",
+				n,
+				" equal parts."
+			] })
+		] });
+	}
 	const Y_MAIN = s.hasCompare ? .75 : 0;
 	const Y_CMP = -.95;
 	const yMin = s.hasCompare ? -2.1 : -1.5;
@@ -53,7 +100,7 @@ function FractionBarScene() {
 				opacity: .6,
 				dashed: true
 			}),
-			/* @__PURE__ */ jsx(MovableDot$1, {
+			/* @__PURE__ */ jsx(MovableDot, {
 				control: num,
 				toPoint: (value) => ({
 					x: value,
@@ -92,6 +139,122 @@ function FractionBarScene() {
 		}) : undefined
 	});
 }
+/** Intact bars and detached pieces share exactly the same horizontal unit scale. */
+function ExchangeScene() {
+	const { scenario: s, reading: r } = useLabView(fractionBarModel);
+	const exchangeWhole = useControl(fractionBarModel, "exchangeWhole");
+	const combinePieces = useControl(fractionBarModel, "combinePieces");
+	const removeWhole = useControl(fractionBarModel, "removeWhole");
+	const removePiece = useControl(fractionBarModel, "removePiece");
+	const e = r.exchange;
+	const n = s.denom;
+	const color = r.solved ? "var(--stage-good)" : "var(--stage-accent)";
+	const rowCount = Math.ceil(e.looseUnits / n);
+	const viewWidth = n * 1.18;
+	return /* @__PURE__ */ jsxs(Stack, {
+		"data-part": "fraction-exchange",
+		"data-whole-groups": e.wholeGroups,
+		"data-loose-units": e.looseUnits,
+		"data-total-units": e.totalUnitCount,
+		children: [
+			/* @__PURE__ */ jsxs("div", { children: [
+				/* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsxs("strong", { children: [
+					e.wholeGroups,
+					" intact ",
+					e.wholeGroups === 1 ? "whole" : "wholes"
+				] }) }),
+				e.wholeGroups > 0 ? /* @__PURE__ */ jsx(Stage, {
+					view: {
+						xMin: -.1,
+						xMax: viewWidth,
+						yMin: -.7,
+						yMax: e.wholeGroups * 2 - 1.3
+					},
+					height: e.wholeGroups * 56,
+					preserveAspect: false,
+					pad: 4,
+					ariaLabel: `${e.wholeGroups} intact equal ${e.wholeGroups === 1 ? "whole" : "wholes"}, each containing ${n} equal ${n === 1 ? "piece" : "pieces"}`,
+					children: Array.from({ length: e.wholeGroups }, (_, i) => /* @__PURE__ */ jsx("g", {
+						"data-part": "fraction-exchange-whole",
+						children: /* @__PURE__ */ jsx(BarStrip, {
+							span: n,
+							cells: n,
+							shaded: n,
+							y: i * 2,
+							color,
+							weight: 28
+						})
+					}, i))
+				}) : /* @__PURE__ */ jsx("p", { children: "No intact wholes remain." }),
+				/* @__PURE__ */ jsxs(Cluster, { children: [/* @__PURE__ */ jsx(ControlButton, {
+					control: exchangeWhole,
+					appearance: "compact-key"
+				}), /* @__PURE__ */ jsx(ControlButton, {
+					control: removeWhole,
+					appearance: "compact-key"
+				})] })
+			] }),
+			/* @__PURE__ */ jsxs("div", { children: [
+				/* @__PURE__ */ jsxs("p", { children: [
+					/* @__PURE__ */ jsxs("strong", { children: [
+						e.looseUnits,
+						" loose ",
+						e.looseUnits === 1 ? "piece" : "pieces"
+					] }),
+					" ",
+					"· each is 1/",
+					n,
+					" of the same whole"
+				] }),
+				rowCount > 0 ? /* @__PURE__ */ jsx(Stage, {
+					view: {
+						xMin: -.1,
+						xMax: viewWidth,
+						yMin: -.7,
+						yMax: rowCount * 2 - 1.3
+					},
+					height: rowCount * 56,
+					preserveAspect: false,
+					pad: 4,
+					ariaLabel: `${e.looseUnits} separate loose ${e.looseUnits === 1 ? "piece" : "pieces"}, each 1/${n} of the original whole`,
+					children: Array.from({ length: e.looseUnits }, (_, i) => /* @__PURE__ */ jsx("g", {
+						"data-part": "fraction-exchange-piece",
+						children: /* @__PURE__ */ jsx(BarStrip, {
+							x: i % n * 1.18,
+							span: 1,
+							cells: 1,
+							shaded: 1,
+							y: Math.floor(i / n) * 2,
+							color,
+							weight: 28
+						})
+					}, i))
+				}) : e.wholeGroups > 0 ? /* @__PURE__ */ jsxs("p", { children: [
+					"No loose pieces yet. Exchange one intact whole to release its ",
+					n,
+					" ",
+					n === 1 ? "piece" : "pieces",
+					"."
+				] }) : /* @__PURE__ */ jsx("p", { children: "Nothing remains. Start over to restore the opening amount." }),
+				/* @__PURE__ */ jsxs(Cluster, { children: [/* @__PURE__ */ jsx(ControlButton, {
+					control: combinePieces,
+					appearance: "compact-key"
+				}), /* @__PURE__ */ jsx(ControlButton, {
+					control: removePiece,
+					appearance: "compact-key"
+				})] })
+			] }),
+			/* @__PURE__ */ jsxs("p", { children: [
+				"One whole always has ",
+				n,
+				" equal ",
+				n === 1 ? "piece" : "pieces",
+				s.whole != null ? ` and represents ${s.whole}${s.unit ? ` ${s.unit}` : ""}` : "",
+				". Exchange or combine to change the grouping without changing the total. Remove material to change the amount."
+			] })
+		]
+	});
+}
 
 //#endregion
 export { FractionBarScene };

package/dist/domains/math/number/fraction-division/activity.mjs

@@ -0,0 +1,15 @@
+import { labActivity } from "../../../../kit/goal-activity.mjs";
+import { defineActivity } from "../../../../runtime/activity.mjs";
+import { fractionDivisionModel } from "./model.mjs";
+
+//#region src/domains/math/number/fraction-division/activity.ts
+const fractionDivisionActivity = defineActivity(fractionDivisionModel, (s) => labActivity({
+	title: "How many portions fit?",
+	objectives: ["Compare available amount with equal portions on one physical scale"],
+	lead: s.hasTarget ? `Each piece is 1/${s.denominator} ${s.unit}. Set ${s.targetAmountUnits} available pieces and ${s.targetPortionUnits} pieces per portion. Count complete portions and inspect any part of another portion.` : `One whole is 1 ${s.unit}, split into ${s.denominator} equal pieces. Change the portion size and watch how many portions fit. The diagonally marked pieces form part of another portion.`,
+	controls: ["amountUnits", "portionUnits"],
+	goal: "grouped"
+}));
+
+//#endregion
+export { fractionDivisionActivity };

package/dist/domains/math/number/fraction-division/manifest.mjs

@@ -0,0 +1,73 @@
+import { defineLab } from "../../../../lab-def/define-lab.mjs";
+import { fractionDivisionModel } from "./model.mjs";
+
+//#region src/domains/math/number/fraction-division/manifest.ts
+var manifest_default = defineLab({
+	id: "fraction-division",
+	domain: "math",
+	group: "Math",
+	title: "How many portions fit?",
+	description: "Group an available amount into equal portions on one unchanged physical scale, including part of another portion. Exact quotient readings count portions.",
+	model: fractionDivisionModel,
+	examples: [
+		{
+			name: "Three quarters in half-litre portions",
+			props: {
+				denominator: 8,
+				amountUnits: 6,
+				portionUnits: 2,
+				targetAmountUnits: 6,
+				targetPortionUnits: 4,
+				controlConfig: { hide: ["amountUnits"] }
+			}
+		},
+		{
+			name: "One and a half litres in three-quarter-litre portions",
+			props: {
+				denominator: 8,
+				amountUnits: 12,
+				portionUnits: 4,
+				targetAmountUnits: 12,
+				targetPortionUnits: 6
+			}
+		},
+		{
+			name: "Zero available amount",
+			props: { amountUnits: 0 }
+		},
+		{
+			name: "Two-whole portion",
+			props: {
+				amountUnits: 16,
+				portionUnits: 16
+			}
+		}
+	],
+	experience: {
+		openingPhase: "act",
+		objectives: ["Group an available quantity into equal portions", "Read complete portions and a fraction of another portion on one physical scale"],
+		phases: ["act", "observe"],
+		responses: [],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	taxonomy: {
+		qualityTier: "support",
+		grades: [
+			"5",
+			"6",
+			"7"
+		],
+		outcomes: ["math", "fractions"],
+		durationMinutes: 5,
+		interaction: "explorer",
+		authorability: "moderate"
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/math/number/fraction-division/model.mjs

@@ -0,0 +1,86 @@
+import { defineLabModel } from "../../../../model/define.mjs";
+import { refuse } from "../../../../model/index.mjs";
+import { z } from "zod";
+import { readFractionDivision } from "@classytic/stage/math";
+
+//#region src/domains/math/number/fraction-division/model.ts
+/** Stage owns physical quantities, grouping and exact portion counts. */
+const fractionDivisionModel = defineLabModel({
+	id: "fraction-division",
+	params: z.object({
+		denominator: z.number().int().min(1).max(8).default(8).describe("equal pieces in one original whole"),
+		amountUnits: z.number().int().min(0).default(6).describe("initial available count of equal pieces"),
+		portionUnits: z.number().int().min(1).default(2).describe("initial equal pieces in one portion"),
+		targetAmountUnits: z.number().int().min(0).optional().describe("goal available pieces; author with targetPortionUnits"),
+		targetPortionUnits: z.number().int().min(1).optional().describe("goal portion pieces; author with targetAmountUnits"),
+		unit: z.string().trim().min(1).max(12).default("L").describe("physical unit of one original whole, never of the quotient")
+	}),
+	resolve(p) {
+		const start = readFractionDivision(p);
+		if (!start.ok) return start;
+		if (p.targetAmountUnits == null !== (p.targetPortionUnits == null)) return refuse("target-pair", "Author targetAmountUnits and targetPortionUnits together, or omit both to explore.");
+		if (p.targetAmountUnits != null && p.targetPortionUnits != null) {
+			const target = readFractionDivision({
+				...p,
+				amountUnits: p.targetAmountUnits,
+				portionUnits: p.targetPortionUnits
+			});
+			if (!target.ok) return target;
+		}
+		return {
+			...p,
+			capacity: start.value.capacity,
+			hasTarget: p.targetAmountUnits != null
+		};
+	},
+	initial: (s) => ({
+		amountUnits: s.amountUnits,
+		portionUnits: s.portionUnits,
+		touched: false
+	}),
+	controls: (c) => ({
+		amountUnits: c.number({
+			label: "Available pieces",
+			step: 1,
+			range: (s) => [0, s.capacity],
+			get: (st) => st.amountUnits,
+			set: (st, v) => ({
+				...st,
+				amountUnits: v,
+				touched: st.touched || v !== st.amountUnits
+			})
+		}),
+		portionUnits: c.number({
+			label: "Pieces per portion",
+			step: 1,
+			range: (s) => [1, s.capacity],
+			get: (st) => st.portionUnits,
+			set: (st, v) => ({
+				...st,
+				portionUnits: v,
+				touched: st.touched || v !== st.portionUnits
+			})
+		})
+	}),
+	read(s, st) {
+		const divided = readFractionDivision({
+			...s,
+			...st
+		});
+		if (!divided.ok) throw new Error(divided.message);
+		return {
+			...divided.value,
+			matched: st.touched && (!s.hasTarget || st.amountUnits === s.targetAmountUnits && st.portionUnits === s.targetPortionUnits)
+		};
+	},
+	goals: { grouped: (r) => r.matched },
+	witness: (s) => ({
+		amountUnits: s.hasTarget ? s.targetAmountUnits : s.amountUnits === s.capacity ? 0 : s.amountUnits + 1,
+		portionUnits: s.hasTarget ? s.targetPortionUnits : s.portionUnits,
+		touched: true
+	}),
+	describe: (s, _st, r) => `One original whole is 1 ${s.unit}, split into ${s.denominator} equal pieces. Available amount ${r.amount.numerator}/${r.amount.denominator} ${s.unit}; one portion ${r.portion.numerator}/${r.portion.denominator} ${s.unit}. ${r.completePortions} complete ${r.completePortions === 1 ? "portion" : "portions"}${r.leftoverUnits > 0 ? ` and ${r.partialPortion.numerator}/${r.partialPortion.denominator} of another portion` : ""}, giving ${r.quotient.numerator}/${r.quotient.denominator} ${r.quotient.numerator === r.quotient.denominator ? "portion" : "portions"}. The quotient counts portions, not ${s.unit}.`
+});
+
+//#endregion
+export { fractionDivisionModel };

package/dist/domains/math/number/fraction-division/runtime.mjs

@@ -0,0 +1,24 @@
+'use client';
+
+import { useLab } from "../../../../runtime/use-lab.mjs";
+import { AuthoredActivityRuntime } from "../../../../kit/authored-activity-runtime.mjs";
+import { fractionDivisionModel } from "./model.mjs";
+import { fractionDivisionActivity } from "./activity.mjs";
+import { FractionDivisionScene } from "./scene.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/math/number/fraction-division/runtime.tsx
+function FractionDivision(props) {
+	const lab = useLab(fractionDivisionModel, props);
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		lab,
+		activity: fractionDivisionActivity,
+		layout: "stack",
+		keyControls: [],
+		sceneLabel: "Equal portions on the same physical scale",
+		children: /* @__PURE__ */ jsx(FractionDivisionScene, {})
+	});
+}
+
+//#endregion
+export { FractionDivision as default };