@classytic/labs 0.1.0 → 0.3.0

package/dist/math/poly/core.mjs

@@ -0,0 +1,268 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
+import { ONE, ZERO, abs, add as add$1, cx, div, fromPolar, isFiniteC, mul as mul$1, sub } from "../complex/core.mjs";
+import { evaluate } from "@classytic/stage";
+
+//#region src/math/poly/core.ts
+/**
+* Polynomial core, the canonical single-variable polynomial engine. The clean,
+* focused alternative to bolting on a heavy general CAS (Algebrite / nerdamer):
+* for the polynomial algebra school actually needs — expand, evaluate,
+* differentiate, FACTOR, and SOLVE any degree — a normalised coefficient form
+* makes everything fall out.
+*
+*   • a Poly is just `number[]` ascending: [a0, a1, …, an] = a0 + a1 x + … + an xⁿ.
+*   • roots of ANY degree via DURAND–KERNER (Weierstrass) simultaneous iteration,
+*     reusing the complex kernel — all n complex roots at once, then snapped to
+*     exact rationals where they're clearly nice (so 2, ½, −3 print exact, not
+*     1.9999999).
+*   • factored form is read straight off the cleaned roots (real → (x−r);
+*     complex pair → an irreducible real quadratic).
+*
+* Numerically safe: Durand–Kerner is capped at MAX_ITER and falls back gracefully;
+* coefficient arrays are trimmed; no overflow paths (the complex kernel guards div).
+*/
+var core_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	allRoots: () => allRoots,
+	deflate: () => deflate,
+	degree: () => degree,
+	deriv: () => deriv,
+	evalC: () => evalC,
+	evalPoly: () => evalPoly,
+	factorTex: () => factorTex,
+	fromAst: () => fromAst,
+	mul: () => mul,
+	polyTex: () => polyTex,
+	solve: () => solve,
+	solveEquation: () => solveEquation,
+	trim: () => trim
+});
+const EPS = 1e-9;
+const MAX_ITER = 300;
+const MAX_DEG = 8;
+const trim = (p) => {
+	let n = p.length;
+	while (n > 1 && Math.abs(p[n - 1]) < 1e-12) n--;
+	return p.slice(0, n);
+};
+const degree = (p) => trim(p).length - 1;
+/** Horner evaluation (real). */
+function evalPoly(p, x) {
+	let s = 0;
+	for (let i = p.length - 1; i >= 0; i--) s = s * x + (p[i] ?? 0);
+	return s;
+}
+/** Horner evaluation (complex). */
+function evalC(p, z) {
+	let s = ZERO;
+	for (let i = p.length - 1; i >= 0; i--) s = add$1(mul$1(s, z), cx(p[i] ?? 0));
+	return s;
+}
+/** Derivative polynomial. */
+const deriv = (p) => trim(p.slice(1).map((c, i) => c * (i + 1)));
+function add(a, b) {
+	const n = Math.max(a.length, b.length), o = [];
+	for (let i = 0; i < n; i++) o.push((a[i] ?? 0) + (b[i] ?? 0));
+	return trim(o);
+}
+function mul(a, b) {
+	const o = new Array(a.length + b.length - 1).fill(0);
+	for (let i = 0; i < a.length; i++) for (let j = 0; j < b.length; j++) o[i + j] += a[i] * b[j];
+	return trim(o);
+}
+/** Synthetic division of p by (x − r); returns the quotient (assumes r is a root,
+*  i.e. drops the remainder). The "divide out a found factor" step. */
+function deflate(p, r) {
+	const n = p.length - 1;
+	if (n < 1) return [0];
+	const q = new Array(n).fill(0);
+	q[n - 1] = p[n];
+	for (let k = n - 2; k >= 0; k--) q[k] = p[k + 1] + r * q[k + 1];
+	return trim(q);
+}
+const tnum = (n) => {
+	const r = Math.round(n * 1e6) / 1e6;
+	return (Object.is(r, -0) ? 0 : r).toString();
+};
+/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
+function polyTex(p0, x = "x") {
+	const p = trim(p0);
+	let out = "";
+	for (let d = p.length - 1; d >= 0; d--) {
+		const c = p[d];
+		if (c === 0) continue;
+		const mag = Math.abs(c);
+		const t = `${d === 0 ? tnum(mag) : mag === 1 ? "" : tnum(mag)}${d === 0 ? "" : d === 1 ? x : `${x}^{${d}}`}`;
+		out += out === "" ? c < 0 ? `-${t}` : t : c < 0 ? ` - ${t}` : ` + ${t}`;
+	}
+	return out || "0";
+}
+function hasVar(node, x) {
+	switch (node.type) {
+		case "var": return node.name === x;
+		case "neg": return hasVar(node.arg, x);
+		case "binary": return hasVar(node.left, x) || hasVar(node.right, x);
+		case "call": return node.args.some((a) => hasVar(a, x));
+		default: return false;
+	}
+}
+/** Coefficients of `node` as a polynomial in `x` (other vars from `params`), or
+*  null if it isn't a polynomial in x (sin(x), 1/x, fractional power, …). */
+function fromAst(node, x = "x", params = {}) {
+	if (!hasVar(node, x)) {
+		const v = evaluate(node, params);
+		return Number.isFinite(v) ? [v] : null;
+	}
+	switch (node.type) {
+		case "var": return [0, 1];
+		case "neg": {
+			const c = fromAst(node.arg, x, params);
+			return c && c.map((k) => -k);
+		}
+		case "binary": {
+			const { op, left, right } = node;
+			const L = fromAst(left, x, params);
+			if (!L) return null;
+			if (op === "+") {
+				const R = fromAst(right, x, params);
+				return R && add(L, R);
+			}
+			if (op === "-") {
+				const R = fromAst(right, x, params);
+				return R && add(L, R.map((k) => -k));
+			}
+			if (op === "*") {
+				const R = fromAst(right, x, params);
+				return R && mul(L, R);
+			}
+			if (op === "/") {
+				if (hasVar(right, x)) return null;
+				const d = evaluate(right, params);
+				return Number.isFinite(d) && d !== 0 ? L.map((k) => k / d) : null;
+			}
+			if (op === "^") {
+				if (hasVar(right, x)) return null;
+				const n = evaluate(right, params);
+				if (!Number.isInteger(n) || n < 0 || n > MAX_DEG) return null;
+				let acc = [1];
+				for (let i = 0; i < n; i++) acc = mul(acc, L);
+				return acc;
+			}
+			return null;
+		}
+		default: return null;
+	}
+}
+/** Snap a near-rational real to its exact value (denominators 1..12), else itself. */
+function snapReal(r) {
+	for (const d of [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		8,
+		10,
+		12
+	]) {
+		const n = Math.round(r * d);
+		if (Math.abs(r * d - n) < 1e-7) {
+			const v = n / d;
+			return Object.is(v, -0) ? 0 : v;
+		}
+	}
+	return Math.round(r * 1e9) / 1e9;
+}
+const snap = (z) => Math.abs(z.im) < 1e-7 ? {
+	re: snapReal(z.re),
+	im: 0
+} : {
+	re: snapReal(z.re),
+	im: snapReal(z.im)
+};
+/**
+* All complex roots of `p` via Durand–Kerner simultaneous iteration (then snapped).
+* For a degree-n polynomial returns n roots; real roots come back with im = 0.
+*/
+function allRoots(p0) {
+	const p = trim(p0);
+	const n = p.length - 1;
+	if (n <= 0) return [];
+	const lead = p[n];
+	const m = p.map((c) => c / lead);
+	let z = Array.from({ length: n }, (_, k) => fromPolar(1 + .1 * k / n, 2 * Math.PI * k / n + .6));
+	for (let it = 0; it < MAX_ITER; it++) {
+		let maxDelta = 0;
+		z = z.map((zi, i) => {
+			let denom = ONE;
+			for (let j = 0; j < n; j++) if (j !== i) denom = mul$1(denom, sub(zi, z[j]));
+			const corr = div(evalC(m, zi), denom);
+			if (!isFiniteC(corr)) return zi;
+			maxDelta = Math.max(maxDelta, abs(corr));
+			return sub(zi, corr);
+		});
+		if (maxDelta < EPS) break;
+	}
+	const roots = z.map(snap);
+	roots.sort((a, b) => a.im === 0 && b.im === 0 ? a.re - b.re : a.im === 0 ? -1 : b.im === 0 ? 1 : a.re - b.re || a.im - b.im);
+	return roots;
+}
+/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
+function solve(p0) {
+	const p = trim(p0);
+	const d = p.length - 1;
+	if (d < 1) return null;
+	const roots = allRoots(p);
+	return {
+		poly: p,
+		degree: d,
+		roots,
+		realRoots: roots.filter((r) => r.im === 0).map((r) => r.re)
+	};
+}
+/** Solve an expression-AST equation `expr = 0` for x, any degree. null if not a
+*  polynomial in x. (Linear/quadratic also flow through here, exactly.) */
+function solveEquation(node, x = "x", params = {}) {
+	const p = fromAst(node, x, params);
+	return p ? solve(p) : null;
+}
+const fnum = (n) => {
+	const r = Math.round(n * 1e6) / 1e6;
+	return (Object.is(r, -0) ? 0 : r).toString().replace(/^-/, "−");
+};
+/** "(x − r)" with the sign tucked in, and "(x − 0)" → "x". */
+const linTex = (r, x) => r === 0 ? x : `(${x} ${r < 0 ? "+" : "−"} ${fnum(Math.abs(r))})`;
+/**
+* Factored form of the polynomial over the reals: leading coefficient × linear
+* factors (real roots, with multiplicity) × irreducible quadratics (complex
+* conjugate pairs). e.g. x³−6x²+11x−6 → "(x − 1)(x − 2)(x − 3)".
+*/
+function factorTex(p0, x = "x") {
+	const p = trim(p0);
+	const lead = p[p.length - 1] ?? 1;
+	const sol = solve(p);
+	if (!sol) return fnum(p[0] ?? 0);
+	const used = new Array(sol.roots.length).fill(false);
+	const parts = [];
+	for (let i = 0; i < sol.roots.length; i++) {
+		if (used[i]) continue;
+		const z = sol.roots[i];
+		if (z.im === 0) {
+			used[i] = true;
+			parts.push(linTex(z.re, x));
+			continue;
+		}
+		used[i] = true;
+		const j = sol.roots.findIndex((w, k) => !used[k] && Math.abs(w.re - z.re) < 1e-6 && Math.abs(w.im + z.im) < 1e-6);
+		if (j >= 0) used[j] = true;
+		const b2 = z.re * z.re + z.im * z.im, two = 2 * z.re;
+		const mid = Math.abs(two) < 1e-9 ? "" : ` ${two < 0 ? "+" : "−"} ${fnum(Math.abs(two))}${x}`;
+		parts.push(`(${x}^2${mid} ${b2 < 0 ? "−" : "+"} ${fnum(Math.abs(b2))})`);
+	}
+	const lc = Math.abs(lead - 1) < 1e-9 ? "" : `${fnum(lead)}\\,`;
+	return parts.length ? `${lc}${parts.join("")}` : fnum(lead);
+}
+
+//#endregion
+export { core_exports, deflate, degree, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };

