@classytic/labs 0.2.0 → 0.3.0

package/dist/math/mystery-bucket/preset.mjs

@@ -2,7 +2,8 @@
 
 import { clamp } from "../../core/util.mjs";
 import { StatusPill, Stepper } from "../../kit/controls.mjs";
-import { ControlBar, Field, LabFrame, LiveRegion } from "../../kit/frame.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { Field } from "../../kit/frame.mjs";
 import { useCheckpoint } from "../../kit/pedagogy.mjs";
 import { MYSTERY_BUCKET_ASSET } from "./asset.mjs";
 import { useEffect, useMemo, useState } from "react";
@@ -84,10 +85,9 @@ function MysteryBucketLab({ bucketWeight = 5, bucketCount = 1, maxWeights = 12,
 		height,
 		ariaLabel: `Balance: a mystery bucket against ${count} unit weights, ${balanced ? "level" : "tipping"}`
 	});
-	return /* @__PURE__ */ jsx(LabFrame, {
-		title,
-		prompt,
-		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+	const controls = /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-fields",
+		children: [
 			/* @__PURE__ */ jsx(Field, {
 				label: "weights",
 				children: /* @__PURE__ */ jsx(Stepper, {
@@ -99,16 +99,39 @@ function MysteryBucketLab({ bucketWeight = 5, bucketCount = 1, maxWeights = 12,
 				})
 			}),
 			/* @__PURE__ */ jsx("span", {
-				style: { opacity: .85 },
+				className: "math-explain",
 				children: status
 			}),
 			/* @__PURE__ */ jsx(StatusPill, {
 				ok: balanced,
 				children: balanced ? "✓ Balanced" : "Not level"
 			})
-		] }),
-		footer: /* @__PURE__ */ jsx(LiveRegion, { children: status }),
-		children: figure
+		]
+	});
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "math-mystery-bucket-activity",
+		focusLayout: "compact",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Concrete algebra",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [/* @__PURE__ */ jsx("strong", { children: balanced ? "Level" : count < total ? "Bucket side heavy" : "Weight side heavy" }), /* @__PURE__ */ jsxs("span", { children: [count, " unit weights"] })] }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [/* @__PURE__ */ jsx(Activity.Canvas, {
+				label: "Mystery bucket balance",
+				children: figure
+			}), /* @__PURE__ */ jsx(Activity.Inspector, {
+				label: "Weights and balance evidence",
+				children: controls
+			})] }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, { children: [/* @__PURE__ */ jsx("span", { children: "Observe" }), /* @__PURE__ */ jsx("div", { children: balanced ? reveal : "A level beam means the visible unit weights equal the hidden total." })] }),
+			/* @__PURE__ */ jsx(Activity.LiveRegion, { children: status }),
+			/* @__PURE__ */ jsx(Activity.Transport, { children: /* @__PURE__ */ jsxs("div", {
+				className: "lab-transport-state",
+				children: [/* @__PURE__ */ jsx("strong", { children: balanced ? "Mystery solved" : "Balance the scale" }), /* @__PURE__ */ jsxs("span", { children: [count, " weights placed"] })]
+			}) })
+		]
 	});
 }
 

package/dist/math/newton-method/index.d.mts

@@ -0,0 +1,2 @@
+import { NewtonMethodExplorer, NewtonMethodExplorerProps } from "./preset.mjs";
+export { NewtonMethodExplorer, type NewtonMethodExplorerProps };

package/dist/math/newton-method/index.mjs

@@ -0,0 +1,3 @@
+import { NewtonMethodExplorer } from "./preset.mjs";
+
+export { NewtonMethodExplorer };

package/dist/math/newton-method/preset.d.mts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+
+//#region src/math/newton-method/preset.d.ts
+interface NewtonMethodExplorerProps {
+  equation?: string;
+  xRange?: [number, number];
+  startX?: number;
+  maxSteps?: number;
+  title?: string;
+  height?: number;
+}
+declare function NewtonMethodExplorer({
+  equation,
+  xRange,
+  startX,
+  maxSteps: maxStepsInit,
+  title,
+  height
+}?: NewtonMethodExplorerProps): ReactNode;
+//#endregion
+export { NewtonMethodExplorer, NewtonMethodExplorerProps };

package/dist/math/newton-method/preset.mjs

