@classytic/stage 0.1.0 → 0.3.0

package/dist/logic/minimize.mjs

@@ -3,9 +3,9 @@ import { truthTable } from "./table.mjs";
 
 //#region src/logic/minimize.ts
 /**
-* Boolean minimisation — Quine–McCluskey: the algorithm a Karnaugh map performs
+* Boolean minimisation, Quine–McCluskey: the algorithm a Karnaugh map performs
 * by eye. Given a function's minterms (the rows where it is 1) over n variables,
-* it finds the PRIME IMPLICANTS (maximal "don't-care cubes" — groups on the
+* it finds the PRIME IMPLICANTS (maximal "don't-care cubes", groups on the
 * K-map) and a minimal SUM-OF-PRODUCTS cover (essential PIs + a greedy fill).
 * Pure + dependency-free, the boolean sibling of `simplify` in the expr engine;
 * the K-map lab renders these cubes as the coloured groups, and the same routine
@@ -31,7 +31,7 @@ function cubeCovers(c, n) {
 	for (let m = 0; m < total; m++) if ((m & c.mask) === c.value) out.push(m);
 	return out;
 }
-/** The product term for a cube — a literal per FIXED bit (MSB = first var). */
+/** The product term for a cube, a literal per FIXED bit (MSB = first var). */
 function cubeTerm(c, vars, neg = "¬", join = " ∧ ") {
 	const n = vars.length;
 	const lits = [];
@@ -86,7 +86,56 @@ function coverageOf(pis, required) {
 	});
 	return map;
 }
-/** A minimal SOP cover: essential prime implicants + a greedy fill of the rest. */
+/** Keep only the minimal PI-sets (drop any that is a strict superset of another). */
+function absorb(products) {
+	const uniq = /* @__PURE__ */ new Map();
+	for (const p of products) {
+		const s = new Set(p);
+		uniq.set([...s].sort((a, b) => a - b).join(","), s);
+	}
+	const sets = [...uniq.values()];
+	return sets.filter((s) => !sets.some((o) => o !== s && o.size < s.size && [...o].every((x) => s.has(x)))).map((s) => [...s]);
+}
+/** Greedy fallback: take the PI covering the most still-uncovered minterms, repeat. */
+function greedyCover(uncovered, cov, candidates) {
+	const left = new Set(uncovered);
+	const picked = [];
+	while (left.size) {
+		let best = -1, bestCount = 0;
+		for (const i of candidates) {
+			if (picked.includes(i)) continue;
+			const c = cov.get(i).filter((m) => left.has(m)).length;
+			if (c > bestCount) {
+				bestCount = c;
+				best = i;
+			}
+		}
+		if (best < 0) break;
+		picked.push(best);
+		for (const m of cov.get(best)) left.delete(m);
+	}
+	return picked;
+}
+/**
+* Petrick's method: the EXACT minimum-size cover of the remaining minterms. Each minterm
+* contributes a clause (the PIs covering it); multiplying the clauses out (with absorption)
+* enumerates every irredundant cover, and we keep the one with the fewest PIs. Falls back to
+* greedy if the residual is large enough that the expansion could blow up (K-map labs are small).
+*/
+function petrickCover(uncovered, cov, candidates) {
+	if (candidates.length > 18) return greedyCover(uncovered, cov, candidates);
+	let products = [[]];
+	for (const m of uncovered) {
+		const clause = candidates.filter((i) => cov.get(i).includes(m));
+		if (clause.length === 0) return greedyCover(uncovered, cov, candidates);
+		const next = [];
+		for (const p of products) for (const pi of clause) next.push(p.includes(pi) ? p : [...p, pi]);
+		products = absorb(next);
+		if (products.length > 4e3) return greedyCover(uncovered, cov, candidates);
+	}
+	return products.reduce((best, p) => p.length < best.length ? p : best, products[0] ?? []);
+}
+/** A minimum SOP cover: essential prime implicants + Petrick's exact cover of the rest. */
 function minimalCover(minterms, n, dontCares = []) {
 	const required = new Set(minterms);
 	if (required.size === 0) return [];
@@ -100,20 +149,9 @@ function minimalCover(minterms, n, dontCares = []) {
 		if (owners.length === 1) chosen.add(owners[0]);
 	}
 	for (const i of chosen) for (const m of cov.get(i)) uncovered.delete(m);
-	while (uncovered.size) {
-		let best = -1, bestCount = -1;
-		pis.forEach((_, i) => {
-			if (chosen.has(i)) return;
-			const c = cov.get(i).filter((m) => uncovered.has(m)).length;
-			if (c > bestCount) {
-				bestCount = c;
-				best = i;
-			}
-		});
-		if (best < 0 || bestCount <= 0) break;
-		chosen.add(best);
-		for (const m of cov.get(best)) uncovered.delete(m);
-	}
+	if (uncovered.size === 0) return [...chosen].map((i) => pis[i]);
+	const candidates = pis.map((_, i) => i).filter((i) => !chosen.has(i));
+	for (const i of petrickCover([...uncovered], cov, candidates)) chosen.add(i);
 	return [...chosen].map((i) => pis[i]);
 }
 /** Full minimisation of a formula (or explicit minterms) → cover + SOP string. */