package/dist/math/poly/index.d.mts

@@ -0,0 +1,3 @@
+import { Poly, PolyRoots, add, allRoots, core_d_exports, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim } from "./core.mjs";
+import { factorSteps, solveSteps } from "./steps.mjs";
+import { PolynomialSolverLab, PolynomialSolverProps, SolverMode } from "./preset.mjs";

package/dist/math/poly/preset.d.mts

@@ -0,0 +1,23 @@
+import { ReactNode } from "react";
+
+//#region src/math/poly/preset.d.ts
+type SolverMode = 'factor' | 'solve';
+interface PolynomialSolverProps {
+  /** The polynomial in x, e.g. "x^2 + 5x + 6" or "x^3 - 6x^2 + 11x - 6". */
+  expr?: string;
+  mode?: SolverMode;
+  /** Let the learner edit the polynomial (the live solver). Default true. */
+  editable?: boolean;
+  height?: number;
+  title?: string;
+  prompt?: string;
+}
+declare function PolynomialSolverLab({
+  expr,
+  mode,
+  editable,
+  title,
+  prompt
+}?: PolynomialSolverProps): ReactNode;
+//#endregion
+export { PolynomialSolverLab, PolynomialSolverProps, SolverMode };

package/dist/math/poly/preset.mjs

@@ -0,0 +1,123 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { Chip, TextInput } from "../../kit/controls.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { toStr } from "../complex/core.mjs";
+import { factorTex, fromAst, polyTex, solve } from "./core.mjs";
+import { WorkedSteps } from "../../kit/rule.mjs";
+import { factorSteps, solveSteps } from "./steps.mjs";
+import { useMemo, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { compileExpr } from "@classytic/stage";
+
+//#region src/math/poly/preset.tsx
+/**
+* PolynomialSolverLab, the dynamic "factor & solve" TOOL (the solver path, vs the
+* curated lesson path). Type or author a polynomial; the engine factors it / solves
+* it = 0 and SHOWS THE WORKING using the school method (split the middle term;
+* factor theorem for higher degree). Runs entirely client-side on the canonical
+* poly core — no heavy CAS dependency. "Show the steps" is a reveal so the learner
+* can try first.
+*/
+function PolynomialSolverLab({ expr = "x^2 + 5x + 6", mode = "factor", editable = true, title = mode === "solve" ? "Solve the polynomial" : "Factor the polynomial", prompt = mode === "solve" ? "Type a polynomial; see it solved step by step." : "Type a polynomial; see it factored step by step." } = {}) {
+	const [src, setSrc] = useState(expr);
+	const [show, setShow] = useState(false);
+	const result = useMemo(() => {
+		const c = compileExpr(src);
+		if (c.error || !c.ast) return { error: "Could not read that expression." };
+		const p = fromAst(c.ast);
+		if (!p) return { error: "That is not a polynomial in x." };
+		if (p.length <= 1) return { error: "Enter a polynomial in x (degree ≥ 1)." };
+		const sol = solve(p);
+		return {
+			p,
+			sol,
+			worked: mode === "solve" ? solveSteps(p) : factorSteps(p),
+			answerTex: mode === "solve" ? sol.roots.map((r) => `x = ${toStr(r)}`).join(" \\quad\\text{or}\\quad ") : factorTex(p),
+			polyTex: polyTex(p)
+		};
+	}, [src, mode]);
+	const figure = "error" in result ? /* @__PURE__ */ jsxs("p", {
+		className: "lab-misconception",
+		role: "status",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				"aria-hidden": true,
+				children: "⚠"
+			}),
+			" ",
+			result.error
+		]
+	}) : /* @__PURE__ */ jsxs("div", {
+		className: "math-polynomial-result",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "math-polynomial-equation",
+			children: [
+				/* @__PURE__ */ jsx(Tex$1, {
+					tex: `${result.polyTex}${mode === "solve" ? " = 0" : ""}`,
+					block: true
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "math-polynomial-arrow",
+					children: "→"
+				}),
+				/* @__PURE__ */ jsx(Tex$1, {
+					tex: result.answerTex,
+					block: true
+				})
+			]
+		}), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Chip, {
+			selected: show,
+			onClick: () => setShow((s) => !s),
+			"aria-pressed": show,
+			children: show ? "▾ hide the steps" : "▸ show the steps"
+		}), show && /* @__PURE__ */ jsx("div", {
+			className: "math-polynomial-steps",
+			children: /* @__PURE__ */ jsx(WorkedSteps, { worked: result.worked })
+		})] })]
+	});
+	const controls = editable ? /* @__PURE__ */ jsx("div", {
+		className: "lab-activity-fields",
+		children: /* @__PURE__ */ jsxs("label", {
+			className: "math-polynomial-input",
+			children: [/* @__PURE__ */ jsx("span", { children: mode === "solve" ? "solve" : "factor" }), /* @__PURE__ */ jsx(TextInput, {
+				value: src,
+				onChange: (value) => {
+					setSrc(value);
+					setShow(false);
+				},
+				label: "polynomial in x",
+				mono: true
+			})]
+		})
+	}) : void 0;
+	const hasError = "error" in result;
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "math-polynomial-solver-activity",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Polynomial tools",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [/* @__PURE__ */ jsx("strong", { children: hasError ? "Check the expression" : mode === "solve" ? "Polynomial solved" : "Polynomial factored" }), /* @__PURE__ */ jsx("span", { children: mode })] }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [/* @__PURE__ */ jsx(Activity.Canvas, {
+				label: "Polynomial result",
+				children: figure
+			}), controls ? /* @__PURE__ */ jsx(Activity.Inspector, {
+				label: "Polynomial input",
+				children: controls
+			}) : null] }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, { children: [/* @__PURE__ */ jsx("span", { children: hasError ? "Input" : "Method" }), /* @__PURE__ */ jsx("div", { children: hasError ? result.error : "Reveal the working when you are ready to compare each algebraic step." })] }),
+			/* @__PURE__ */ jsx(Activity.LiveRegion, { children: hasError ? result.error : `${mode === "solve" ? "Solution" : "Factorization"} ready.` }),
+			/* @__PURE__ */ jsx(Activity.Transport, { children: /* @__PURE__ */ jsxs("div", {
+				className: "lab-transport-state",
+				children: [/* @__PURE__ */ jsx("strong", { children: show ? "Working revealed" : "Try it first" }), /* @__PURE__ */ jsx("span", { children: editable ? "edit the polynomial to explore another case" : mode })]
+			}) })
+		]
+	});
+}
+
+//#endregion
+export { PolynomialSolverLab };