@@ -0,0 +1,277 @@
+'use client';
+
+import { clamp } from "../../core/util.mjs";
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { derivativeAt, functionViewport, normalizeRange, valueInRange } from "../calculus/core.mjs";
+import { MathActivity, MathExpressionError, MathRunTransport } from "../activity.mjs";
+import { newtonStep } from "../root-finding/core.mjs";
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Axes, Grid, MovableDot, Plot, Point, Segment, Stage, compileExpr, differentiate, evaluate, simplify, toLatex, useFrameLoop, useInView } from "@classytic/stage";
+
+//#region src/math/newton-method/preset.tsx
+const fmt$1 = (value) => Number.isFinite(value) ? value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "") : "—";
+function NewtonMethodExplorer({ equation = "x^3 - x - 2", xRange = [-3, 3], startX = 1.8, maxSteps: maxStepsInit = 12, title = "Find a root with tangents", height = 360 } = {}) {
+	const [xMin, xMax] = normalizeRange(xRange, [-3, 3]);
+	const initialX = valueInRange(startX, [xMin, xMax], 1.8);
+	const maxSteps = Math.round(clamp(Number.isFinite(maxStepsInit) ? maxStepsInit : 12, 1, 30));
+	const [points, setPoints] = useState([initialX]);
+	const [state, setState] = useState("ready");
+	const [running, setRunning] = useState(false);
+	const elapsed = useRef(0);
+	const { ref: viewRef, inView } = useInView();
+	useEffect(() => {
+		setPoints([initialX]);
+		setState("ready");
+		setRunning(false);
+	}, [
+		initialX,
+		equation,
+		xMin,
+		xMax,
+		maxSteps
+	]);
+	const model = useMemo(() => {
+		const result = compileExpr(equation);
+		if (!result.ast) return {
+			ok: false,
+			error: result.error ?? "Invalid expression"
+		};
+		const ast = result.ast;
+		const fn = (x) => evaluate(ast, { x });
+		let derivativeNode = null;
+		try {
+			const node = differentiate(ast, "x");
+			derivativeNode = node ? simplify(node) : null;
+		} catch {
+			derivativeNode = null;
+		}
+		return {
+			ok: true,
+			fn,
+			derivative: derivativeNode ? (x) => evaluate(derivativeNode, { x }) : (x) => derivativeAt(fn, x),
+			latex: toLatex(ast),
+			derivativeLatex: derivativeNode ? toLatex(derivativeNode) : null
+		};
+	}, [equation]);
+	const advance = useCallback(() => {
+		if (!model.ok) return;
+		setPoints((history) => {
+			if (history.length - 1 >= maxSteps) {
+				setState("max-steps");
+				setRunning(false);
+				return history;
+			}
+			const current = history[history.length - 1];
+			const result = newtonStep(model.fn, model.derivative, current);
+			if (result.state !== "running") {
+				setState(result.state);
+				setRunning(false);
+				return history;
+			}
+			if (history.some((value) => Math.abs(value - result.nextX) <= 1e-7 * (1 + Math.abs(result.nextX)))) {
+				setState("cycle");
+				setRunning(false);
+				return history;
+			}
+			setState("running");
+			return [...history, result.nextX];
+		});
+	}, [maxSteps, model]);
+	useFrameLoop((frame) => {
+		elapsed.current += frame.dtMs;
+		if (elapsed.current < 650) return;
+		elapsed.current = 0;
+		advance();
+	}, { running: running && model.ok && inView });
+	if (!model.ok) return /* @__PURE__ */ jsx(MathExpressionError, {
+		title,
+		expression: equation,
+		error: model.error
+	});
+	const { fn, derivative, latex, derivativeLatex } = model;
+	const view = functionViewport(fn, [xMin, xMax]);
+	const currentX = points[points.length - 1];
+	const currentY = fn(currentX);
+	const slope = derivative(currentX);
+	const currentStep = newtonStep(fn, derivative, currentX);
+	const stateLabel = state === "converged" ? "Root found" : state === "flat-derivative" ? "Tangent is flat" : state === "diverged" ? "Iteration diverged" : state === "cycle" ? "Cycle detected" : state === "max-steps" ? "Iteration limit" : running ? "Iterating" : points.length > 1 ? "Paused" : "Ready";
+	const figure = /* @__PURE__ */ jsx("div", {
+		ref: viewRef,
+		children: /* @__PURE__ */ jsxs(Stage, {
+			view: {
+				xMin,
+				xMax,
+				...view
+			},
+			height,
+			preserveAspect: false,
+			ariaLabel: `Newton method on ${equation}; current estimate ${fmt$1(currentX)}`,
+			children: [
+				/* @__PURE__ */ jsx(Grid, {}),
+				/* @__PURE__ */ jsx(Axes, { labels: true }),
+				/* @__PURE__ */ jsx(Plot.OfX, {
+					y: fn,
+					domain: [xMin, xMax],
+					color: "var(--stage-accent)",
+					weight: 2.75
+				}),
+				points.slice(0, -1).map((x, index, arr) => {
+					const y = fn(x);
+					const next = points[index + 1];
+					const op = .18 + .72 * ((index + 1) / arr.length);
+					return /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(Segment, {
+							from: {
+								x,
+								y
+							},
+							to: {
+								x: next,
+								y: 0
+							},
+							color: "var(--stage-accent-2)",
+							weight: 1.5,
+							opacity: op
+						}),
+						/* @__PURE__ */ jsx(Segment, {
+							from: {
+								x: next,
+								y: 0
+							},
+							to: {
+								x: next,
+								y: fn(next)
+							},
+							color: "var(--stage-muted)",
+							weight: 1,
+							dashed: true,
+							opacity: op * .7
+						}),
+						/* @__PURE__ */ jsx(Point, {
+							x,
+							y,
+							r: 3,
+							color: "var(--stage-accent-2)",
+							opacity: op
+						})
+					] }, `${index}-${x}`);
+				}),
+				Number.isFinite(currentStep.nextX) && currentStep.state === "running" ? /* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: currentX,
+						y: currentY
+					},
+					to: {
+						x: currentStep.nextX,
+						y: 0
+					},
+					color: "var(--stage-good)",
+					weight: 2.5
+				}) : null,
+				/* @__PURE__ */ jsx(Point, {
+					x: currentX,
+					y: currentY,
+					r: 5,
+					color: "var(--stage-good)"
+				}),
+				/* @__PURE__ */ jsx(MovableDot, {
+					value: {
+						x: currentX,
+						y: 0
+					},
+					constrain: "horizontal",
+					onMove: (point) => {
+						setPoints([clamp(point.x, xMin, xMax)]);
+						setState("ready");
+						setRunning(false);
+					},
+					color: "var(--stage-fg)",
+					ariaLabel: "starting estimate on x axis"
+				})
+			]
+		})
+	});
+	const reset = () => {
+		setPoints([initialX]);
+		setState("ready");
+		setRunning(false);
+	};
+	const terminal = [
+		"converged",
+		"flat-derivative",
+		"diverged",
+		"cycle",
+		"max-steps"
+	].includes(state);
+	const transport = /* @__PURE__ */ jsx(MathRunTransport, {
+		running,
+		onReset: reset,
+		onStep: advance,
+		onToggle: () => {
+			setRunning((value) => !value);
+			setState(running ? "paused" : "running");
+		},
+		state: stateLabel,
+		detail: `iteration ${points.length - 1} of ${maxSteps}`,
+		disabled: terminal,
+		resetLabel: "Reset Newton method",
+		stepLabel: "Take one Newton tangent step"
+	});
+	const details = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "math-equation-detail",
+		children: [
+			/* @__PURE__ */ jsx(Tex$1, { tex: `f(x)=${latex}` }),
+			derivativeLatex ? /* @__PURE__ */ jsx(Tex$1, { tex: `f'(x)=${derivativeLatex}` }) : null,
+			/* @__PURE__ */ jsx(Tex$1, { tex: `x_{n+1}=x_n-\\frac{f(x_n)}{f'(x_n)}` })
+		]
+	}), /* @__PURE__ */ jsxs("div", {
+		className: "math-iteration-ledger",
+		children: [
+			/* @__PURE__ */ jsx("span", { children: "n" }),
+			/* @__PURE__ */ jsx("span", { children: "xₙ" }),
+			/* @__PURE__ */ jsx("span", { children: "|f(xₙ)|" }),
+			points.map((x, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx("span", { children: index }),
+				/* @__PURE__ */ jsx("span", { children: fmt$1(x) }),
+				/* @__PURE__ */ jsx("span", { children: Math.abs(fn(x)).toExponential(2) })
+			] }, `${index}-${x}`))
+		]
+	})] });
+	return /* @__PURE__ */ jsx(MathActivity, {
+		className: "math-newton-method",
+		eyebrow: "Calculus · numerical solving",
+		title,
+		description: "Each tangent meets the x-axis at the next estimate. Step through the recurrence and watch the error shrink—or diagnose why it fails.",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("strong", { children: stateLabel }),
+			/* @__PURE__ */ jsxs("span", { children: ["|f(x)| ", Number.isFinite(currentY) ? Math.abs(currentY).toExponential(2) : "—"] }),
+			/* @__PURE__ */ jsxs("span", { children: ["n ", points.length - 1] })
+		] }),
+		figure,
+		measurements: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+			className: "math-result-probe",
+			children: [
+				/* @__PURE__ */ jsx("span", { children: "Current estimate" }),
+				/* @__PURE__ */ jsxs("strong", { children: ["x = ", fmt$1(currentX)] }),
+				/* @__PURE__ */ jsxs("small", { children: [
+					"f(x) ",
+					fmt$1(currentY),
+					" · slope ",
+					fmt$1(slope)
+				] })
+			]
+		}), /* @__PURE__ */ jsx("p", {
+			className: "math-explain",
+			children: "The tangent is a local linear approximation. Its x-intercept becomes the next guess."
+		})] }),
+		conclusion: state === "converged" ? "The residual is below tolerance, so the current estimate is a root." : state === "flat-derivative" ? "The tangent is too flat to produce a reliable next intercept. Choose another starting value." : state === "cycle" ? "The estimates repeated instead of approaching a root. Choose another start." : state === "diverged" ? "The next estimate became unsafe. Choose a start closer to a root." : "Take another tangent step and compare the new residual.",
+		transport,
+		details,
+		graphLabel: "Function graph with Newton tangent iterations",
+		inspectorLabel: "Root estimate"
+	});
+}
+
+//#endregion
+export { NewtonMethodExplorer };