package/dist/logic/table.mjs

@@ -4,7 +4,7 @@ import { evalBool, freeVars } from "./ast.mjs";
 /**
 * Truth tables + the things derived from them: classification (tautology /
 * contradiction / contingency), logical equivalence, and DNF/CNF. Everything is
-* a fold over the 2ⁿ assignments — the truth table is the source of truth, so
+* a fold over the 2ⁿ assignments, the truth table is the source of truth, so
 * equivalence is just "same output column" (no algebraic law engine needed).
 */
 /** Enumerate all 2^vars assignments (MSB = first var), evaluating `n` on each. */

package/dist/math/ast.d.mts

@@ -1,6 +1,6 @@
 //#region src/math/ast.d.ts
 /**
- * expr/ast — the Abstract Syntax Tree: node types, evaluation, free-variable
+ * expr/ast, the Abstract Syntax Tree: node types, evaluation, free-variable
  * collection, and small builder helpers. The AST is the shared representation
  * that evaluation, differentiation, simplification, and LaTeX printing all
  * operate on.

package/dist/math/ast.mjs

@@ -2,7 +2,7 @@ import { CONSTANTS, FN1, FN2 } from "./defs.mjs";
 
 //#region src/math/ast.ts
 /**
-* expr/ast — the Abstract Syntax Tree: node types, evaluation, free-variable
+* expr/ast, the Abstract Syntax Tree: node types, evaluation, free-variable
 * collection, and small builder helpers. The AST is the shared representation
 * that evaluation, differentiation, simplification, and LaTeX printing all
 * operate on.

package/dist/math/calculus.d.mts

@@ -3,7 +3,28 @@ import { Node } from "./ast.mjs";
 //#region src/math/calculus.d.ts
 /** 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.
+ *
+ * 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.
+ */
+declare function integrate(node: Node, x: string): Node | null;
+/**
+ * A definite integral evaluated exactly: `F(b) - F(a)`.
+ *
+ * Returned as a NUMBER rather than a node, because that is what a lesson compares a learner's
+ * answer against. Null when the antiderivative is not elementary, or when either limit lands
+ * somewhere the expression is not defined.
+ */
+declare function definiteIntegral(node: Node, x: string, lower: number, upper: number): number | null;
 /** Fold constants and trivial identities so derivative output is readable. */
 declare function simplify(node: Node): Node;
 //#endregion
-export { differentiate, simplify };
+export { definiteIntegral, differentiate, integrate, simplify };

package/dist/math/calculus.mjs

@@ -1,9 +1,9 @@
 import { FN1, FN2 } from "./defs.mjs";
