@classytic/labs 0.1.0 → 0.3.0

package/dist/math/percent-bar/preset.mjs

@@ -0,0 +1,311 @@
+'use client';
+
+import { round } from "../../core/util.mjs";
+import { StatusPill } from "../../kit/controls.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { LinkedViews } from "../../kit/frame.mjs";
+import { useCheckpoint } from "../../kit/pedagogy.mjs";
+import { getScene } from "../../kit/scenes.mjs";
+import { useEffect, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, MovableDot, Segment, Stage } from "@classytic/stage";
+
+//#region src/math/percent-bar/preset.tsx
+/**
+* PercentBarLab, the authorable PERCENTAGE manipulative: a bar is the whole
+* (100%), the learner drags a fill to a target percent, and the same drag reads
+* out both the percent AND the concrete amount (percent × whole). One engine,
+* many analogies, the story is data: set `whole` + `unit` (students, mL, $, %
+* battery) and an optional `segments` breakdown for the reference bar, and the
+* SAME component teaches "make 25%", "25% of 80", a budget split, a charged
+* battery, a poll. Built on the juiced <MovableDot> (snap + live readout +
+* ghost stops) so a percentage feels tactile, not typed.
+*
+* Fully authorable: whole, unit, target, snap granularity, the reference-bar
+* segments + their labels/colours, and the prompt, no code per analogy.
+*/
+const PALETTE = [
+	"var(--stage-accent)",
+	"var(--stage-good)",
+	"#f3a23b",
+	"#e85aa6",
+	"#7c83ff",
+	"#34c6c6"
+];
+const fmtVal = (n) => String(round(n));
+function PercentBarLab(props = {}) {
+	const { whole = 100, unit = "", start = 0, target, snapPct = 5, showValue = true, segments, referenceLabel, scene, height = 230, title = "Percentages", prompt = target != null ? `Drag the bar to ${target}%.` : "Drag the bar and watch the percentage.", activity = "percent-bar" } = props;
+	const snap = (p) => Math.round(p / snapPct) * snapPct;
+	const clampPct = (p) => Math.max(0, Math.min(100, snap(p)));
+	const [pct, setPct] = useState(clampPct(start));
+	useEffect(() => {
+		setPct(clampPct(start));
+	}, [start, snapPct]);
+	const solved = target != null && pct === target;
+	const value = round(whole * pct / 100);
+	useCheckpoint({
+		solved,
+		activity,
+		response: `${pct}%${showValue ? ` = ${fmtVal(value)} ${unit}` : ""}`
+	});
+	const fillColor = solved ? "var(--stage-good)" : "var(--stage-accent)";
+	const Y_REF = 1.35;
+	const Y_BAR = -.25;
+	const BARW = 30;
+	const segTotal = (segments ?? []).reduce((s, x) => s + Math.max(0, x.frac), 0) || 1;
+	let acc = 0;
+	const segSpans = (segments ?? []).map((s, i) => {
+		const x0 = acc / segTotal * 100;
+		acc += Math.max(0, s.frac);
+		const x1 = acc / segTotal * 100;
+		return {
+			...s,
+			x0,
+			x1,
+			mid: (x0 + x1) / 2,
+			color: s.color ?? PALETTE[i % PALETTE.length]
+		};
+	});
+	const ticks = [];
+	for (let p = 0; p <= 100; p += snapPct) ticks.push(p);
+	const figure = /* @__PURE__ */ jsxs(Stage, {
+		view: {
+			xMin: -7,
+			xMax: 114,
+			yMin: -2.4,
+			yMax: segments?.length || referenceLabel ? 2.6 : 1.2
+		},
+		height,
+		preserveAspect: false,
+		pad: 14,
+		ariaLabel: `Percentage bar at ${pct} percent of ${whole}${unit ? " " + unit : ""}`,
+		children: [
+			(segSpans.length > 0 || referenceLabel) && /* @__PURE__ */ jsxs(Fragment$1, { children: [referenceLabel && /* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: Y_REF,
+				text: referenceLabel,
+				color: "var(--stage-muted)",
+				size: 12,
+				anchor: "start",
+				dy: -22
+			}), segSpans.length > 0 ? segSpans.map((s, i) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: s.x0,
+					y: Y_REF
+				},
+				to: {
+					x: s.x1,
+					y: Y_REF
+				},
+				color: s.color,
+				weight: BARW - 4,
+				opacity: .85
+			}), s.label && s.x1 - s.x0 > 9 && /* @__PURE__ */ jsx(Label, {
+				x: s.mid,
+				y: Y_REF,
+				text: s.label,
+				color: "var(--stage-fg)",
+				size: 11,
+				weight: 700
+			})] }, i)) : /* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_REF
+				},
+				to: {
+					x: 100,
+					y: Y_REF
+				},
+				color: "var(--stage-grid)",
+				weight: BARW - 4,
+				opacity: .7
+			})] }),
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_BAR
+				},
+				to: {
+					x: 100,
+					y: Y_BAR
+				},
+				color: "var(--stage-grid)",
+				weight: BARW,
+				opacity: .6
+			}),
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: 0,
+					y: Y_BAR
+				},
+				to: {
+					x: Math.max(1e-4, pct),
+					y: Y_BAR
+				},
+				color: fillColor,
+				weight: BARW
+			}),
+			ticks.map((p) => /* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: p,
+					y: Y_BAR - .62
+				},
+				to: {
+					x: p,
+					y: Y_BAR - (p % 25 === 0 ? .92 : .78)
+				},
+				color: "var(--stage-fg)",
+				opacity: p % 25 === 0 ? .5 : .2,
+				weight: p % 25 === 0 ? 1.5 : 1
+			}, p)),
+			/* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: Y_BAR,
+				text: "0%",
+				color: "var(--stage-muted)",
+				size: 12,
+				dy: 34
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 100,
+				y: Y_BAR,
+				text: "100%",
+				color: "var(--stage-muted)",
+				size: 12,
+				dy: 34
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 100,
+				y: Y_BAR,
+				text: `${fmtVal(whole)}${unit ? " " + unit : ""}`,
+				color: "var(--stage-muted)",
+				size: 12,
+				anchor: "start",
+				dx: 10
+			}),
+			target != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: target,
+					y: Y_BAR - .95
+				},
+				to: {
+					x: target,
+					y: .7
+				},
+				color: "var(--stage-good)",
+				weight: 1.75,
+				opacity: solved ? .9 : .55,
+				dashed: true
+			}), !solved && /* @__PURE__ */ jsx(Dot, {
+				x: target,
+				y: Y_BAR,
+				r: 5,
+				color: "var(--stage-good)",
+				opacity: .4
+			})] }),
+			/* @__PURE__ */ jsx(MovableDot, {
+				value: {
+					x: pct,
+					y: Y_BAR
+				},
+				onMove: (p) => setPct(clampPct(p.x)),
+				constrain: "horizontal",
+				range: {
+					min: 0,
+					max: 100
+				},
+				snap: snapPct,
+				step: snapPct,
+				readout: () => `${pct}%`,
+				color: fillColor,
+				r: 9,
+				ariaLabel: "percentage fill handle"
+			})
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs("div", {
+		className: "lab-activity-fields",
+		children: [
+			/* @__PURE__ */ jsxs("span", {
+				className: "lab-numeric-primary",
+				children: [pct, "%"]
+			}),
+			showValue && /* @__PURE__ */ jsxs("span", {
+				className: "lab-numeric-secondary",
+				children: [
+					"= ",
+					fmtVal(value),
+					unit ? ` ${unit}` : "",
+					whole !== 100 ? ` of ${fmtVal(whole)}` : ""
+				]
+			}),
+			target != null && /* @__PURE__ */ jsx(StatusPill, {
+				ok: solved,
+				children: solved ? `✓ ${target}%` : `target ${target}%`
+			})
+		]
+	});
+	const twin = scene && scene !== "none" ? getScene(scene)?.render({
+		frac: pct / 100,
+		guessTone: solved ? "ok" : "idle",
+		color: fillColor,
+		label: `${pct}%`,
+		width: 132,
+		height: 170
+	}) : null;
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "math-percent-bar-activity",
+		focusLayout: "compact",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Percentage model",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [
+				/* @__PURE__ */ jsxs("strong", { children: [pct, "%"] }),
+				showValue ? /* @__PURE__ */ jsxs("span", { children: [
+					fmtVal(value),
+					" ",
+					unit
+				] }) : null,
+				/* @__PURE__ */ jsxs("span", { children: ["whole ", fmtVal(whole)] })
+			] }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [/* @__PURE__ */ jsx(Activity.Canvas, {
+				label: "Interactive percentage model",
+				children: /* @__PURE__ */ jsx(LinkedViews, {
+					primary: figure,
+					representations: twin ? /* @__PURE__ */ jsx("div", {
+						className: "lab-rep",
+						children: twin
+					}) : void 0
+				})
+			}), /* @__PURE__ */ jsx(Activity.Inspector, {
+				label: "Percentage and amount",
+				children: controls
+			})] }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, { children: [/* @__PURE__ */ jsx("span", { children: "Observe" }), /* @__PURE__ */ jsx("div", { children: "The fill fraction and concrete amount stay synchronized: percentage ÷ 100 × whole gives the represented value." })] }),
+			/* @__PURE__ */ jsxs(Activity.LiveRegion, { children: [
+				pct,
+				" percent represents ",
+				fmtVal(value),
+				unit ? ` ${unit}` : "",
+				" of ",
+				fmtVal(whole),
+				".",
+				solved ? " Target reached." : ""
+			] }),
+			/* @__PURE__ */ jsx(Activity.Transport, { children: /* @__PURE__ */ jsxs("div", {
+				className: "lab-transport-state",
+				children: [/* @__PURE__ */ jsx("strong", { children: solved ? "Target reached" : "Move the fill handle" }), /* @__PURE__ */ jsxs("span", { children: [
+					pct,
+					"% of ",
+					fmtVal(whole)
+				] })]
+			}) })
+		]
+	});
+}
+
+//#endregion
+export { PercentBarLab };

