@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/math/algebra/mystery-bucket/scene.mjs

@@ -1,39 +1,112 @@
 'use client';
 
+import { FigText } from "../../../../kit/figure/text.mjs";
+import { SCENE } from "../../../../kit/scene/tokens.mjs";
+import { Figure } from "../../../../kit/figure/figure.mjs";
+import { SceneCanvas } from "../../../../kit/scene/scene.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
-import { mysteryBucketDoc } from "../../../../math/mystery-bucket/preset.mjs";
-import "../../../../math/mystery-bucket/index.mjs";
+import { useNarrow } from "../../../../kit/figure/narrow.mjs";
+import { Balance } from "../../../../kit/scene/objects/balance.mjs";
 import { mysteryBucketModel } from "./model.mjs";
-import { useMemo } from "react";
-import { Scene } from "@classytic/stage";
-import { jsx } from "react/jsx-runtime";
+import { useId } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { BucketGlyph, StageAssetDefs, WeightGlyph } from "@classytic/stage/assets";
 
 //#region src/domains/math/algebra/mystery-bucket/scene.tsx
-/**
-* A sealed bucket on one pan, a row of 1-unit weights on the other. Level means the two sides
-* agree; the drawing is stage's own `mystery-bucket` asset (a balance-scale world, not an SVG this
-* file draws itself), so this scene only turns the model's reading into that asset's SceneDoc.
-*/
+/** The existing balance and Stage glyphs at readable size; unit weights stack on their pan. */
 function MysteryBucketScene() {
 	const { scenario: s, state, reading } = useLabView(mysteryBucketModel);
-	const doc = useMemo(() => mysteryBucketDoc({
-		bucketWeight: s.per,
-		bucketCount: s.buckets,
-		count: state.count,
-		maxWeights: s.cap
-	}), [
-		s.per,
-		s.buckets,
-		state.count,
-		s.cap
-	]);
-	return /* @__PURE__ */ jsx(Scene, {
-		doc,
-		interactive: false,
-		showGrid: false,
-		showAxes: false,
-		height: 340,
-		ariaLabel: `Balance: a mystery bucket against ${state.count} unit weights, ${reading.balanced ? "level" : "tipping"}`
+	const { ref, narrow, width } = useNarrow();
+	const scope = useId();
+	const w = narrow ? Math.max(280, Math.min(400, width || 360)) : 440;
+	const rows = Math.max(1, Math.ceil(Math.max(s.buckets, s.cap) / 3));
+	const hang = rows * 36 + 36;
+	const h = hang + 146;
+	const tilt = Math.max(-13, Math.min(13, (state.count - s.total) * 4.5));
+	const stack = (count, bucket) => Array.from({ length: count }, (_, i) => {
+		const row = Math.floor(i / 3);
+		const inRow = Math.min(3, count - row * 3);
+		const cx = (i % 3 - (inRow - 1) / 2) * 34;
+		const top = -(row + 1) * 36;
+		return bucket ? /* @__PURE__ */ jsx(BucketGlyph, {
+			scope,
+			cx,
+			top,
+			wpx: 32,
+			hpx: 32,
+			label: reading.balanced ? String(s.per) : "?"
+		}, i) : /* @__PURE__ */ jsx("g", {
+			style: { "--stage-fg": SCENE.label.ink },
+			children: /* @__PURE__ */ jsx(WeightGlyph, {
+				scope,
+				cx,
+				top,
+				wpx: 30,
+				hpx: 30,
+				label: "1"
+			})
+		}, i);
+	});
+	return /* @__PURE__ */ jsx("div", {
+		ref,
+		children: /* @__PURE__ */ jsxs(Figure, {
+			viewBox: [w, h],
+			composition: "content",
+			domain: "math",
+			label: `${s.buckets} identical buckets against ${state.count} unit weights, ${reading.balanced ? "level" : "tipping"}. Each weight is one unit.`,
+			children: [/* @__PURE__ */ jsx(StageAssetDefs, { scope }), /* @__PURE__ */ jsxs(SceneCanvas, {
+				frame: {
+					w,
+					h,
+					groundY: h - 42
+				},
+				children: [
+					/* @__PURE__ */ jsx(FigText, {
+						x: w / 2,
+						y: 22,
+						anchor: "middle",
+						size: "label",
+						caps: false,
+						children: "Each weight is 1 unit"
+					}),
+					/* @__PURE__ */ jsx(Balance, {
+						cx: w / 2,
+						pivotY: 62,
+						arm: w / 2 - 72,
+						hang,
+						pan: 52,
+						tilt,
+						ground: h - 42,
+						left: stack(s.buckets, true),
+						right: stack(state.count, false)
+					}),
+					/* @__PURE__ */ jsxs(FigText, {
+						x: 72,
+						y: h - 12,
+						anchor: "middle",
+						size: "label",
+						caps: false,
+						children: [
+							s.buckets,
+							" identical ",
+							s.buckets === 1 ? "bucket" : "buckets"
+						]
+					}),
+					/* @__PURE__ */ jsxs(FigText, {
+						x: w - 72,
+						y: h - 12,
+						anchor: "middle",
+						size: "label",
+						caps: false,
+						children: [
+							state.count,
+							" unit ",
+							state.count === 1 ? "weight" : "weights"
+						]
+					})
+				]
+			})]
+		})
 	});
 }
 

package/dist/domains/math/algebra/partial-fractions/scene.mjs

@@ -2,15 +2,14 @@
 
 import { Tex } from "../../../../core/tex.mjs";
 import { STROKE } from "../../../../kit/figure/figure.mjs";
-import "../../../../kit/figure/index.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { CoordPlane } from "../../../../kit/coords.mjs";
 import { useAsking } from "../../../../kit/shell/earned.mjs";
 import { termTex } from "../../../../math/partial-fractions/core.mjs";
 import { partialFractionsModel } from "./model.mjs";
 import { Fragment } from "react";
-import { Polyline } from "@classytic/stage";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Polyline } from "@classytic/stage/primitives";
 
 //#region src/domains/math/algebra/partial-fractions/scene.tsx
 /**

package/dist/domains/math/algebra/polynomial-solver/activity.mjs

@@ -15,7 +15,7 @@ function wordsOf(game) {
 		}
 		case "split": return {
 			title: "Split the middle term",
-			lead: "Find two whole numbers that multiply to a × c and add to b. Tap the pairs; if none works, say so."
+			lead: game.cases[0]?.form === "two-letter" ? `Find two whole numbers that multiply to a × c and add to b; the ${game.cases[0].letters[1]}² rides along, so they become the two ${game.cases[0].letters.join("")} terms. Tap the pairs; if none works, say so.` : "Find two whole numbers that multiply to a × c and add to b. Tap the pairs; if none works, say so."
 		};
 		case "hunt": return {
 			title: "Hunt for a factor",
@@ -24,6 +24,9 @@ function wordsOf(game) {
 		case "tableau": return game.predict ? {
 			title: "Predict the remainder",
 			lead: "Work out the remainder before any division is shown. Then the tableau and the curve check your answer."
+		} : game.cases[0]?.kind === "long" ? {
+			title: "Divide by a quadratic",
+			lead: "Divide the leading terms, multiply the divisor, then subtract. Keep coefficients aligned by power, including zero for missing powers. Press Enter to check each cell."
 		} : {
 			title: "Divide by synthetic division",
 			lead: "Fill the tableau one cell at a time: bring the first coefficient down, multiply by the number on the left, add the column. Press Enter after each cell."
@@ -66,12 +69,13 @@ function cardOf(game, i) {
 			})),
 			answer: String(c.realCount),
 			explain: `The engine finds ${c.realCount} different real ${c.realCount === 1 ? "root" : "roots"}; a repeated root counts once here.`,
-			tryAgain: "Look for a factor, or use the discriminant of a quadratic factor.",
+			tryAgain: "Look for factors and count their different real solutions. A repeated solution counts once.",
 			hints: ["A polynomial of degree n has at most n real roots."]
 		};
 	}
 	if (game.kind === "tableau" && game.predict) {
 		const c = game.cases[i];
+		if (c.kind !== "synthetic") return null;
 		return {
 			kind: "text",
 			id: `${QUESTION_PREFIX.tableau}-${i}`,

package/dist/domains/math/algebra/polynomial-solver/cases-division.mjs

@@ -44,6 +44,7 @@ function buildTableau(source, divisorSource) {
 	const realRoots = realRootsOf(parsed.node);
 	const reach = Math.max(2.5, Math.ceil(Math.abs(r)) + 1.5, ...realRoots.map((k) => Math.ceil(Math.abs(k.x)) + 1));
 	return {
+		kind: "synthetic",
 		parsed,
 		divisorTex: d.tex,
 		divisorSource,
@@ -59,8 +60,53 @@ function buildTableau(source, divisorSource) {
 		realRoots
 	};
 }
+function buildLongTableau(source, divisorSource) {
+	const parsed = parsePoly(source);
+	if (isRefusal$1(parsed)) return parsed;
+	const divisor = parsePoly(divisorSource);
+	if (isRefusal$1(divisor)) return refuse(divisor.code, `The divisor: ${divisor.message}`);
+	const result = polynomial.longDivisionSteps(parsed.node, divisor.node);
+	if (!result.ok) return result;
+	const working = result.value;
+	const cells = [];
+	for (const [i, round] of working.rounds.entries()) {
+		cells.push({
+			row: i * 3,
+			col: round.power,
+			op: "quotient",
+			value: view(round.coefficient)
+		});
+		for (let power = round.power + 2; power >= 0; power -= 1) cells.push({
+			row: i * 3 + 1,
+			col: power,
+			op: "multiply",
+			value: view(round.product[power] ?? R.ZERO)
+		});
+		for (let power = round.power + 1; power >= 0; power -= 1) cells.push({
+			row: i * 3 + 2,
+			col: power,
+			op: "subtract",
+			value: view(round.difference[power] ?? R.ZERO)
+		});
+	}
+	return {
+		kind: "long",
+		parsed,
+		divisorTex: divisor.tex,
+		divisorSource,
+		cells,
+		working,
+		division: working.division,
+		quotientTex: toLatex(working.division.quotient),
+		remainderTex: toLatex(working.division.remainder)
+	};
+}
 /** What a cell asks for, as the prompt beside the input (never the value). */
 function cellPrompt(t, cell) {
+	if (t.kind === "long") {
+		const power = cell.col === 0 ? "constant" : cell.col === 1 ? "x" : `x^${cell.col}`;
+		return cell.op === "quotient" ? `Divide the leading coefficients to find the ${power} coefficient of the quotient.` : cell.op === "multiply" ? `Multiply the divisor by this quotient term: enter the ${power} coefficient.` : `Subtract the product from the current dividend: enter the ${power} coefficient, including zero for missing powers.`;
+	}
 	const prev = t.rows[2][cell.col - 1];
 	const raw = cell.op === "bring" ? "Bring the first coefficient down." : cell.op === "multiply" ? `Multiply ${prev?.text ?? ""} by ${t.root.text}.` : `Add the column: ${t.rows[0][cell.col].text} plus the product above.`;
 	return raw.replace(/-/g, "−");
@@ -114,4 +160,4 @@ function buildSquare(source) {
 }
 
 //#endregion
-export { buildSquare, buildTableau, cellPrompt };
+export { buildLongTableau, buildSquare, buildTableau, cellPrompt };

package/dist/domains/math/algebra/polynomial-solver/cases-factor.mjs

@@ -27,6 +27,7 @@ function buildSplit(source) {
 	const steps = school.trace.steps;
 	const at = steps.findIndex((st) => st.data?.kind === "factor-pairs");
 	return {
+		form: "one-letter",
 		parsed,
 		a: view(a),
 		b: bv,
@@ -143,6 +144,7 @@ const QUADRATIC_METHODS = new Set([
 function calculatorWork(c, factor) {
 	const all = c.school.trace.steps;
 	return {
+		form: "one-letter",
 		tex: c.parsed.tex,
 		steps: all.filter((s) => s.method !== "factorised" && !(factor && SOLVE_ONLY.has(s.method))),
 		quadraticOnly: all.every((s) => QUADRATIC_METHODS.has(s.method)),

package/dist/domains/math/algebra/polynomial-solver/cases-two-letter.mjs

@@ -0,0 +1,129 @@
+import { engineRefused, isRefusal as isRefusal$1, sameValue } from "./engine.mjs";
+import { buildSplit, calculatorWork, solveCached } from "./cases-factor.mjs";
+import { refuse } from "@classytic/stage/result";
+import { compileExpr, polynomial, toLatex } from "@classytic/stage/math";
+import { normalizeMathInput, splitLetterProducts } from "@classytic/stage/math/answer";
+
+//#region src/domains/math/algebra/polynomial-solver/cases-two-letter.ts
+/**
+* Two-letter cases: a HOMOGENEOUS polynomial in two letters (`x^2 - 7xy + 12y^2`, `2a^2 + 5ab + 2b^2`,
+* `a^3 - 27b^3`) factorised by stage's `polynomial.factorTwoLetterSchool`, which carries the second
+* letter through the school moves and closes on stage's multivariate factorisation (`factorMPoly`).
+* Only `factor` (the calculator) and `split` read two letters; one-letter input never reaches this
+* file's builders, so every one-letter case is built exactly as before (cases-factor.ts).
+*
+* There is no curve: a polynomial in two letters is not a function of one input, so these cases
+* carry no plot, and the scenes draw none.
+*/
+/**
+* Read `source` in two letters. Null when it has fewer than two letters (the one-letter path reads
+* it); a refusal when it has two or more letters but is not homogeneous in exactly two.
+* Letters typed together read as a product: `7xy` is 7·x·y.
+*/
+function readTwoLetter(source) {
+	let text;
+	try {
+		text = splitLetterProducts(normalizeMathInput(source));
+	} catch {
+		return null;
+	}
+	const compiled = compileExpr(text);
+	if (isRefusal$1(compiled)) return null;
+	const p = polynomial.MP.fromNode(compiled.ast);
+	if (!p || polynomial.MP.vars(p).length < 2) return null;
+	const form = polynomial.twoLetterForm(p);
+	if (typeof form === "string") return refuse("not-two-letter", `"${source}" cannot be factorised here: ${form}. Two letters need every term of the same degree, such as x^2 - 7xy + 12y^2.`);
+	const node = polynomial.MP.toNode(p, form);
+	return {
+		source,
+		node,
+		letters: form,
+		degree: polynomial.MP.totalDegree(p),
+		tex: toLatex(node)
+	};
+}
+function factorRead(read) {
+	const r = polynomial.factorTwoLetterSchool(read.node, read.letters);
+	return r.status === "solved" ? r : engineRefused(r.reason);
+}
+function buildTwoLetterSplit(read) {
+	if (read.degree !== 2) return refuse("needs-quadratic", `Split the middle term needs a quadratic; "${read.source}" has degree ${read.degree}.`);
+	const r = factorRead(read);
+	if (isRefusal$1(r)) return r;
+	if (!r.quadratic) return refuse("no-factor-pairs", `"${read.source}" has a letter in every term: take out the common factor instead of splitting.`);
+	const { a, b, c, pairs: fp } = r.quadratic;
+	const steps = r.trace.steps;
+	const at = steps.findIndex((s) => s.data?.kind === "factor-pairs");
+	const split = steps.find((s) => s.data?.kind === "split-group")?.data;
+	return {
+		form: "two-letter",
+		letters: r.letters,
+		tex: read.tex,
+		a,
+		b,
+		c,
+		ac: fp.ac,
+		pairs: fp.pairs,
+		chosen: fp.chosen,
+		matches: fp.pairs.map((pr) => sameValue(pr.sum.value, b.value)),
+		splitTex: split?.kind === "split-group" ? split.split : null,
+		work: steps.slice(at + 1),
+		factoredTex: toLatex(r.factored),
+		verified: r.verified
+	};
+}
+/** A split round in one letter (exactly as before) or two. */
+function buildSplitCase(source) {
+	const two = readTwoLetter(source);
+	if (two === null) return buildSplit(source);
+	return isRefusal$1(two) ? two : buildTwoLetterSplit(two);
+}
+const QUADRATIC_METHODS = new Set([
+	"factor-pairs",
+	"split-middle-term",
+	"factorised"
+]);
+function buildTwoLetterWork(read) {
+	const r = factorRead(read);
+	if (isRefusal$1(r)) return r;
+	const all = r.trace.steps;
+	return {
+		form: "two-letter",
+		letters: r.letters,
+		tex: read.tex,
+		steps: all.filter((s) => s.method !== "factorised"),
+		quadraticOnly: all.every((s) => QUADRATIC_METHODS.has(s.method)),
+		answerTex: toLatex(r.factored),
+		verified: r.verified
+	};
+}
+const calculated = new Map();
+/**
+* The calculator's working for any source: two letters (factorise only) or one letter (the school
+* method, exactly as before). Remembered, since the model reads it on every keystroke. Pure.
+*/
+function calculatorCase(source, factor) {
+	const key = `${factor ? "f" : "s"}:${source}`;
+	const hit = calculated.get(key);
+	if (hit) return hit;
+	const two = readTwoLetter(source);
+	let built;
+	if (two === null) {
+		const one = solveCached(source);
+		built = isRefusal$1(one) ? one : calculatorWork(one, factor);
+	} else if (isRefusal$1(two)) built = two;
+	else if (!factor) built = refuse("needs-one-letter", `Solving needs one unknown, and "${source}" has two letters. Factorise it instead (mode="factor").`);
+	else built = buildTwoLetterWork(two);
+	if (calculated.size > 64) calculated.delete(calculated.keys().next().value);
+	calculated.set(key, built);
+	return built;
+}
+/** How a typed draft reads, in one letter or two; null while it does not parse. */
+function draftTex(source, oneLetter) {
+	const two = readTwoLetter(source);
+	if (two && !isRefusal$1(two)) return two.tex;
+	return oneLetter(source);
+}
+
+//#endregion
+export { buildSplitCase, buildTwoLetterSplit, buildTwoLetterWork, calculatorCase, draftTex, readTwoLetter };

package/dist/domains/math/algebra/polynomial-solver/engine.mjs

@@ -153,6 +153,7 @@ const METHOD_LABEL = {
 	"quadratic-formula": "Formula",
 	"complete-square": "Complete the square",
 	factor: "Factorise",
+	"cubes-identity": "Cubes identity",
 	condition: "Condition",
 	"leading-coefficient": "Keep degree",
 	solve: "Solve",

package/dist/domains/math/algebra/polynomial-solver/games.mjs

@@ -1,6 +1,7 @@
 import { isRefusal, parsePoly } from "./engine.mjs";
 import { cellPrompt } from "./cases-division.mjs";
-import { calculatorWork, huntHints, solveCached } from "./cases-factor.mjs";
+import { huntHints } from "./cases-factor.mjs";
+import { calculatorCase, draftTex } from "./cases-two-letter.mjs";
 
 //#region src/domains/math/algebra/polynomial-solver/games.ts
 /**
@@ -162,7 +163,7 @@ function roundDone(game, play, r) {
 	if ((game.kind === "square" || game.kind === "solve") && (play.kind === "square" || play.kind === "solve")) {
 		return play.answered[r] ?? false;
 	}
-	if (game.kind === "calculator" && play.kind === "calculator") return !isRefusal(solveCached(play.source));
+	if (game.kind === "calculator" && play.kind === "calculator") return !isRefusal(calculatorCase(play.source, game.factor));
 	return false;
 }
 /** How many lines of the engine's working round `r` steps through (0: none to step). */
@@ -205,14 +206,14 @@ const texOf = (source) => {
 };
 function viewOf(game, play) {
 	if (game.kind === "calculator" && play.kind === "calculator") {
-		const built = solveCached(play.source);
+		const built = calculatorCase(play.source, game.factor);
 		return {
 			kind: "calculator",
 			factor: game.factor,
 			editable: game.editable,
-			preview: texOf(play.draft),
+			preview: draftTex(play.draft, texOf),
 			source: play.source,
-			work: isRefusal(built) ? null : calculatorWork(built, game.factor),
+			work: isRefusal(built) ? null : built,
 			error: isRefusal(built) ? built.message : null,
 			examples: EXAMPLES.map((e) => texOf(e) ?? e)
 		};

package/dist/domains/math/algebra/polynomial-solver/manifest.mjs

@@ -8,9 +8,25 @@ var manifest_default = defineLab({
 	domain: "math",
 	group: "Math",
 	title: "Polynomial solver (factor / solve, step by step)",
-	description: "Type a polynomial in x; the engine factors it or solves =0 and shows the working. Guided modes on the exact engine: split the middle term (factor-pair game), hunt for a factor (rational-root candidates as probes), fill a synthetic-division tableau, predict a remainder, complete the square, predict the real roots before the working.",
+	description: "Type a polynomial in x; the engine factors it or solves =0 and shows the working. Factorise and split the middle term also take a homogeneous polynomial in two letters (x^2 - 7xy + 12y^2, a^3 - 27b^3), the second letter carried. Guided modes on the exact engine: split the middle term (factor-pair game), hunt for a factor (rational-root candidates as probes), fill a synthetic-division tableau, predict a remainder, complete the square, predict the real roots before the working.",
 	model: polynomialSolverModel,
 	examples: [
+		{
+			name: "Quadratic long division with a polynomial remainder",
+			props: {
+				mode: "long-division",
+				expr: "x^4+x+1",
+				divisor: "2*x^2+1"
+			}
+		},
+		{
+			name: "Long division with exact rational coefficients",
+			props: {
+				mode: "long-division",
+				expr: "x^3/2+x/3+1",
+				divisor: "3*x^2/2-1"
+			}
+		},
 		{
 			name: "default",
 			props: {}
@@ -46,6 +62,21 @@ var manifest_default = defineLab({
 			name: "complete the square",
 			props: { mode: "complete-square" }
 		},
+		{
+			name: "NCTB two-letter split",
+			props: {
+				mode: "split",
+				expr: "x^2 - 7xy + 12y^2",
+				transfer: "2a^2 + 5ab + 2b^2"
+			}
+		},
+		{
+			name: "NCTB two-letter factor",
+			props: {
+				mode: "factor",
+				expr: "a^3 - 27b^3"
+			}
+		},
 		{
 			name: "FP1 polynomials and their roots",
 			props: {
@@ -427,6 +458,7 @@ var manifest_default = defineLab({
 			"Split the middle term by finding the factor pair of ac that adds to b, and recognise when none exists",
 			"Find a first factor of a cubic with the factor theorem, trying only ±p/q",
 			"Divide by (x − a) with a synthetic-division tableau and read the remainder as P(a)",
+			"Divide by a quadratic with aligned quotient, product and subtraction coefficients",
 			"Complete the square and read off the least or greatest value"
 		],
 		phases: [

package/dist/domains/math/algebra/polynomial-solver/model.mjs

@@ -1,8 +1,9 @@
 import { defineLabModel } from "../../../../model/define.mjs";
 import { refuse } from "../../../../model/index.mjs";
 import { isRefusal } from "./engine.mjs";
-import { buildSquare, buildTableau } from "./cases-division.mjs";
-import { buildHunt, buildSolve, buildSplit } from "./cases-factor.mjs";
+import { buildLongTableau, buildSquare, buildTableau } from "./cases-division.mjs";
+import { buildHunt, buildSolve } from "./cases-factor.mjs";
+import { buildSplitCase, calculatorCase, readTwoLetter } from "./cases-two-letter.mjs";
 import { finishedPlay, initialPlay, roundDone, scoreOf, viewOf, workCount } from "./games.mjs";
 import { calculate, canCheckCell, canShowCell, checkCell, claimNone, pickExample, respond, setFrame, showCell, showRound, tapPair, tryCandidate, typeCell, typeDraft } from "./moves.mjs";
 import { z } from "zod";
@@ -22,6 +23,9 @@ import { z } from "zod";
 *   synthetic / remainder          fill the division tableau; or predict P(a) on a card first
 *   complete-square                choose the bracket number on a card; the square and least value follow
 *
+* factor (the calculator) and split also read a homogeneous polynomial in two letters
+* (cases-two-letter.ts, stage's `factorTwoLetterSchool`); every other mode reads x only.
+*
 * Every guided game is played in rounds (docs/LAB-MODEL.md §5): `expr`, then `transfer`. Each step
 * opens its round with `show-round` and waits for `done` with `{ round }`; `done` without args (the
 * witness, the explore step) means every round. Per-item verbs (tap pair 3, try candidate 5) are
@@ -33,6 +37,7 @@ const MODES = [
 	"split",
 	"hunt",
 	"synthetic",
+	"long-division",
 	"remainder",
 	"complete-square"
 ];
@@ -43,14 +48,15 @@ const DEFAULT_EXPR = {
 	split: "2x^2 + 7x + 3",
 	hunt: "x^3 - 2x^2 - 5x + 6",
 	synthetic: "x^3 - 4x^2 + x + 6",
+	"long-division": "x^4 - 5x^2 + 4",
 	remainder: "2x^3 - 3x + 5",
 	"complete-square": "x^2 + 6x + 5"
 };
 const params = z.object({
-	mode: z.enum(MODES).default("factor").describe("factor/solve: the calculator (add guided for a real-root prediction per polynomial). split: factor-pair game on a × c. hunt: try ±p/q candidates. synthetic: fill the tableau. remainder: predict P(a) first. complete-square: choose the bracket number"),
-	expr: z.string().max(200).default("").describe("the polynomial in x, e.g. \"2x^3 - 3x^2 - 11x + 6\"; blank plays the mode's own example"),
+	mode: z.enum(MODES).default("factor").describe("factor/solve: the calculator (add guided for a real-root prediction per polynomial). split: factor-pair game on a × c. hunt: try ±p/q candidates. synthetic: fill the linear-divisor tableau. long-division: quadratic divisor, dividend degree 2..6, exact quotient/product/subtraction cells. remainder: predict P(a) first. complete-square: choose the bracket number"),
+	expr: z.string().max(200).default("").describe("the polynomial in x, e.g. \"2x^3 - 3x^2 - 11x + 6\"; factor (calculator) and split also take a homogeneous polynomial in two letters, e.g. \"x^2 - 7xy + 12y^2\" or \"a^3 - 27b^3\"; blank plays the mode's own example"),
 	transfer: z.string().max(200).default("").describe("a second polynomial, played as a second round (guided modes); blank for one round"),
-	divisor: z.string().max(60).default("").describe("synthetic / remainder: the divisor, e.g. 'x - 2' or '2x - 3'; blank is x - 2 (remainder: x + 1)"),
+	divisor: z.string().max(60).default("").describe("synthetic / remainder / long-division: the divisor, e.g. 'x - 2' or '2x - 3'; blank is x - 2 (remainder: x + 1; long-division: x^2 - 1)"),
 	transferDivisor: z.string().max(60).default("").describe("synthetic / remainder: the second round's divisor; blank reuses divisor"),
 	guided: z.boolean().default(false).describe("factor / solve only: predict the number of real roots, then step through the exact working. false keeps the calculator"),
 	editable: z.boolean().default(true).describe("calculator only: let the learner type another polynomial"),
@@ -72,7 +78,7 @@ function gameOf(p, sources) {
 		case "solve": {
 			const factor = p.mode === "factor";
 			if (!p.guided) {
-				const first = buildSolve(sources[0]);
+				const first = calculatorCase(sources[0], factor);
 				if (isRefusal(first)) return refuse(first.code, first.message, { prop: "expr" });
 				return {
 					kind: "calculator",
@@ -80,6 +86,8 @@ function gameOf(p, sources) {
 					editable: p.editable
 				};
 			}
+			const twoAt = sources.findIndex((source) => readTwoLetter(source) !== null);
+			if (twoAt >= 0) return refuse("needs-one-letter", "guided predicts the real roots of a polynomial in x; for two letters use the calculator (guided: false) or mode=\"split\".", { prop: twoAt === 0 ? "expr" : "transfer" });
 			const cases = build(sources, buildSolve);
 			return isRefusal(cases) ? cases : {
 				kind: "solve",
@@ -88,7 +96,7 @@ function gameOf(p, sources) {
 			};
 		}
 		case "split": {
-			const cases = build(sources, buildSplit);
+			const cases = build(sources, buildSplitCase);
 			return isRefusal(cases) ? cases : {
 				kind: "split",
 				cases
@@ -101,16 +109,17 @@ function gameOf(p, sources) {
 				cases
 			};
 		}
+		case "long-division":
 		case "synthetic":
 		case "remainder": {
 			const predict = p.mode === "remainder";
-			const divisor = p.divisor.trim() || (predict ? "x + 1" : "x - 2");
+			const divisor = p.divisor.trim() || (p.mode === "long-division" ? "x^2 - 1" : predict ? "x + 1" : "x - 2");
 			const divisors = [divisor, p.transferDivisor.trim() || divisor];
 			const cases = [];
 			for (const [i, source] of sources.entries()) {
-				const c = buildTableau(source, divisors[i]);
+				const c = p.mode === "long-division" ? buildLongTableau(source, divisors[i]) : buildTableau(source, divisors[i]);
 				if (isRefusal(c)) {
-					const ofDivisor = c.message.startsWith("The divisor") || c.code === "divisor-not-linear";
+					const ofDivisor = c.message.startsWith("The divisor") || c.code === "divisor-not-linear" || c.code === "divisor-not-quadratic";
 					const prop = ofDivisor ? i === 0 ? "divisor" : "transferDivisor" : i === 0 ? "expr" : "transfer";
 					return refuse(c.code, c.message, { prop });
 				}
@@ -242,7 +251,7 @@ function describePlay(game, v, st, round) {
 	}
 	if (v.kind === "tableau" && game.kind === "tableau") {
 		const c = game.cases[round];
-		if (v.predict) return v.unlocked ? `Remainder ${c.remainder.text}.` : "Type your prediction.";
+		if (v.predict && c.kind === "synthetic") return v.unlocked ? `Remainder ${c.remainder.text}.` : "Type your prediction.";
 		const stepText = v.cell !== null ? `Cell ${v.filled + 1} of ${c.cells.length}: ${v.cellPrompt}` : "Tableau complete.";
 		return v.wrong > 0 ? `Not yet. ${v.cellPrompt ?? ""}` : stepText;
 	}

package/dist/domains/math/algebra/polynomial-solver/moves.mjs

@@ -163,7 +163,7 @@ function gradeRemainder(game, questionId, response) {
 	const r = cardRound(game, questionId);
 	if (r === null || game.kind !== "tableau" || typeof response !== "string") return undefined;
 	const item = game.cases[r];
-	if (!item) return undefined;
+	if (!item || item.kind !== "synthetic") return undefined;
 	const correct = checkTyped(response, item.remainder);
 	return {
 		correct,

package/dist/domains/math/algebra/polynomial-solver/plots.mjs

@@ -4,11 +4,11 @@ import { Tex } from "../../../../core/tex.mjs";
 import { FigText } from "../../../../kit/figure/text.mjs";
 import { Figure, HUE, STROKE, alpha, tint } from "../../../../kit/figure/figure.mjs";
 import { PlaneTex, estimateTexWidth } from "../../../../kit/figure/math-text.mjs";
-import "../../../../kit/figure/index.mjs";
 import { CoordPlane, clearOfLabel as clearOfLabel$1, dotZone } from "../../../../kit/coords.mjs";
 import { clippedRuns } from "../../../../math/poly/model.mjs";
-import { Dot, Label, Polyline, Segment, useCoords } from "@classytic/stage";
+import { useCoords } from "@classytic/stage/core";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, Polyline, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/algebra/polynomial-solver/plots.tsx
 const PROBE_INK = {

package/dist/domains/math/algebra/polynomial-solver/runtime.mjs

@@ -86,7 +86,7 @@ function PolynomialSolver(props) {
 		className: `math-polynomial-solver-activity ${className}`,
 		activityId: activityIdOf(session?.scenario.mode ?? "factor", kind),
 		scene: "direct",
-		sceneLabel,
+		sceneLabel: session?.scenario.mode === "long-division" ? "The polynomial and the quadratic long-division tableau" : sceneLabel,
 		keyControls: [],
 		initialStepId: guided && revealed ? "explore" : undefined,
 		report: guided && !revealed,