package/dist/math/number-line/preset.mjs

@@ -1,11 +1,10 @@
 'use client';
 
 import { clamp } from "../../core/util.mjs";
-import { StatusPill } from "../../kit/controls.mjs";
-import { ControlBar, LabFrame, LiveRegion } from "../../kit/frame.mjs";
+import { Activity } from "../../kit/activity.mjs";
 import { useCheckpoint } from "../../kit/pedagogy.mjs";
 import { useEffect, useMemo, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Dot, Label, MovableDot, Segment, Stage } from "@classytic/stage";
 
 //#region src/math/number-line/preset.tsx
@@ -96,6 +95,26 @@ function NumberLineLab({ min = -8, max = 8, start = 0, target, title = "Number l
 				dy: 22,
 				size: 12
 			}, `l${t}`)),
+			target != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: target,
+					y: -.62
+				},
+				to: {
+					x: target,
+					y: .62
+				},
+				color: "var(--stage-good)",
+				opacity: solved ? .55 : .28,
+				weight: 2
+			}), /* @__PURE__ */ jsx(Label, {
+				x: target,
+				y: 0,
+				text: "target",
+				color: "var(--stage-good)",
+				dy: -28,
+				size: 11
+			})] }),
 			solved && target != null && /* @__PURE__ */ jsx(Dot, {
 				x: target,
 				y: 0,
@@ -121,21 +140,32 @@ function NumberLineLab({ min = -8, max = 8, start = 0, target, title = "Number l
 			})
 		]
 	});