-import { add, call, div, mul, neg, num, pow, sub } from "./ast.mjs";
+import { add, call, div, evaluate, mul, neg, num, pow, sub, variable } from "./ast.mjs";
 
 //#region src/math/calculus.ts
 /**
-* expr/calculus — symbolic differentiation + algebraic simplification on the AST.
+* expr/calculus, symbolic differentiation + algebraic simplification on the AST.
 *
 * `differentiate(node, x)` returns the exact derivative as a new AST, or `null`
 * when the expression contains something not symbolically differentiable
@@ -70,7 +70,201 @@ function differentiate(node, x) {
 		default: return null;
 	}
 }
+/**
+* Outer antiderivative of a 1-arg function, given its argument node `u`.
+*
+* Mirrors DERIV above. Only the functions whose antiderivative is itself elementary appear:
+* `ln` and the inverse trig functions integrate by parts into forms this table cannot express,
+* so they are absent and `integrate` returns null for them rather than guessing.
+*/
+const INTEG = {
+	sin: (u) => neg(call("cos", u)),
+	cos: (u) => call("sin", u),
+	exp: (u) => call("exp", u),
+	sinh: (u) => call("cosh", u),
+	cosh: (u) => call("sinh", u)
+};
+/** `true` when `node` holds no occurrence of `x`, so it is a constant for this integral. */
+function isConstantIn(node, x) {
+	return !freeVarsHas(node, x);
+}
+function freeVarsHas(node, x) {
+	switch (node.type) {
+		case "num": return false;
+		case "var": return node.name === x;
+		case "neg": return freeVarsHas(node.arg, x);
+		case "binary": return freeVarsHas(node.left, x) || freeVarsHas(node.right, x);
+		case "call": return node.args.some((a) => freeVarsHas(a, x));
+		default: return true;
+	}
+}
+/**
+* The constant `a` when `u` is linear in `x` (that is, `u = a·x + b`), else null.
+*
+* This is what makes the whole linear-substitution family work with one rule instead of a pattern
+* per case: if `du/dx` simplifies to a non-zero NUMBER, then `∫f(u) dx = F(u)/a`. Deriving it from
+* `differentiate` rather than matching `a*x+b` by shape means `(3-2x)^5` and `(-2x+3)^5` and
+* `3-2*x` all work without three separate matchers.
+*/
+function linearFactor(u, x) {
+	const d = differentiate(u, x);
+	if (!d) return null;
+	const s = simplify(d);
+	return s.type === "num" && s.value !== 0 ? s.value : null;
+}
+/** Divide by a constant, without emitting the noise of `expr / 1`. */
+const overConst = (node, a) => a === 1 ? node : div(node, num(a));
+/**
+* Exact symbolic antiderivative with respect to `x`, or `null` when this engine cannot do it.
+*
+* 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.
+*/
+function integrate(node, x) {
+	if (isConstantIn(node, x)) return mul(node, variable(x));
+	switch (node.type) {
+		case "var": return div(pow(variable(x), num(2)), num(2));
+		case "neg": {
+			const inner = integrate(node.arg, x);
+			return inner && neg(inner);
+		}
+		case "binary": {
+			const { op, left, right } = node;
+			if (op === "+" || op === "-") {
+				const l = integrate(left, x);
+				const r = integrate(right, x);
+				return l && r && (op === "+" ? add(l, r) : sub(l, r));
+			}
+			if (op === "*") {
+				if (isConstantIn(left, x)) {
+					const r = integrate(right, x);
+					return r && mul(left, r);
+				}
+				if (isConstantIn(right, x)) {
+					const l = integrate(left, x);
+					return l && mul(right, l);
+				}
+				return null;
+			}
+			if (op === "/") {
+				if (isConstantIn(right, x)) {
+					const l = integrate(left, x);
+					return l && div(l, right);
+				}
+				if (isConstantIn(left, x)) {
+					const a = linearFactor(right, x);
+					return a === null ? null : overConst(mul(left, call("ln", call("abs", right))), a);
+				}
+				return null;
+			}
+			if (op === "^") {
+				const exponent = simplify(right);
+				if (exponent.type !== "num") return null;
+				const n = exponent.value;
+				const a = linearFactor(left, x);
+				if (a === null) return null;
+				if (n === -1) return overConst(call("ln", call("abs", left)), a);
+				return overConst(div(pow(left, num(n + 1)), num(n + 1)), a);
+			}
+			return null;
+		}
+		case "call": {
+			const u = node.args[0];
+			const rule = INTEG[node.fn];
+			if (!rule || !u || node.args.length !== 1) return null;
+			const a = linearFactor(u, x);
+			return a === null ? null : overConst(rule(u), a);
+		}
+		default: return null;
+	}
+}
+/**
+* A definite integral evaluated exactly: `F(b) - F(a)`.
+*
+* Returned as a NUMBER rather than a node, because that is what a lesson compares a learner's
+* answer against. Null when the antiderivative is not elementary, or when either limit lands
+* somewhere the expression is not defined.
+*/
+function definiteIntegral(node, x, lower, upper) {
+	const F = integrate(node, x);
+	if (!F) return null;
+	const at = (v) => evaluate(F, { [x]: v });
+	const result = at(upper) - at(lower);
+	return Number.isFinite(result) ? result : null;
+}
 const isNum = (n, v) => n.type === "num" && (v === void 0 || n.value === v);