package/dist/math/phase-portrait/index.d.mts

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

package/dist/math/phase-portrait/index.mjs

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

package/dist/math/phase-portrait/preset.d.mts

@@ -0,0 +1,27 @@
+import { ReactNode } from "react";
+
+//#region src/math/phase-portrait/preset.d.ts
+interface PhasePortraitExplorerProps {
+  dx?: string;
+  dy?: string;
+  xRange?: [number, number];
+  yRange?: [number, number];
+  initial?: [number, number];
+  duration?: number;
+  stepSize?: number;
+  title?: string;
+  height?: number;
+}
+declare function PhasePortraitExplorer({
+  dx,
+  dy,
+  xRange,
+  yRange,
+  initial: initialProp,
+  duration: durationProp,
+  stepSize: stepProp,
+  title,
+  height
+}?: PhasePortraitExplorerProps): ReactNode;
+//#endregion
+export { PhasePortraitExplorer, PhasePortraitExplorerProps };

package/dist/math/phase-portrait/preset.mjs

@@ -0,0 +1,265 @@
+'use client';
+
+import { clamp } from "../../core/util.mjs";
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { Slider } from "../../kit/controls.mjs";
+import { Field } from "../../kit/frame.mjs";
+import { normalizeRange, valueInRange } from "../calculus/core.mjs";
+import { MathActivity, MathExpressionError, MathResetTransport } from "../activity.mjs";
+import { solvePhaseSystem } from "../ode/system.mjs";
+import { useEffect, useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Axes, Grid, MovableDot, Polyline, Stage, Vector, compileExpr, evaluate, toLatex } from "@classytic/stage";
+
+//#region src/math/phase-portrait/preset.tsx
+const fmt$1 = (value) => Number.isFinite(value) ? value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "") : "—";
+const distance = (a, b) => a && b ? Math.hypot(a.x - b.x, a.y - b.y) : NaN;
+function PhasePortraitExplorer({ dx = "y", dy = "-x - 0.25*y", xRange = [-4, 4], yRange = [-4, 4], initial: initialProp = [3, 0], duration: durationProp = 10, stepSize: stepProp = .16, title = "See a system evolve in state space", height = 420 } = {}) {
+	const [xMin, xMax] = normalizeRange(xRange, [-4, 4]), [yMin, yMax] = normalizeRange(yRange, [-4, 4]);
+	const initialValue = useMemo(() => ({
+		x: valueInRange(initialProp[0], [xMin, xMax], 3),
+		y: valueInRange(initialProp[1], [yMin, yMax], 0)
+	}), [
+		initialProp[0],
+		initialProp[1],
+		xMax,
+		xMin,
+		yMax,
+		yMin
+	]);
+	const initialDuration = clamp(Number.isFinite(durationProp) ? durationProp : 10, 1, 40);
+	const initialStep = clamp(Number.isFinite(stepProp) ? stepProp : .16, .02, 1);
+	const [initial, setInitial] = useState(initialValue), [duration, setDuration] = useState(initialDuration), [stepSize, setStepSize] = useState(initialStep);
+	useEffect(() => {
+		setInitial(initialValue);
+		setDuration(initialDuration);
+		setStepSize(initialStep);
+	}, [
+		dx,
+		dy,
+		initialDuration,
+		initialStep,
+		initialValue
+	]);
+	const model = useMemo(() => {
+		const xResult = compileExpr(dx), yResult = compileExpr(dy);
+		if (!xResult.ast || !yResult.ast) return {
+			ok: false,
+			error: xResult.error ?? yResult.error ?? "Invalid system expression"
+		};
+		const field = (x, y, t) => {
+			try {
+				return {
+					dx: evaluate(xResult.ast, {
+						x,
+						y,
+						t
+					}),
+					dy: evaluate(yResult.ast, {
+						x,
+						y,
+						t
+					})
+				};
+			} catch {
+				return {
+					dx: NaN,
+					dy: NaN
+				};
+			}
+		};
+		return {
+			ok: true,
+			field,
+			dxLatex: toLatex(xResult.ast),
+			dyLatex: toLatex(yResult.ast)
+		};
+	}, [dx, dy]);
+	if (!model.ok) return /* @__PURE__ */ jsx(MathExpressionError, {
+		title,
+		error: model.error
+	});
+	const rk4 = solvePhaseSystem(model.field, initial, duration, stepSize, "rk4");
+	const euler = solvePhaseSystem(model.field, initial, duration, stepSize, "euler");
+	const reference = solvePhaseSystem(model.field, initial, duration, Math.max(.005, stepSize / 10), "rk4");
+	const endpointError = distance(euler.points.at(-1), reference.points.at(-1));
+	const rk4Error = distance(rk4.points.at(-1), reference.points.at(-1));
+	const derivative = model.field(initial.x, initial.y, 0), speed = Math.hypot(derivative.dx, derivative.dy);
+	const inside = (point) => point.x >= xMin - 1 && point.x <= xMax + 1 && point.y >= yMin - 1 && point.y <= yMax + 1;
+	const visibleRk4 = rk4.points.filter(inside), visibleEuler = euler.points.filter(inside);
+	const columns = 13, rows = 11, cellX = (xMax - xMin) / (columns - 1), cellY = (yMax - yMin) / (rows - 1), arrowLength = Math.min(cellX, cellY) * .34;
+	const vectors = [];
+	for (let column = 0; column < columns; column++) for (let row = 0; row < rows; row++) {
+		const x = xMin + column * cellX, y = yMin + row * cellY, value = model.field(x, y, 0), magnitude = Math.hypot(value.dx, value.dy);
+		if (!(magnitude > 1e-10 && Number.isFinite(magnitude))) continue;
+		vectors.push({
+			tail: {
+				x: x - arrowLength * value.dx / magnitude / 2,
+				y: y - arrowLength * value.dy / magnitude / 2
+			},
+			tip: {
+				x: x + arrowLength * value.dx / magnitude / 2,
+				y: y + arrowLength * value.dy / magnitude / 2
+			},
+			speed: magnitude
+		});
+	}
+	const seedScaleX = (xMax - xMin) * .28, seedScaleY = (yMax - yMin) * .28;
+	const context = [
+		[-seedScaleX, 0],
+		[seedScaleX, 0],
+		[0, -seedScaleY],
+		[0, seedScaleY]
+	].map(([x, y]) => solvePhaseSystem(model.field, {
+		x,
+		y
+	}, Math.min(duration, 8), Math.max(stepSize, .12), "rk4").points.filter(inside));
+	const figure = /* @__PURE__ */ jsxs(Stage, {
+		view: {
+			xMin,
+			xMax,
+			yMin,
+			yMax
+		},
+		height,
+		ariaLabel: `Phase portrait for dx over dt equals ${dx}, dy over dt equals ${dy}`,
+		children: [
+			/* @__PURE__ */ jsx(Grid, {}),
+			/* @__PURE__ */ jsx(Axes, {}),
+			vectors.map((vector, index) => /* @__PURE__ */ jsx(Vector, {
+				tail: vector.tail,
+				tip: vector.tip,
+				color: "var(--stage-muted)",
+				opacity: .42,
+				weight: 1.1
+			}, index)),
+			context.map((points, index) => /* @__PURE__ */ jsx(Polyline, {
+				points,
+				color: "var(--stage-muted)",
+				opacity: .35,
+				weight: 1.5
+			}, index)),
+			/* @__PURE__ */ jsx(Polyline, {
+				points: visibleEuler,
+				color: "var(--stage-accent-2)",
+				opacity: .72,
+				weight: 2,
+				dashed: true
+			}),
+			/* @__PURE__ */ jsx(Polyline, {
+				points: visibleRk4,
+				color: "var(--stage-good)",
+				weight: 3
+			}),
+			/* @__PURE__ */ jsx(MovableDot, {
+				value: initial,
+				onMove: (point) => setInitial({
+					x: clamp(point.x, xMin, xMax),
+					y: clamp(point.y, yMin, yMax)
+				}),
+				color: "var(--stage-accent)",
+				ariaLabel: "initial state in phase space",
+				step: Math.min(cellX, cellY) / 10
+			})
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Field, {
+		label: "Trace time",
+		value: `${duration.toFixed(1)} s`,
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: duration,
+			min: 1,
+			max: 40,
+			step: .5,
+			onChange: setDuration,
+			ariaLabel: "trajectory duration"
+		})
+	}), /* @__PURE__ */ jsx(Field, {
+		label: "Solver step h",
+		value: stepSize.toFixed(2),
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: stepSize,
+			min: .02,
+			max: 1,
+			step: .02,
+			onChange: setStepSize,
+			ariaLabel: "phase solver step size"
+		})
+	})] });
+	const details = /* @__PURE__ */ jsxs("div", {
+		className: "math-equation-detail",
+		children: [/* @__PURE__ */ jsx(Tex$1, { tex: `\frac{dx}{dt}=${model.dxLatex},\qquad \frac{dy}{dt}=${model.dyLatex}` }), /* @__PURE__ */ jsx("p", { children: "Every arrow is the instantaneous state velocity (dx/dt, dy/dt). A trajectory stays tangent to those arrows as time advances." })]
+	});
+	const reset = () => {
+		setInitial(initialValue);
+		setDuration(initialDuration);
+		setStepSize(initialStep);
+	};
+	return /* @__PURE__ */ jsx(MathActivity, {
+		className: "math-phase-portrait",
+		eyebrow: "Calculus · dynamical systems",
+		title,
+		description: "Each point is an entire system state—not a moment on an ordinary graph. Drag the initial state and watch the flow reveal cycles, attraction, repulsion, or damping.",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("strong", { children: rk4.state === "complete" ? "Trajectory traced" : "Trace stopped safely" }),
+			/* @__PURE__ */ jsxs("span", { children: [
+				"state (",
+				fmt$1(initial.x),
+				", ",
+				fmt$1(initial.y),
+				")"
+			] }),
+			/* @__PURE__ */ jsxs("span", { children: ["speed ", fmt$1(speed)] })
+		] }),
+		figure,
+		measurements: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "math-result-probe",
+				children: [
+					/* @__PURE__ */ jsx("span", { children: "Forward-endpoint error" }),
+					/* @__PURE__ */ jsxs("strong", { children: ["Euler ", Number.isFinite(endpointError) ? endpointError.toExponential(2) : "—"] }),
+					/* @__PURE__ */ jsxs("small", { children: [
+						"RK4 ",
+						Number.isFinite(rk4Error) ? rk4Error.toExponential(2) : "—",
+						" · duration ±",
+						duration.toFixed(1)
+					] })
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "math-slope-legend",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-line": "field",
+						children: "Flow direction"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						"data-line": "euler",
+						children: "Euler"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						"data-line": "rk4",
+						children: "RK4 trajectory"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "math-explain",
+				children: "The green curve follows the system both forward and backward from the draggable state. Neighboring faint curves reveal the larger flow."
+			})
+		] }),
+		controls,
+		conclusion: speed < .05 ? "This state is near an equilibrium: both derivatives are nearly zero." : "The system state moves in the direction of the local arrow; its whole history forms the trajectory.",
+		transport: /* @__PURE__ */ jsx(MathResetTransport, {
+			onReset: reset,
+			state: "Drag the state to launch another trajectory",
+			detail: `dx/dt ${fmt$1(derivative.dx)} · dy/dt ${fmt$1(derivative.dy)}`
+		}),
+		details,
+		graphLabel: "Vector field and trajectories in the x-y phase plane",
+		inspectorLabel: "System behavior"
+	});
+}
+
+//#endregion
+export { PhasePortraitExplorer };

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