-	return /* @__PURE__ */ jsx(LabFrame, {
-		title,
-		prompt,
-		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [/* @__PURE__ */ jsxs("span", {
-			style: {
-				fontWeight: 600,
-				fontVariantNumeric: "tabular-nums"
-			},
-			children: ["value = ", val]
-		}), target != null && /* @__PURE__ */ jsx(StatusPill, {
-			ok: solved,
-			children: solved ? `✓ Landed on ${target}` : "Not there yet"
-		})] }),
-		footer: /* @__PURE__ */ jsx(LiveRegion, { children: target != null ? solved ? `Landed on ${target}` : `Marker at ${val}` : `Marker at ${val}` }),
-		children: figure
+	const update = target != null ? solved ? `Landed on ${target}` : `Marker at ${val}` : `Marker at ${val}`;
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "math-number-line-activity",
+		focusLayout: "compact",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Number sense",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [
+				/* @__PURE__ */ jsx("strong", { children: solved ? "Target reached" : "Explore the line" }),
+				/* @__PURE__ */ jsxs("span", { children: ["value ", val] }),
+				target != null ? /* @__PURE__ */ jsxs("span", { children: ["target ", target] }) : null
+			] }),
+			/* @__PURE__ */ jsx(Activity.Workspace, { children: /* @__PURE__ */ jsx(Activity.Canvas, {
+				label: "Interactive number line",
+				children: figure
+			}) }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, { children: [/* @__PURE__ */ jsx("span", { children: solved ? "Complete" : "Observe" }), /* @__PURE__ */ jsx("div", { children: solved ? `The marker is exactly on ${target}.` : "Values increase to the right and decrease to the left of zero." })] }),
+			/* @__PURE__ */ jsx(Activity.LiveRegion, { children: update }),
+			/* @__PURE__ */ jsx(Activity.Transport, { children: /* @__PURE__ */ jsxs("div", {
+				className: "lab-transport-state",
+				children: [/* @__PURE__ */ jsx("strong", { children: solved ? "Position confirmed" : "Drag the marker" }), /* @__PURE__ */ jsx("span", { children: target == null ? `Current value ${val}` : `${Math.abs(target - val)} step${Math.abs(target - val) === 1 ? "" : "s"} from target` })]
+			}) })
+		]
 	});
 }
 