package/dist/math/poly/steps.d.mts

@@ -0,0 +1,10 @@
+import { Worked } from "../../kit/calc.mjs";
+import { Poly } from "./core.mjs";
+
+//#region src/math/poly/steps.d.ts
+/** Step-by-step FACTORISATION of a polynomial. */
+declare function factorSteps(p0: Poly, x?: string): Worked;
+/** Step-by-step SOLUTION of p = 0 (factor, then each factor = 0 → the roots). */
+declare function solveSteps(p0: Poly, x?: string): Worked;
+//#endregion
+export { factorSteps, solveSteps };

package/dist/math/poly/steps.mjs

@@ -0,0 +1,99 @@
+import { toStr } from "../complex/core.mjs";
+import { deflate, degree, evalPoly, factorTex, polyTex, solve, trim } from "./core.mjs";
+import { calc } from "../../kit/calc.mjs";
+
+//#region src/math/poly/steps.ts
+/**
+* Polynomial SOLVER steps, the engine side of a step-by-step solver. It emits a
+* {@link Worked} trace (the same data a RuleCard / lesson renders) using the
+* COMMON SCHOOL METHOD, not a raw CAS dump:
+*   • quadratics  → split the middle term (find the factor pair of a·c that adds
+*                   to b) and factor by grouping; fall back to the quadratic
+*                   formula + discriminant when it doesn't factor over ℤ.
+*   • higher deg  → the factor theorem: find a rational root, divide out (x − r)
+*                   by synthetic division, repeat down to a quadratic.
+*
+* Pure: builds on the canonical poly core + complex kernel. A creator drops the
+* solver lab; the learner sees the working. (For a curated LESSON, author the
+* steps by hand instead — this is the TOOL path.)
+*/
+const n2 = (n) => {
+	const r = Math.round(n * 1e6) / 1e6;
+	return (Object.is(r, -0) ? 0 : r).toString();
+};
+const lin = (r, x) => r === 0 ? x : `(${x} ${r < 0 ? "+" : "-"} ${n2(Math.abs(r))})`;
+/** coefficient × x-power, dropping a leading 1 (so "x^2", not "1x^2"). */
+const cx = (c, xp) => Math.abs(c) === 1 && xp ? c < 0 ? `-${xp}` : xp : `${n2(c)}${xp}`;
+/** Integer pair (u, v) with u·v = prod and u + v = sum, or null. */
+function factorPair(prod, sum) {
+	if (!Number.isInteger(prod) || !Number.isInteger(sum)) return null;
+	const lim = Math.min(2e4, Math.abs(prod) + 1);
+	for (let u = -lim; u <= lim; u++) {
+		if (u === 0) {
+			if (prod === 0 && v0(sum) === 0) return [0, sum];
+			continue;
+		}
+		if (prod % u === 0) {
+			const v = prod / u;
+			if (u + v === sum) return [u, v];
+		}
+	}
+	return null;
+}
+const v0 = (s) => s;
+function quadratic(p, x) {
+	const a = p[2], b = p[1], c = p[0];
+	const w = calc().step(`${polyTex(p, x)} \\;=\\; a${x}^2 + b${x} + c`, `compare to ax² + bx + c: a = ${n2(a)} (the x² coefficient), b = ${n2(b)} (the middle), c = ${n2(c)} (the constant)`);
+	const ac = a * c;
+	const pair = factorPair(ac, b);
+	if (pair && [
+		a,
+		b,
+		c
+	].every(Number.isInteger)) {
+		const [u, v] = pair;
+		w.step(`a \\times c = (${n2(a)})(${n2(c)}) = ${n2(ac)}`, "multiply the x² coefficient by the constant").step(`\\text{find } u, v:\\ \\ u \\cdot v = ${n2(ac)}\\ \\text{ and }\\ u + v = ${n2(b)} \\;\\Rightarrow\\; u = ${n2(u)},\\ v = ${n2(v)}`, `two numbers that multiply to a·c (${n2(ac)}) and add to b (${n2(b)})`).step(`${cx(a, `${x}^2`)} ${u < 0 ? "-" : "+"} ${n2(Math.abs(u))}${x} ${v < 0 ? "-" : "+"} ${n2(Math.abs(v))}${x} ${c < 0 ? "-" : "+"} ${n2(Math.abs(c))}`, `split the middle term ${n2(b)}${x} into ${n2(u)}${x} + ${n2(v)}${x}`).step(`= ${factorTex(p, x)}`, "group in pairs and take out the common factor");
+		return w.done(0);
+	}
+	const disc = b * b - 4 * a * c;
+	const sol = solve(p);
+	w.step(`\\Delta = b^2 - 4ac = (${n2(b)})^2 - 4(${n2(a)})(${n2(c)}) = ${n2(disc)}`, disc < 0 ? "the discriminant is negative, so the roots are complex" : "the discriminant b² − 4ac (no whole-number pair exists, so use the formula)").step(`x = \\dfrac{-b \\pm \\sqrt{\\Delta}}{2a} = \\dfrac{${n2(-b)} \\pm \\sqrt{${n2(disc)}}}{${n2(2 * a)}}`, "substitute a, b and Δ into the quadratic formula").step(sol.roots.length === 2 ? `x = ${toStr(sol.roots[0])} \\text{ or } ${toStr(sol.roots[1])}` : `x = ${toStr(sol.roots[0])}`, "the two roots").step(`= ${factorTex(p, x)}`, "factored form");
+	return w.done(0);
+}
+/** Step-by-step FACTORISATION of a polynomial. */
+function factorSteps(p0, x = "x") {
+	const p = trim(p0);
+	const d = degree(p);
+	if (d <= 1) return calc().step(polyTex(p, x), d === 1 ? "already linear (a factor itself)" : "a constant").done(0);
+	if (d === 2) return quadratic(p, x);
+	const w = calc().step(polyTex(p, x), "the polynomial");
+	let cur = p;
+	for (const root of solve(p).roots) {
+		if (root.im !== 0) continue;
+		const r = root.re;
+		if (degree(cur) <= 2 || Math.abs(evalPoly(cur, r)) > 1e-6) continue;
+		w.step(`f(${n2(r)}) = 0 \\Rightarrow ${lin(r, x)} \\text{ is a factor}`, "factor theorem");
+		cur = deflate(cur, r);
+		w.step(`\\text{quotient } = ${polyTex(cur, x)}`, "divide it out (synthetic division)");
+	}
+	if (degree(cur) === 2) w.step(`${polyTex(cur, x)} \\Rightarrow \\text{factor the quadratic}`, "split the middle term / formula");
+	w.step(`= ${factorTex(p, x)}`, "fully factored");
+	return w.done(0);
+}
+/** Step-by-step SOLUTION of p = 0 (factor, then each factor = 0 → the roots). */
+function solveSteps(p0, x = "x") {
+	const p = trim(p0);
+	const sol = solve(p);
+	if (!sol) return calc().step(polyTex(p, x), "no equation to solve").done(0);
+	const w = calc().step(`${polyTex(p, x)} = 0`, "set the polynomial to zero");
+	if (degree(p) === 2) {
+		const inner = quadratic(p, x);
+		for (const s of inner.steps.slice(1)) w.step(s.tex, s.note);
+	} else w.step(`${factorTex(p, x)} = 0`, "factor it (factor theorem)").step("\\text{each factor } = 0", "a product is 0 when a factor is 0");
+	const roots = sol.roots.map((r) => `${x} = ${toStr(r)}`).join(" \\text{ or } ");
+	w.step(roots || "\\text{no roots}", sol.realRoots.length < sol.roots.length ? "real and complex roots" : "the roots");
+	return w.done(sol.realRoots[0] ?? 0);
+}
+
+//#endregion
+export { factorSteps, solveSteps };