+/** A stable structural key, so identical cores group (x and x; x² and x²). */
+function nodeKey(n) {
+	switch (n.type) {
+		case "num": return `#${n.value}`;
+		case "var": return `$${n.name}`;
+		case "neg": return `-${nodeKey(n.arg)}`;
+		case "binary": return `(${nodeKey(n.left)}${n.op}${nodeKey(n.right)})`;
+		case "call": return `${n.fn}(${n.args.map(nodeKey).join(",")})`;
+		default: return "?";
+	}
+}
+/** Split a term into (numeric coefficient, the rest); core null = a pure number. */
+function splitCoeff(n) {
+	if (n.type === "num") return [n.value, null];
+	if (n.type === "neg") {
+		const [c, core] = splitCoeff(n.arg);
+		return [-c, core];
+	}
+	if (n.type === "binary" && n.op === "*") {
+		if (n.left.type === "num") return [n.left.value, n.right];
+		if (n.right.type === "num") return [n.right.value, n.left];
+	}
+	return [1, n];
+}
+/** Flatten a +/- chain into signed (coeff, core) terms. */
+function flattenTerms(node, s, out) {
+	if (node.type === "binary" && (node.op === "+" || node.op === "-")) {
+		flattenTerms(node.left, s, out);
+		flattenTerms(node.right, node.op === "-" ? -s : s, out);
+		return;
+	}
+	if (node.type === "neg") {
+		flattenTerms(node.arg, -s, out);
+		return;
+	}
+	const [coeff, core] = splitCoeff(node);
+	out.push({
+		coeff: coeff * s,
+		core
+	});
+}
+/** Combine like terms across `l op r`: 2x + 3x → 5x, x − x → 0, constants merge. */
+function combineLikeTerms(l, r, op) {
+	const list = [];
+	flattenTerms(l, 1, list);
+	flattenTerms(r, op === "-" ? -1 : 1, list);
+	const groups = /* @__PURE__ */ new Map();
+	for (const t of list) {
+		const k = t.core ? nodeKey(t.core) : "";
+		const g = groups.get(k);
+		if (g) g.coeff += t.coeff;
+		else groups.set(k, {
+			coeff: t.coeff,
+			core: t.core
+		});
+	}
+	let result = null;
+	for (const { coeff, core } of groups.values()) {
+		if (Math.abs(coeff) < 1e-12) continue;
+		const mag = Math.abs(coeff);
+		const body = core === null ? num(mag) : mag === 1 ? core : mul(num(mag), core);
+		if (result === null) result = coeff < 0 ? neg(body) : body;
+		else result = coeff < 0 ? sub(result, body) : add(result, body);
+	}
+	return result ?? num(0);
+}
 /** Fold constants and trivial identities so derivative output is readable. */
 function simplify(node) {
 	switch (node.type) {
@@ -90,15 +284,8 @@ function simplify(node) {
 				const v = fold(op, l.value, r.value);
 				if (v !== null && Number.isFinite(v)) return num(v);
 			}
+			if (op === "+" || op === "-") return combineLikeTerms(l, r, op);
 			switch (op) {
-				case "+":
-					if (isNum(l, 0)) return r;
-					if (isNum(r, 0)) return l;
-					break;
-				case "-":
-					if (isNum(r, 0)) return l;
-					if (isNum(l, 0)) return simplify(neg(r));
-					break;
 				case "*":
 					if (isNum(l, 0) || isNum(r, 0)) return num(0);
 					if (isNum(l, 1)) return r;
@@ -133,10 +320,36 @@ function simplify(node) {
 							right: l.left
 						};
 					}
+					/**
+					* Cancel a constant against a fraction's denominator: c·(a/b) → (c/b)·a.
+					*
+					* `∫3x² dx` is the plainest case. The constant comes out of the integral and the power
+					* rule divides by 3, so the honest answer is `3·(x³/3)`. A learner expects `x³`, and
+					* only the fully cancelled form is worth showing as the ANSWER.
+					*/
+					if (l.type === "num" && r.type === "binary" && r.op === "/" && r.right.type === "num") {
+						const k = l.value / r.right.value;
+						if (Number.isInteger(k)) return k === 1 ? r.left : simplify(mul(num(k), r.left));
+					}
+					if (r.type === "num" && l.type === "binary" && l.op === "/" && l.right.type === "num") {
+						const k = r.value / l.right.value;
+						if (Number.isInteger(k)) return k === 1 ? l.left : simplify(mul(num(k), l.left));
+					}
 					break;
 				case "/":
 					if (isNum(r, 1)) return l;
 					if (isNum(l, 0)) return num(0);
+					/**
+					* Collapse a nested fraction: (a/b)/c → a/(bc).
+					*
+					* Integration produces these constantly, because the power rule divides by n+1 and the
+					* linear-substitution rule then divides by a. Left alone, ∫(2x+1)³dx renders as a
+					* fraction inside a fraction, which is correct and unreadable, and unreadable is the
+					* complaint this engine exists to answer.
+					*/
+					if (r.type === "num" && l.type === "binary" && l.op === "/" && l.right.type === "num") return simplify(div(l.left, num(l.right.value * r.value)));
+					if (r.type === "num" && r.value < 0) return simplify(neg(div(l, num(-r.value))));
+					if (l.type === "neg") return neg(simplify(div(l.arg, r)));
 					break;
 				case "^":
 					if (isNum(r, 1)) return l;
@@ -185,4 +398,4 @@ function fold(op, a, b) {
 }
 
 //#endregion
-export { differentiate, simplify };
+export { definiteIntegral, differentiate, integrate, simplify };

package/dist/math/compile.d.mts

@@ -0,0 +1,8 @@
+import { Node } from "./ast.mjs";
+
+//#region src/math/compile.d.ts
+type CompiledFn = (scope?: Record<string, number>) => number;
+/** Compile an AST to a fast `(scope) => number`. */
+declare function compile(node: Node): CompiledFn;
+//#endregion
+export { CompiledFn, compile };

package/dist/math/compile.mjs

@@ -0,0 +1,40 @@
+import { CONSTANTS, FN1, FN2 } from "./defs.mjs";
+
+//#region src/math/compile.ts
+const JS_OP = {
+	"+": "+",
+	"-": "-",
+	"*": "*",
+	"/": "/",
+	"%": "%",
+	"^": "**"
+};
+/** Emit a JS expression string (every node fully parenthesised, so `**` and unary
+*  minus never collide — `(-x)**2` is valid, `-x**2` is a JS SyntaxError). */
+function gen(node) {
+	switch (node.type) {
+		case "num": return `(${node.value})`;
+		case "var": {
+			const lc = node.name.toLowerCase();
+			if (lc in CONSTANTS) return `(${CONSTANTS[lc]})`;
+			return `(s[${JSON.stringify(node.name)}]??NaN)`;
+		}
+		case "neg": return `(-${gen(node.arg)})`;
+		case "binary": return `(${gen(node.left)}${JS_OP[node.op] ?? "+"}${gen(node.right)})`;
+		case "call": {
+			const a = node.args.map(gen);
+			if (node.fn in FN1 && a[0]) return `F1[${JSON.stringify(node.fn)}](${a[0]})`;
+			if (node.fn in FN2 && a[0] && a[1]) return `F2[${JSON.stringify(node.fn)}](${a[0]},${a[1]})`;
+			return "NaN";
+		}
+		default: return "NaN";
+	}
+}
+/** Compile an AST to a fast `(scope) => number`. */
+function compile(node) {
+	const f = new Function("s", "F1", "F2", `return ${gen(node)};`);
+	return (scope = {}) => f(scope, FN1, FN2);
+}
+
+//#endregion
+export { compile };

package/dist/math/defs.mjs

@@ -1,6 +1,6 @@
 //#region src/math/defs.ts
 /**
-* expr/defs — the function & constant tables shared by the tokenizer, evaluator,
+* expr/defs, the function & constant tables shared by the tokenizer, evaluator,
 * differentiator, and LaTeX printer. Pure data; no AST knowledge here.
 */
 const CONSTANTS = {

package/dist/math/index.d.mts

@@ -1,6 +1,7 @@
 import { BinOp, Node, compileNode, evaluate, freeVars } from "./ast.mjs";
 import { parse } from "./parse.mjs";
-import { differentiate, simplify } from "./calculus.mjs";
+import { definiteIntegral, differentiate, integrate, simplify } from "./calculus.mjs";
+import { CompiledFn, compile } from "./compile.mjs";
 import { toLatex } from "./latex.mjs";
 
 //#region src/math/index.d.ts
@@ -9,7 +10,7 @@ interface CompiledExpr {
   readonly fn: (scope: Record<string, number>) => number;
   /** Free variables referenced (excludes constants & functions), e.g. `['x','a']`. */
   readonly vars: string[];
-  /** The parsed syntax tree — for differentiation, LaTeX, or analysis. */
+  /** The parsed syntax tree, for differentiation, LaTeX, or analysis. */
   readonly ast: Node;
   readonly error?: undefined;
 }
@@ -20,7 +21,7 @@ interface ExprError {
   readonly ast?: undefined;
 }
 type ExprResult = CompiledExpr | ExprError;
-/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }` — never throws. */
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
 declare function compileExpr(src: string): ExprResult;
 //#endregion
-export { type BinOp, CompiledExpr, ExprError, ExprResult, type Node, compileExpr, compileNode, differentiate, evaluate, freeVars, parse, simplify, toLatex };
+export { type BinOp, CompiledExpr, type CompiledFn, ExprError, ExprResult, type Node, compile, compileExpr, compileNode, definiteIntegral, differentiate, evaluate, freeVars, integrate, parse, simplify, toLatex };

package/dist/math/index.mjs

@@ -1,11 +1,12 @@
 import { compileNode, evaluate, freeVars } from "./ast.mjs";
 import { parse } from "./parse.mjs";
-import { differentiate, simplify } from "./calculus.mjs";
+import { definiteIntegral, differentiate, integrate, simplify } from "./calculus.mjs";
+import { compile } from "./compile.mjs";
 import { toLatex } from "./latex.mjs";
 
 //#region src/math/index.ts
 /**
-* expr — a tiny, safe, dependency-free symbolic math engine.
+* expr, a tiny, safe, dependency-free symbolic math engine.
 *
 * Pipeline: `tokenize → parse (AST) → evaluate`. On top of the AST it offers
 * exact `differentiate`, `simplify`, and `toLatex`, so the same typed formula
@@ -22,7 +23,7 @@ import { toLatex } from "./latex.mjs";
 * csc asin acos atan sinh cosh tanh sqrt cbrt abs exp ln log log2 log10 floor
 * ceil round sign` (+ 2-arg `pow atan2 min max mod hypot`).
 */
-/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }` — never throws. */
+/** Compile a formula string. Returns `{ fn, vars, ast }` or `{ error }`, never throws. */
 function compileExpr(src) {
 	if (!src || !src.trim()) return { error: "Empty expression" };
 	let ast;
@@ -39,4 +40,4 @@ function compileExpr(src) {
 }
 
 //#endregion
-export { compileExpr, compileNode, differentiate, evaluate, freeVars, parse, simplify, toLatex };
+export { compile, compileExpr, compileNode, definiteIntegral, differentiate, evaluate, freeVars, integrate, parse, simplify, toLatex };

package/dist/math/latex.mjs

@@ -103,6 +103,14 @@ function texCall(node) {
 	if (node.fn === "cbrt") return `\\sqrt[3]{${wrap(a0, 0)}}`;
 	if (node.fn === "abs") return `\\left|${wrap(a0, 0)}\\right|`;
 	if (node.fn === "exp") return `e^{${wrap(a0, 0)}}`;
+	/**
+	* `ln|x|`, not `ln(|x|)`.
+	*
+	* The modulus bars already delimit the argument, so the usual parentheses double up. Every
+	* textbook and mark scheme writes the integral of 1/x as ln|x|, and that is the form a learner
+	* has to reproduce, so it is the form to show.
+	*/
+	if ((node.fn === "ln" || node.fn === "log") && a0.type === "call" && a0.fn === "abs" && a0.args[0]) return `\\${node.fn}\\left|${wrap(a0.args[0], 0)}\\right|`;
 	const args = node.args.map((a) => wrap(a, 0)).join(", ");
 	return `${NAMED_FN.has(node.fn) ? `\\${node.fn}` : `\\operatorname{${node.fn}}`}\\left(${args}\\right)`;
 }

package/dist/math/parse.mjs

@@ -4,11 +4,11 @@ import { bin, call, neg, num, variable } from "./ast.mjs";
 
 //#region src/math/parse.ts
 /**
-* expr/parse — token stream → AST, via precedence-climbing (Pratt).
+* expr/parse, token stream → AST, via precedence-climbing (Pratt).
 *
 * Binary precedence: `+ -` < `* / %` < `^` (right-assoc). Unary minus binds
 * looser than `^` (so `-2^2 = -(2^2) = -4`) but tighter than `*`. Throws a
-* descriptive Error on malformed input — the parser is the single source of
+* descriptive Error on malformed input, the parser is the single source of
 * truth for "is this expression well-formed?".
 */
 const BIN_PREC = {

package/dist/math/tokenize.mjs

@@ -2,7 +2,7 @@ import { isFunction } from "./defs.mjs";
 
 //#region src/math/tokenize.ts
 /**
-* expr/tokenize — source string → token stream.
+* expr/tokenize, source string → token stream.
 *
 * Handles numbers (incl. `1.5e3`, rejecting malformed `2..3`), identifiers
 * (classified as function vs variable), operators, parens, and commas. Inserts

package/dist/primitives/CanvasLayer.mjs

@@ -7,16 +7,16 @@ import { jsx } from "react/jsx-runtime";
 
 //#region src/primitives/CanvasLayer.tsx
 /**
-* <CanvasLayer> — the engine's HIGH-ELEMENT-COUNT escape hatch: a zero-dependency
+* <CanvasLayer>, the engine's HIGH-ELEMENT-COUNT escape hatch: a zero-dependency
 * HiDPI <canvas> that shares the engine's coordinate system + clock. Use it when
 * a lab needs a heatmap, a particle/gas sim, or thousands of moving dots at 60fps
-* — cases where one retained SVG node per element would drop frames. Declarative,
+*, cases where one retained SVG node per element would drop frames. Declarative,
 * low-count, accessible figures should stay on <Stage> (SVG); this is the
 * deliberate, bundle-free alternative to a WebGL engine (no Pixi/three dependency)
 * until a lab MEASURABLY needs shaders/tens-of-thousands of textured sprites.
 *
 * `draw(ctx, coords)` runs in CSS-pixel space (the context is pre-scaled for dpr)
-* on mount, on resize, and whenever `draw`'s identity changes — so memoize it on
+* on mount, on resize, and whenever `draw`'s identity changes, so memoize it on
 * your state (or bump it from a useFrameLoop tick) to drive animation. Overlay a
 * sibling <Stage> with the SAME view for accessible SVG handles/labels on top.
 */

package/dist/primitives/Dot.d.mts

@@ -1,5 +1,4 @@
 import { StyleProps } from "./props.mjs";
-import { ReactNode } from "react";
 
 //#region src/primitives/Dot.d.ts
 interface DotProps extends StyleProps {
@@ -8,20 +7,8 @@ interface DotProps extends StyleProps {
   /** Pixel radius (never scaled). */
   r?: number;
 }
-declare function Dot({
-  x,
-  y,
-  r,
-  color,
-  opacity
-}: DotProps): ReactNode;
+declare const Dot: import("react").NamedExoticComponent<DotProps>;
 /** A point with a contrast ring (reads clearly over any background). */
-declare function Point({
-  x,
-  y,
-  r,
-  color,
-  opacity
-}: DotProps): ReactNode;
+declare const Point: import("react").NamedExoticComponent<DotProps>;
 //#endregion
 export { Dot, DotProps, Point };