package/dist/math/number-structure/core.d.mts

@@ -0,0 +1,42 @@
+//#region src/math/number-structure/core.d.ts
+type NumberStructureMode = 'factor-array' | 'prime-tree' | 'gcd' | 'lcm' | 'divisibility';
+type FactorSplitStrategy = 'smallest' | 'balanced';
+interface FactorTreeNode {
+  value: number;
+  prime: boolean;
+  left?: FactorTreeNode;
+  right?: FactorTreeNode;
+}
+interface FactorPair {
+  rows: number;
+  columns: number;
+}
+interface PrimePower {
+  prime: number;
+  exponentA: number;
+  exponentB: number;
+  gcdExponent: number;
+  lcmExponent: number;
+}
+declare function divisors(value: number): number[];
+declare function factorPairs(value: number): FactorPair[];
+declare function isPrime(value: number): boolean;
+declare function primeFactors(value: number): number[];
+declare function factorTree(value: number, strategy?: FactorSplitStrategy): FactorTreeNode;
+declare function gcd(a: number, b: number): number;
+declare function lcm(a: number, b: number): number;
+declare function primePowers(a: number, b: number): PrimePower[];
+declare function arrayState(value: number, rows: number): {
+  rows: number;
+  columns: number;
+  placed: number;
+  remainder: number;
+  exact: boolean;
+};
+declare function divisibilityEvidence(value: number): {
+  divisor: number;
+  works: boolean;
+  reason: string;
+}[];
+//#endregion
+export { FactorPair, FactorSplitStrategy, FactorTreeNode, NumberStructureMode, PrimePower, arrayState, divisibilityEvidence, divisors, factorPairs, factorTree, gcd, isPrime, lcm, primeFactors, primePowers };

package/dist/math/number-structure/core.mjs