package/dist/math/radian-wrap/core.d.mts

@@ -0,0 +1,38 @@
+//#region src/math/radian-wrap/core.d.ts
+/** One laid-down radius: the arc it covers, and whether it is a whole one. */
+interface Band {
+  /** Where this band starts and ends, in radians from the positive x axis. */
+  from: number;
+  to: number;
+  /** 1 for a complete radius, less for the part-radius at the end. */
+  fraction: number;
+  /** 1-based index, for labelling. */
+  index: number;
+}
+declare const TAU: number;
+/** Degrees in one radian, to the precision a learner will see. */
+declare const DEG_PER_RAD: number;
+/**
+ * Split an angle into the whole radii laid so far plus the remainder.
+ *
+ * The bands are what makes the count visible: six full ones and a short stub is a
+ * picture a learner can hold, where "6.283185" is not.
+ */
+declare function bands(laid: number): Band[];
+/** How many WHOLE radii have been laid. The headline count. */
+declare const wholeRadii: (laid: number) => number;
+interface Readout {
+  /** The angle laid so far, in radians. Equals arc length divided by radius. */
+  radians: number;
+  degrees: number;
+  /** Arc length in the same units as the radius. */
+  arc: number;
+  /** Whole radii laid, and the leftover fraction of one. */
+  whole: number;
+  remainder: number;
+  /** True once the rim is closed, within a hair. */
+  closed: boolean;
+}
+declare function readout(laid: number, radius: number): Readout;
+//#endregion
+export { Band, DEG_PER_RAD, TAU, bands, readout, wholeRadii };

