@classytic/stage 0.3.0 → 0.4.0

package/dist/finance/management-accounting/variances.mjs

@@ -0,0 +1,150 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/variances.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function analyzeCostVariances(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	if ([
+		facts.actualOutputUnits,
+		facts.material.standardQuantityPerUnit,
+		facts.material.standardPricePerUnit,
+		facts.material.actualQuantity,
+		facts.material.actualPricePerUnit,
+		facts.labour.standardHoursPerUnit,
+		facts.labour.standardRatePerHour,
+		facts.labour.actualHours,
+		facts.labour.actualRatePerHour,
+		facts.variableOverhead.standardRatePerHour,
+		facts.variableOverhead.actualRatePerHour,
+		facts.fixedOverhead.budgeted,
+		facts.fixedOverhead.actual
+	].some((value) => !Number.isFinite(value) || value < 0)) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: "Variance inputs must be finite and non-negative."
+	});
+	if (!Number.isFinite(facts.fixedOverhead.normalCapacityHours) || facts.fixedOverhead.normalCapacityHours <= 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: "Normal capacity hours must be finite and positive."
+	});
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	const standardQuantity = facts.actualOutputUnits * facts.material.standardQuantityPerUnit;
+	const standardHours = facts.actualOutputUnits * facts.labour.standardHoursPerUnit;
+	const variance = (amount) => {
+		const rounded = money(amount, policy);
+		return {
+			amount: Math.abs(rounded),
+			outcome: rounded > 0 ? "favorable" : rounded < 0 ? "adverse" : "none"
+		};
+	};
+	const signed = (item) => item.outcome === "favorable" ? item.amount : item.outcome === "adverse" ? -item.amount : 0;
+	const combine = (...items) => variance(items.reduce((sum, item) => sum + signed(item), 0));
+	const materialPrice = variance(facts.material.actualQuantity * (facts.material.standardPricePerUnit - facts.material.actualPricePerUnit));
+	const materialUsage = variance(facts.material.standardPricePerUnit * (standardQuantity - facts.material.actualQuantity));
+	const labourRate = variance(facts.labour.actualHours * (facts.labour.standardRatePerHour - facts.labour.actualRatePerHour));
+	const labourEfficiency = variance(facts.labour.standardRatePerHour * (standardHours - facts.labour.actualHours));
+	const variableExpenditure = variance(facts.labour.actualHours * (facts.variableOverhead.standardRatePerHour - facts.variableOverhead.actualRatePerHour));
+	const variableEfficiency = variance(facts.variableOverhead.standardRatePerHour * (standardHours - facts.labour.actualHours));
+	const fixedExpenditure = variance(facts.fixedOverhead.budgeted - facts.fixedOverhead.actual);
+	const fixedVolume = variance(standardHours * (facts.fixedOverhead.budgeted / facts.fixedOverhead.normalCapacityHours) - facts.fixedOverhead.budgeted);
+	const materialTotal = combine(materialPrice, materialUsage);
+	const labourTotal = combine(labourRate, labourEfficiency);
+	const variableTotal = combine(variableExpenditure, variableEfficiency);
+	const fixedTotal = combine(fixedExpenditure, fixedVolume);
+	const totalCostVariance = combine(materialTotal, labourTotal, variableTotal, fixedTotal);
+	const trace = [
+		{
+			id: "variance:material-price",
+			kind: "derive",
+			rule: "Material price variance = actual quantity × (standard price − actual price). Positive is favorable.",
+			working: `${facts.material.actualQuantity} × (${facts.material.standardPricePerUnit} − ${facts.material.actualPricePerUnit})`,
+			result: signed(materialPrice)
+		},
+		{
+			id: "variance:material-usage",
+			kind: "derive",
+			rule: "Material usage variance = standard price × (standard quantity for output − actual quantity). Positive is favorable.",
+			working: `${facts.material.standardPricePerUnit} × (${standardQuantity} − ${facts.material.actualQuantity})`,
+			result: signed(materialUsage)
+		},
+		{
+			id: "variance:labour-rate",
+			kind: "derive",
+			rule: "Labour rate variance = actual hours × (standard rate − actual rate). Positive is favorable.",
+			working: `${facts.labour.actualHours} × (${facts.labour.standardRatePerHour} − ${facts.labour.actualRatePerHour})`,
+			result: signed(labourRate)
+		},
+		{
+			id: "variance:labour-efficiency",
+			kind: "derive",
+			rule: "Labour efficiency variance = standard rate × (standard hours for output − actual hours). Positive is favorable.",
+			working: `${facts.labour.standardRatePerHour} × (${standardHours} − ${facts.labour.actualHours})`,
+			result: signed(labourEfficiency)
+		}
+	];
+	return {
+		completed: true,
+		standardQuantity,
+		standardHours,
+		material: {
+			price: materialPrice,
+			usage: materialUsage,
+			total: materialTotal
+		},
+		labour: {
+			rate: labourRate,
+			efficiency: labourEfficiency,
+			total: labourTotal
+		},
+		variableOverhead: {
+			expenditure: variableExpenditure,
+			efficiency: variableEfficiency,
+			total: variableTotal
+		},
+		fixedOverhead: {
+			expenditure: fixedExpenditure,
+			volume: fixedVolume,
+			total: fixedTotal
+		},
+		totalCostVariance,
+		diagnostics,
+		trace
+	};
+}
+const money = (value, policy) => fromMinor(toMinor(value, policy), policy);
+const zero = {
+	amount: 0,
+	outcome: "none"
+};
+const emptyResult = (diagnostics) => ({
+	completed: false,
+	standardQuantity: 0,
+	standardHours: 0,
+	material: {
+		price: zero,
+		usage: zero,
+		total: zero
+	},
+	labour: {
+		rate: zero,
+		efficiency: zero,
+		total: zero
+	},
+	variableOverhead: {
+		expenditure: zero,
+		efficiency: zero,
+		total: zero
+	},
+	fixedOverhead: {
+		expenditure: zero,
+		volume: zero,
+		total: zero
+	},
+	totalCostVariance: zero,
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { analyzeCostVariances };

package/dist/index.d.mts

@@ -12,6 +12,12 @@ import { IconName, ToolIcon } from "./builder/icons.mjs";
 import { AUTHORING_TOOLS, CIRCLE, DELETE, GEOMETRY_TOOLS, INTERSECT, LINE, MEASURE, MIDPOINT, NOTE, POINT, SCALAR, SEGMENT, SELECT, Tool, ToolCtx } from "./builder/tools.mjs";
 import { SceneBuilder, SceneBuilderProps } from "./builder/SceneBuilder.mjs";
 import { Palette, PaletteProps } from "./builder/Palette.mjs";
+import { BinOp, Node, compileNode, evaluate, freeVars } from "./math/ast.mjs";
+import { parse as parse$1 } from "./math/parse.mjs";
+import { definiteIntegral, differentiate, integrate, simplify } from "./math/calculus.mjs";
+import { CompiledFn, compile } from "./math/compile.mjs";
+import { toLatex as toLatex$1 } from "./math/latex.mjs";
+import { CompiledExpr, ExprError, ExprResult, compileExpr } from "./math/expr.mjs";
 import { CoordsContext, DragOverlayContext, StageRefContext, useCoords, useDragOverlay, useStageRef } from "./core/context.mjs";
 import { ClockProvider, ClockProviderProps, FrameDriver, FrameInfo, useFrameLoop } from "./core/clock.mjs";
 import { Learner, LearnerProvider, LearnerResult, PriorAttempts, useLearner } from "./core/learner.mjs";
@@ -41,12 +47,6 @@ import { CURRENT_SCHEMA_VERSION, emptyDoc, migrate, parse, serialize } from "./s
 import { InstanceState, SceneStore } from "./scene/store.mjs";
 import { Scene, SceneProps } from "./scene/Scene.mjs";
 import { RenderOpts, renderElements } from "./scene/render.mjs";
-import { BinOp, Node, compileNode, evaluate, freeVars } from "./math/ast.mjs";
-import { parse as parse$1 } from "./math/parse.mjs";
-import { definiteIntegral, differentiate, integrate, simplify } from "./math/calculus.mjs";
-import { CompiledFn, compile } from "./math/compile.mjs";
-import { toLatex as toLatex$1 } from "./math/latex.mjs";
-import { CompiledExpr, ExprError, ExprResult, compileExpr } from "./math/index.mjs";
 import { BinOp as BinOp$1, LNode, evalBool, freeVars as freeVars$1 } from "./logic/ast.mjs";
 import { parseLogic } from "./logic/parse.mjs";
 import { Classification, TruthRow, TruthTable, classify, equivalent, toCNF, toDNF, truthTable } from "./logic/table.mjs";

package/dist/index.mjs

@@ -31,7 +31,7 @@ import { parse as parse$1 } from "./math/parse.mjs";
 import { definiteIntegral, differentiate, integrate, simplify } from "./math/calculus.mjs";
 import { compile } from "./math/compile.mjs";
 import { toLatex as toLatex$1 } from "./math/latex.mjs";
-import { compileExpr } from "./math/index.mjs";
+import { compileExpr } from "./math/expr.mjs";
 import { EVALUATORS } from "./scene/evaluators.mjs";
 import { resolve } from "./scene/resolve.mjs";
 import { applyCommand, collectRemoved, inverse } from "./scene/commands.mjs";

package/dist/math/analysis.d.mts

@@ -0,0 +1,61 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/analysis.d.ts
+type Fn1 = (x: number) => number;
+/** A straight line y = m·x + c, with the point it was taken at and an evaluator. */
+interface Line {
+  m: number;
+  c: number;
+  at: {
+    x: number;
+    y: number;
+  };
+  f: Fn1;
+}
+/**
+ * Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+ *   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+ *   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+ *      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+ *      change sign. False minima (a parabola that never reaches 0) are rejected
+ *      by the accept tolerance, so no phantom roots.
+ */
+declare function roots(f: Fn1, a: number, b: number, opts?: {
+  steps?: number;
+  tol?: number;
+}): number[];
+/** Points where f and g meet on [a,b]. */
+declare function intersections(f: Fn1, g: Fn1, a: number, b: number, opts?: {
+  steps?: number;
+  tol?: number;
+}): {
+  x: number;
+  y: number;
+}[];
+/** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
+declare function tangentAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+/** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
+declare function normalAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+/**
+ * Composite-Simpson definite integral ∫_a^b f dx, on a NUMERIC function.
+ *
+ * Error O(h⁴) against O(h) for a Riemann sum, so at n≈1000 it is accurate to near machine
+ * precision for a smooth integrand and serves as the reference value a Riemann sum converges
+ * toward. `n` is forced even, as the rule requires. Not adaptive: a singularity inside [a, b] is
+ * not detected, which is why the callers in this file (`areaBetween`) split at the crossings first.
+ *
+ * Named `quadrature` because `calculus.ts` beside it exports `integrate`, which integrates an AST
+ * SYMBOLICALLY: different argument type, different return type, different meaning. (`simpson`
+ * would become a lie the moment the rule changed.) The single implementation, after two copies of
+ * it were found in labs; see `KERNEL-CONTRACT.md` §7.
+ */
+declare function quadrature(f: Fn1, a: number, b: number, n?: number): number;
+/**
+ * Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+ * pieces where g > f don't cancel the pieces where f > g (which a single
+ * |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+ * wants.
+ */
+declare function areaBetween(f: Fn1, g: Fn1, a: number, b: number, n?: number): number;
+//#endregion
+export { Fn1, Line, areaBetween, intersections, normalAt, quadrature, roots, tangentAt };

package/dist/math/analysis.mjs

@@ -0,0 +1,187 @@
+import { evaluate } from "./ast.mjs";
+import { differentiate } from "./calculus.mjs";
+
+//#region src/math/analysis.ts
+/**
+* analysis, the NUMERIC layer over this package's symbolic engine: the half of calculus that needs
+* a number rather than an expression. `calculus.ts` differentiates and integrates an AST exactly;
+* this file finds roots, intersections, tangents, normals and areas, which in general have no
+* closed form at all.
+*
+* Everything works on a compiled scalar `Fn1 = (x) => number` (params already baked into the
+* closure) plus, for exact tangents, the parsed `Node` AST. Pure: no React, no pixels.
+*
+* Methods, and why each is safe:
+*   • roots, bisection on sign changes PLUS Newton at local minima of |f|, so tangent (even
+*     multiplicity) roots are found and poles are rejected. See the docblock on `roots`.
+*   • tangents/normals, EXACT: the AST is differentiated symbolically, then evaluated. No
+*     finite-difference error in the gradient a lesson shows.
+*   • quadrature, composite Simpson, error O(h⁴).
+*
+* Units: none. These are pure numbers on a pure function.
+*/
+function pushUnique(out, x, tol) {
+	if (!out.some((p) => Math.abs(p - x) <= tol)) out.push(x);
+}
+/** Newton's method from x0 using a central-difference derivative (we only hold
+*  the numeric f, not its AST). Returns the polished root, or null on a flat
+*  derivative / divergence. Used to recover tangent (even-multiplicity) roots a
+*  sign-change scan can't see. */
+function newton(f, x0, tol) {
+	let x = x0;
+	for (let k = 0; k < 40; k++) {
+		const fx = f(x);
+		if (!Number.isFinite(fx)) return null;
+		if (Math.abs(fx) <= tol) return x;
+		const h = Math.max(1e-7, Math.abs(x) * 1e-7);
+		const d = (f(x + h) - f(x - h)) / (2 * h);
+		if (!Number.isFinite(d) || Math.abs(d) < 1e-13) return null;
+		const nx = x - fx / d;
+		if (!Number.isFinite(nx)) return null;
+		if (Math.abs(nx - x) <= tol) return nx;
+		x = nx;
+	}
+	return Math.abs(f(x)) <= tol ? x : null;
+}
+/**
+* Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+*   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+*   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+*      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+*      change sign. False minima (a parabola that never reaches 0) are rejected
+*      by the accept tolerance, so no phantom roots.
+*/
+function roots(f, a, b, opts = {}) {
+	const steps = opts.steps ?? 1e3;
+	const tol = opts.tol ?? 1e-9;
+	const grid = (b - a) / steps;
+	const out = [];
+	const xs = [], fs = [];
+	for (let i = 0; i <= steps; i++) {
+		const x = a + grid * i;
+		xs.push(x);
+		fs.push(f(x));
+	}
+	let maxAbs = 0;
+	for (const v of fs) if (Number.isFinite(v)) maxAbs = Math.max(maxAbs, Math.abs(v));
+	const acceptTol = 1e-7 * (1 + maxAbs);
+	for (let i = 1; i <= steps; i++) {
+		const fPrev = fs[i - 1], fx = fs[i];
+		if (!Number.isFinite(fPrev) || !Number.isFinite(fx)) continue;
+		if (fPrev === 0) {
+			pushUnique(out, xs[i - 1], grid);
+			continue;
+		}
+		if (fPrev * fx < 0) {
+			let lo = xs[i - 1], hi = xs[i], flo = fPrev;
+			for (let k = 0; k < 80 && hi - lo > tol; k++) {
+				const mid = (lo + hi) / 2;
+				const fm = f(mid);
+				if (!Number.isFinite(fm)) break;
+				if (flo * fm <= 0) hi = mid;
+				else {
+					lo = mid;
+					flo = fm;
+				}
+			}
+			const mid = (lo + hi) / 2;
+			if (Math.abs(f(mid)) <= acceptTol) pushUnique(out, mid, grid);
+		}
+	}
+	for (let i = 1; i < steps; i++) {
+		const p = fs[i - 1], c = fs[i], q = fs[i + 1];
+		if (!Number.isFinite(p) || !Number.isFinite(c) || !Number.isFinite(q)) continue;
+		if (Math.abs(c) <= Math.abs(p) && Math.abs(c) <= Math.abs(q) && Math.abs(c) < .05 * (1 + maxAbs)) {
+			const r = newton(f, xs[i], tol);
+			if (r != null && r >= a - grid && r <= b + grid && Math.abs(f(r)) <= acceptTol) pushUnique(out, r, grid);
+		}
+	}
+	out.sort((u, v) => u - v);
+	return out;
+}
+/** Points where f and g meet on [a,b]. */
+function intersections(f, g, a, b, opts) {
+	return roots((x) => f(x) - g(x), a, b, opts).map((x) => ({
+		x,
+		y: f(x)
+	}));
+}
+/** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
+function tangentAt(ast, x0, varName = "x", params = {}) {
+	const d = differentiate(ast, varName);
+	if (!d) return null;
+	const m = evaluate(d, {
+		...params,
+		[varName]: x0
+	});
+	const y0 = evaluate(ast, {
+		...params,
+		[varName]: x0
+	});
+	if (!Number.isFinite(m) || !Number.isFinite(y0)) return null;
+	const c = y0 - m * x0;
+	return {
+		m,
+		c,
+		at: {
+			x: x0,
+			y: y0
+		},
+		f: (x) => m * x + c
+	};
+}
+/** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
+function normalAt(ast, x0, varName = "x", params = {}) {
+	const t = tangentAt(ast, x0, varName, params);
+	if (!t || t.m === 0) return null;
+	const m = -1 / t.m;
+	const c = t.at.y - m * t.at.x;
+	return {
+		m,
+		c,
+		at: t.at,
+		f: (x) => m * x + c
+	};
+}
+/**
+* Composite-Simpson definite integral ∫_a^b f dx, on a NUMERIC function.
+*
+* Error O(h⁴) against O(h) for a Riemann sum, so at n≈1000 it is accurate to near machine
+* precision for a smooth integrand and serves as the reference value a Riemann sum converges
+* toward. `n` is forced even, as the rule requires. Not adaptive: a singularity inside [a, b] is
+* not detected, which is why the callers in this file (`areaBetween`) split at the crossings first.
+*
+* Named `quadrature` because `calculus.ts` beside it exports `integrate`, which integrates an AST
+* SYMBOLICALLY: different argument type, different return type, different meaning. (`simpson`
+* would become a lie the moment the rule changed.) The single implementation, after two copies of
+* it were found in labs; see `KERNEL-CONTRACT.md` §7.
+*/
+function quadrature(f, a, b, n = 1e3) {
+	if (a === b) return 0;
+	const m = Math.max(2, Math.ceil(n / 2) * 2);
+	const h = (b - a) / m;
+	let sum = f(a) + f(b);
+	for (let i = 1; i < m; i++) sum += (i % 2 === 1 ? 4 : 2) * f(a + i * h);
+	return sum * h / 3;
+}
+/**
+* Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+* pieces where g > f don't cancel the pieces where f > g (which a single
+* |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+* wants.
+*/
+function areaBetween(f, g, a, b, n = 1e3) {
+	const d = (x) => f(x) - g(x);
+	const cuts = [
+		a,
+		...roots(d, a, b).filter((x) => x > a + 1e-9 && x < b - 1e-9).sort((u, v) => u - v),
+		b
+	];
+	const per = Math.max(20, Math.round(n / Math.max(1, cuts.length - 1)));
+	let area = 0;
+	for (let i = 0; i < cuts.length - 1; i++) area += Math.abs(quadrature(d, cuts[i], cuts[i + 1], per));
+	return area;
+}
+
+//#endregion
+export { areaBetween, intersections, normalAt, quadrature, roots, tangentAt };

package/dist/math/answer-check.d.mts

@@ -0,0 +1,50 @@
+//#region src/math/answer-check.d.ts
+/**
+ * answer-check, the "is the student right?" layer, built on the expr engine beside it. Two modes,
+ * the ones exams need:
+ *
+ *   • NUMBER     — value within tolerance, parsed so `pi/2` and `2*sqrt(5)` count.
+ *   • EXPRESSION — any algebraically EQUIVALENT form accepted, checked BOTH symbolically
+ *                  (simplify(student − answer) → 0) AND numerically by sampling, so
+ *                  `(x+1)(x+2)` ≡ `x^2+3x+2`.
+ *
+ * Both passes run because neither is sufficient alone: the simplifier cannot collapse every
+ * equivalent pair, and sampling alone would accept two expressions that happen to agree on the
+ * sample points. Symbolic first, numeric as the fallback, and a minimum count of agreeing FINITE
+ * samples so a pair that is undefined everywhere in the window cannot pass by default.
+ *
+ * Tolerances are relative, not absolute: a 1% window on a quantity of order 10⁵ is not the same
+ * marking scheme as a 1% window on 0.3, and only one of those is what an exam means.
+ *
+ * Pure: no React, no pixels.
+ */
+/** Evaluate a numeric answer string (`3.14`, `pi/2`, `2*sqrt(5)`) → number (NaN if invalid). */
+declare function parseValue(raw: string): number;
+declare function normalizeMathInput(raw: string): string;
+/** Numeric match with a relative-ish tolerance (default ~1% of scale). */
+declare function checkNumber(student: number, value: number, tol?: number): boolean;
+interface ExprCheckOpts {
+  /** Variables to sample (defaults to the union of both sides' free vars). */
+  vars?: string[];
+  /** Sampling domain for the numeric pass. */
+  domain?: [number, number];
+  tol?: number;
+  samples?: number;
+}
+/** True if `student` is algebraically equivalent to `answer` (symbolic OR numeric). */
+declare function checkExpression(student: string, answer: string, opts?: ExprCheckOpts): boolean;
+type AnswerSpec = {
+  kind: 'number';
+  value: number;
+  tol?: number;
+} | {
+  kind: 'expression';
+  value: string;
+  vars?: string[];
+  domain?: [number, number];
+  tol?: number;
+};
+/** Check a raw student string against an authored answer spec. */
+declare function checkAnswer(spec: AnswerSpec, raw: string): boolean;
+//#endregion
+export { AnswerSpec, ExprCheckOpts, checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue };

package/dist/math/answer-check.mjs

@@ -0,0 +1,106 @@
+import { parse } from "./parse.mjs";
+import { simplify } from "./calculus.mjs";
+import { compileExpr } from "./expr.mjs";
+
+//#region src/math/answer-check.ts
+/**
+* answer-check, the "is the student right?" layer, built on the expr engine beside it. Two modes,
+* the ones exams need:
+*
+*   • NUMBER     — value within tolerance, parsed so `pi/2` and `2*sqrt(5)` count.
+*   • EXPRESSION — any algebraically EQUIVALENT form accepted, checked BOTH symbolically
+*                  (simplify(student − answer) → 0) AND numerically by sampling, so
+*                  `(x+1)(x+2)` ≡ `x^2+3x+2`.
+*
+* Both passes run because neither is sufficient alone: the simplifier cannot collapse every
+* equivalent pair, and sampling alone would accept two expressions that happen to agree on the
+* sample points. Symbolic first, numeric as the fallback, and a minimum count of agreeing FINITE
+* samples so a pair that is undefined everywhere in the window cannot pass by default.
+*
+* Tolerances are relative, not absolute: a 1% window on a quantity of order 10⁵ is not the same
+* marking scheme as a 1% window on 0.3, and only one of those is what an exam means.
+*
+* Pure: no React, no pixels.
+*/
+/** Compile, returning the usable form or null (never the error union). */
+function tryCompile(src) {
+	const c = compileExpr(src);
+	if (c.error !== void 0) return null;
+	return c;
+}
+/** Evaluate a numeric answer string (`3.14`, `pi/2`, `2*sqrt(5)`) → number (NaN if invalid). */
+function parseValue(raw) {
+	const c = tryCompile(normalizeMathInput(raw));
+	return c ? c.fn({}) : NaN;
+}
+/**
+* Make exam-natural input parse: accept implicit multiplication (`2x` → `2*x`,
+* `)(` → `)*(`) and a leading `y =` (`y = 2x − 3` → `2*x - 3`). Conservative ,
+* never inserts `*` before `(` after a letter, so function calls like `sin(x)`
+* survive. Unicode minus → ascii.
+*/
+const SUPERSCRIPT = {
+	"⁰": "0",
+	"¹": "1",
+	"²": "2",
+	"³": "3",
+	"⁴": "4",
+	"⁵": "5",
+	"⁶": "6",
+	"⁷": "7",
+	"⁸": "8",
+	"⁹": "9"
+};
+function normalizeMathInput(raw) {
+	let s = raw.trim().replace(/−/g, "-").replace(/×/g, "*").replace(/÷/g, "/");
+	s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹]+/g, (m) => "^" + [...m].map((ch) => SUPERSCRIPT[ch]).join(""));
+	s = s.replace(/\*\*/g, "^");
+	s = s.replace(/\s+/g, "");
+	s = s.replace(/^y=/i, "");
+	s = s.replace(/(\d)(?![eE][+-]?\d)([a-zA-Z(])/g, "$1*$2");
+	s = s.replace(/\)([a-zA-Z0-9(])/g, ")*$1");
+	return s;
+}
+/** Numeric match with a relative-ish tolerance (default ~1% of scale). */
+function checkNumber(student, value, tol = .01) {
+	if (!Number.isFinite(student) || !Number.isFinite(value)) return false;
+	return Math.abs(student - value) <= tol * Math.max(1, Math.abs(value));
+}
+const isZeroNode = (n, eps = 1e-9) => n.type === "num" && Math.abs(n.value) < eps;
+/** True if `student` is algebraically equivalent to `answer` (symbolic OR numeric). */
+function checkExpression(student, answer, opts = {}) {
+	const a = tryCompile(normalizeMathInput(student));
+	const b = tryCompile(normalizeMathInput(answer));
+	if (!a || !b) return false;
+	try {
+		if (isZeroNode(simplify(parse(`(${normalizeMathInput(student)}) - (${normalizeMathInput(answer)})`)), opts.tol ?? 1e-9)) return true;
+	} catch {}
+	const vars = opts.vars ?? [...new Set([...a.vars, ...b.vars])];
+	const [lo, hi] = opts.domain ?? [-3.3, 3.7];
+	const tol = opts.tol ?? 1e-6;
+	const samples = opts.samples ?? 32;
+	const PHI = .6180339887498949;
+	const R2 = .4142135623730951;
+	let finite = 0;
+	for (let i = 0; i < samples; i++) {
+		const scope = {};
+		vars.forEach((v, j) => {
+			scope[v] = lo + (hi - lo) * (((i + 1) * PHI + (j + 1) * R2) % 1);
+		});
+		const ya = a.fn(scope);
+		const yb = b.fn(scope);
+		if (!Number.isFinite(ya) || !Number.isFinite(yb)) continue;
+		finite++;
+		if (Math.abs(ya - yb) > tol * Math.max(1, Math.abs(ya), Math.abs(yb))) return false;
+	}
+	return finite >= 5;
+}
+/** Check a raw student string against an authored answer spec. */
+function checkAnswer(spec, raw) {
+	if (!raw || !raw.trim()) return false;
+	if (spec.kind === "number") return checkNumber(parseValue(raw), spec.value, spec.tol);
+	return checkExpression(raw, spec.value, spec);
+}
+
+//#endregion
+export { checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue };

package/dist/math/calculus.d.mts

@@ -4,16 +4,11 @@ import { Node } from "./ast.mjs";
 /** Exact symbolic derivative, or `null` if a non-differentiable node is present. */
 declare function differentiate(node: Node, x: string): Node | null;
 /**
- * Exact symbolic antiderivative with respect to `x`, or `null` when this engine cannot do it.
+ * Exact symbolic antiderivative, trying the expression as written and then multiplied out.
  *
- * The constant of integration is NOT included. That is deliberate: `+ c` is the single most
- * commonly dropped mark in the topic, so it belongs in the lesson's own working where a learner
- * has to write it, not silently bolted on by the engine.
- *
- * Covers the Cambridge P1/P3 toolkit: linearity, the power rule including the `1/x → ln|x|`
- * exception, and any of the above composed with a LINEAR inner function. Returns null for
- * integration by parts, by non-linear substitution, and partial fractions, so a caller can fall
- * back to the numerical `integrate` in `core/numeric` and show area rather than a wrong formula.
+ * The second attempt is what makes `∫x(x+1)dx` and `∫(R²−x²)²dx` work: expand distributes, collect
+ * turns the resulting repeated factors back into powers, and then the ordinary power rule applies
+ * term by term. A single retry, because both passes are idempotent on their own output.
  */
 declare function integrate(node: Node, x: string): Node | null;
 /**