@@ -0,0 +1,130 @@
+//#region src/math/number-structure/core.ts
+function divisors(value) {
+	const n = Math.max(1, Math.trunc(Math.abs(value)));
+	return Array.from({ length: n }, (_, i) => i + 1).filter((d) => n % d === 0);
+}
+function factorPairs(value) {
+	const n = Math.max(1, Math.trunc(Math.abs(value)));
+	const result = [];
+	for (let rows = 1; rows * rows <= n; rows += 1) if (n % rows === 0) result.push({
+		rows,
+		columns: n / rows
+	});
+	return result;
+}
+function isPrime(value) {
+	const n = Math.trunc(value);
+	if (n < 2) return false;
+	for (let d = 2; d * d <= n; d += 1) if (n % d === 0) return false;
+	return true;
+}
+function primeFactors(value) {
+	let n = Math.max(1, Math.trunc(Math.abs(value)));
+	const result = [];
+	for (let d = 2; d * d <= n; d += 1) while (n % d === 0) {
+		result.push(d);
+		n /= d;
+	}
+	if (n > 1) result.push(n);
+	return result;
+}
+function factorTree(value, strategy = "balanced") {
+	const n = Math.max(2, Math.trunc(value));
+	if (isPrime(n)) return {
+		value: n,
+		prime: true
+	};
+	const pairs = factorPairs(n).filter((pair) => pair.rows > 1);
+	const pair = strategy === "smallest" ? pairs[0] : pairs.at(-1);
+	if (!pair) return {
+		value: n,
+		prime: true
+	};
+	return {
+		value: n,
+		prime: false,
+		left: factorTree(pair.rows, strategy),
+		right: factorTree(pair.columns, strategy)
+	};
+}
+function gcd(a, b) {
+	let x = Math.abs(Math.trunc(a));
+	let y = Math.abs(Math.trunc(b));
+	while (y) [x, y] = [y, x % y];
+	return x;
+}
+function lcm(a, b) {
+	const x = Math.abs(Math.trunc(a));
+	const y = Math.abs(Math.trunc(b));
+	return x && y ? x / gcd(x, y) * y : 0;
+}
+function counts(value) {
+	const result = /* @__PURE__ */ new Map();
+	for (const p of primeFactors(value)) result.set(p, (result.get(p) ?? 0) + 1);
+	return result;
+}
+function primePowers(a, b) {
+	const ca = counts(a), cb = counts(b);
+	return [...new Set([...ca.keys(), ...cb.keys()])].sort((x, y) => x - y).map((prime) => {
+		const exponentA = ca.get(prime) ?? 0, exponentB = cb.get(prime) ?? 0;
+		return {
+			prime,
+			exponentA,
+			exponentB,
+			gcdExponent: Math.min(exponentA, exponentB),
+			lcmExponent: Math.max(exponentA, exponentB)
+		};
+	});
+}
+function arrayState(value, rows) {
+	const n = Math.max(2, Math.trunc(value));
+	const r = Math.max(1, Math.min(n, Math.trunc(rows)));
+	return {
+		rows: r,
+		columns: Math.floor(n / r),
+		placed: n - n % r,
+		remainder: n % r,
+		exact: n % r === 0
+	};
+}
+function divisibilityEvidence(value) {
+	const digits = String(Math.abs(Math.trunc(value))).split("").map(Number);
+	const digitSum = digits.reduce((sum, digit) => sum + digit, 0);
+	const last = digits.at(-1) ?? 0;
+	const lastTwo = Number(digits.slice(-2).join(""));
+	return [
+		{
+			divisor: 2,
+			works: last % 2 === 0,
+			reason: `last digit ${last} is ${last % 2 === 0 ? "" : "not "}even`
+		},
+		{
+			divisor: 3,
+			works: digitSum % 3 === 0,
+			reason: `digit sum ${digitSum} is ${digitSum % 3 === 0 ? "" : "not "}a multiple of 3`
+		},
+		{
+			divisor: 5,
+			works: last === 0 || last === 5,
+			reason: `last digit is ${last}`
+		},
+		{
+			divisor: 9,
+			works: digitSum % 9 === 0,
+			reason: `digit sum is ${digitSum}`
+		},
+		{
+			divisor: 10,
+			works: last === 0,
+			reason: `last digit is ${last}`
+		},
+		{
+			divisor: 4,
+			works: lastTwo % 4 === 0,
+			reason: `last two digits make ${lastTwo}`
+		}
+	];
+}
+
+//#endregion
+export { arrayState, divisibilityEvidence, divisors, factorPairs, factorTree, gcd, isPrime, lcm, primeFactors, primePowers };

package/dist/math/number-structure/index.d.mts

@@ -0,0 +1,2 @@
+import { FactorPair, FactorSplitStrategy, FactorTreeNode, NumberStructureMode, PrimePower, arrayState, divisibilityEvidence, divisors, factorPairs, factorTree, gcd, isPrime, lcm, primeFactors, primePowers } from "./core.mjs";
+import { NumberStructureLab, NumberStructureProps } from "./preset.mjs";

package/dist/math/number-structure/preset.d.mts

@@ -0,0 +1,28 @@
+import { FactorSplitStrategy, NumberStructureMode } from "./core.mjs";
+import { ReactNode } from "react";
+
+//#region src/math/number-structure/preset.d.ts
+interface NumberStructureProps {
+  mode?: NumberStructureMode;
+  value?: number;
+  rows?: number;
+  a?: number;
+  b?: number;
+  splitStrategy?: FactorSplitStrategy;
+  title?: string;
+  prompt?: string;
+  activity?: string;
+}
+declare function NumberStructureLab({
+  mode: initial,
+  value: initialValue,
+  rows: initialRows,
+  a: initialA,
+  b: initialB,
+  splitStrategy: initialSplit,
+  title,
+  prompt,
+  activity
+}: NumberStructureProps): ReactNode;
+//#endregion
+export { NumberStructureLab, NumberStructureProps };