package/dist/math/radian-wrap/core.mjs

@@ -0,0 +1,58 @@
+//#region src/math/radian-wrap/core.ts
+const TAU = Math.PI * 2;
+/** Degrees in one radian, to the precision a learner will see. */
+const DEG_PER_RAD = 180 / Math.PI;
+/**
+* Split an angle into the whole radii laid so far plus the remainder.
+*
+* The bands are what makes the count visible: six full ones and a short stub is a
+* picture a learner can hold, where "6.283185" is not.
+*/
+function bands(laid) {
+	const out = [];
+	const total = Math.max(0, laid);
+	let placed = 0;
+	let index = 1;
+	while (placed < total - 1e-9) {
+		const span = Math.min(1, total - placed);
+		out.push({
+			from: placed,
+			to: placed + span,
+			fraction: span,
+			index
+		});
+		placed += span;
+		index += 1;
+	}
+	return out;
+}
+/** How many WHOLE radii have been laid. The headline count. */
+const wholeRadii = (laid) => Math.floor(laid + 1e-9);
+/** A point on the circle at `angle`, in figure coordinates (y already flipped). */
+function onCircle(centre, r, angle) {
+	return {
+		x: centre.x + r * Math.cos(angle),
+		y: centre.y - r * Math.sin(angle)
+	};
+}
+/** Sample an arc so it can be drawn as a polyline. */
+function arcPoints(centre, r, from, to, steps = 48) {
+	const pts = [];
+	const n = Math.max(2, Math.ceil(Math.abs(to - from) / TAU * steps) + 1);
+	for (let i = 0; i <= n; i++) pts.push(onCircle(centre, r, from + (to - from) * i / n));
+	return pts;
+}
+function readout(laid, radius) {
+	const radians = Math.max(0, laid);
+	return {
+		radians,
+		degrees: radians * DEG_PER_RAD,
+		arc: radians * radius,
+		whole: wholeRadii(radians),
+		remainder: radians - wholeRadii(radians),
+		closed: Math.abs(radians - TAU) < 1e-6
+	};
+}
+
+//#endregion
+export { DEG_PER_RAD, TAU, arcPoints, bands, onCircle, readout, wholeRadii };

package/dist/math/radian-wrap/index.d.mts

@@ -0,0 +1,2 @@
+import { RadianWrapLab, RadianWrapProps } from "./preset.mjs";
+import { Band, DEG_PER_RAD, TAU, bands, readout, wholeRadii } from "./core.mjs";

package/dist/math/radian-wrap/preset.d.mts

@@ -0,0 +1,19 @@
+import { ReactNode } from "react";
+
+//#region src/math/radian-wrap/preset.d.ts
+interface RadianWrapProps {
+  /** Where the slider starts, in radii of arc laid. Default 1, exactly one radian. */
+  startRadians?: number;
+  /** Drawn radius in figure units. The COUNT must not depend on it, which is the point. */
+  radius?: number;
+  title?: string;
+  prompt?: string;
+}
+declare function RadianWrapLab({
+  startRadians,
+  radius,
+  title,
+  prompt
+}?: RadianWrapProps): ReactNode;
+//#endregion
+export { RadianWrapLab, RadianWrapProps };