@@ -0,0 +1,50 @@
+import { Complex } from "../complex/core.mjs";
+import { Node } from "@classytic/stage";
+
+//#region src/math/poly/core.d.ts
+declare namespace core_d_exports {
+  export { Poly, PolyRoots, add, allRoots, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };
+}
+type Poly = number[];
+declare const trim: (p: Poly) => Poly;
+declare const degree: (p: Poly) => number;
+/** Horner evaluation (real). */
+declare function evalPoly(p: Poly, x: number): number;
+/** Horner evaluation (complex). */
+declare function evalC(p: Poly, z: Complex): Complex;
+/** Derivative polynomial. */
+declare const deriv: (p: Poly) => Poly;
+declare function add(a: Poly, b: Poly): Poly;
+declare function mul(a: Poly, b: Poly): Poly;
+/** 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. */
+declare function deflate(p: Poly, r: number): Poly;
+/** LaTeX of a polynomial in descending order, e.g. [−6,11,−6,1] → "x^{3} - 6x^{2} + 11x - 6". */
+declare function polyTex(p0: Poly, x?: string): string;
+/** 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, …). */
+declare function fromAst(node: Node, x?: string, params?: Record<string, number>): Poly | null;
+/**
+ * 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.
+ */
+declare function allRoots(p0: Poly): Complex[];
+interface PolyRoots {
+  poly: Poly;
+  degree: number;
+  roots: Complex[];
+  realRoots: number[];
+}
+/** Solve p = 0 for ALL roots (any degree up to MAX_DEG). null if degenerate. */
+declare function solve(p0: Poly): PolyRoots | null;
+/** 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.) */
+declare function solveEquation(node: Node, x?: string, params?: Record<string, number>): PolyRoots | null;
+/**
+ * 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)".
+ */
+declare function factorTex(p0: Poly, x?: string): string;
+//#endregion
+export { Poly, PolyRoots, add, allRoots, core_d_exports, deflate, degree, deriv, evalC, evalPoly, factorTex, fromAst, mul, polyTex, solve, solveEquation, trim };