@classytic/labs 0.1.0

package/dist/commerce/economics/market-equilibrium.mjs

@@ -0,0 +1,340 @@
+'use client';
+
+import { clamp } from "../../core/util.mjs";
+import { CheckButton, Slider, StatusPill } from "../../kit/controls.mjs";
+import { ControlBar, Field, LabFrame, LiveRegion } from "../../kit/frame.mjs";
+import { useCheckpoint } from "../../kit/pedagogy.mjs";
+import { demandQ, equilibrium, supplyQ } from "./core.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Axes, Dot, Label, MovableDot, Polygon, Segment, Stage } from "@classytic/stage";
+
+//#region src/commerce/economics/market-equilibrium.tsx
+/**
+* MarketEquilibriumLab — Marshall's scissors: where the market clears.
+*
+* Drag a horizontal PRICE line across a fixed demand line + supply line. At any
+* non-equilibrium price the lab shades the HORIZONTAL gap between Qd and Qs —
+* amber SURPLUS above equilibrium (pressure pushes price down), red SHORTAGE
+* below (pressure pushes price up) — and the band collapses to nothing at the
+* crossing, where a green pill reads "market clears, Qd = Qs". Shift sliders move
+* either curve to watch BOTH P* and Q* move. Reuses the shared econ core +
+* Stage primitives; tokenized; reduced-motion safe (no autoplay — the learner drags).
+*
+* The algebra (solve a−bQ = c+dQ for Q*) belongs in a paired MathDerivation.
+*/
+const DEMAND0 = {
+	intercept: 9,
+	slope: .8
+};
+const SUPPLY0 = {
+	intercept: 1,
+	slope: .7
+};
+function MarketEquilibriumLab({ demand = DEMAND0, supply = SUPPLY0, shiftControls = {
+	demand: true,
+	supply: true
+}, priceMax = 10, qtyMax = 12, goodLabel = "the good", title = "Marshall's scissors — where the market clears", prompt = "Drag the price. Above equilibrium → surplus; below → shortage; the gap is Qs − Qd.", height = 320, objectives }) {
+	const [dShift, setDShift] = useState(0);
+	const [sShift, setSShift] = useState(0);
+	const d = {
+		intercept: demand.intercept + dShift,
+		slope: demand.slope
+	};
+	const s = {
+		intercept: supply.intercept + sShift,
+		slope: supply.slope
+	};
+	const eq = equilibrium(d, s);
+	const [price, setPrice] = useState(clamp(eq.p + 2, .4, priceMax - .4));
+	const qd = demandQ(d, price);
+	const qs = supplyQ(s, price);
+	const gap = qs - qd;
+	const cleared = Math.abs(gap) < .05;
+	const state = cleared ? "cleared" : gap > 0 ? "surplus" : "shortage";
+	useCheckpoint({
+		solved: cleared,
+		activity: "market-equilibrium"
+	});
+	const view = {
+		xMin: -.8,
+		xMax: qtyMax + .4,
+		yMin: -.8,
+		yMax: priceMax + .4
+	};
+	const dQatP0 = d.intercept / d.slope;
+	const sPatQmax = s.intercept + s.slope * qtyMax;
+	const bandColor = state === "surplus" ? "var(--stage-warn)" : "var(--stage-danger)";
+	const lo = Math.min(qd, qs), hi = Math.max(qd, qs);
+	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", {
+		style: {
+			borderRadius: 14,
+			overflow: "hidden",
+			background: "var(--stage-bg)",
+			border: "1px solid var(--stage-grid)"
+		},
+		children: /* @__PURE__ */ jsxs(Stage, {
+			view,
+			height,
+			preserveAspect: false,
+			ariaLabel: `Supply and demand; price ${price.toFixed(1)}, Qd ${qd.toFixed(1)}, Qs ${qs.toFixed(1)}, ${state}`,
+			children: [
+				/* @__PURE__ */ jsx(Axes, { ticks: false }),
+				/* @__PURE__ */ jsx(Label, {
+					x: qtyMax / 2,
+					y: -.5,
+					text: "Quantity →",
+					color: "var(--stage-muted)",
+					size: 11
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x: -.5,
+					y: priceMax / 2,
+					text: "Price",
+					color: "var(--stage-muted)",
+					size: 11
+				}),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: 0,
+						y: d.intercept
+					},
+					to: {
+						x: dQatP0,
+						y: 0
+					},
+					color: "var(--stage-accent)",
+					weight: 2.5
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x: dQatP0 * .5,
+					y: d.intercept * .5,
+					text: "Demand",
+					color: "var(--stage-accent)",
+					size: 11,
+					dx: 14
+				}),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: 0,
+						y: s.intercept
+					},
+					to: {
+						x: qtyMax,
+						y: sPatQmax
+					},
+					color: "var(--stage-accent-2)",
+					weight: 2.5
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x: qtyMax * .7,
+					y: s.intercept + s.slope * qtyMax * .7,
+					text: "Supply",
+					color: "var(--stage-accent-2)",
+					size: 11,
+					dy: -12
+				}),
+				!cleared && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+					/* @__PURE__ */ jsx(Segment, {
+						from: {
+							x: lo,
+							y: price
+						},
+						to: {
+							x: hi,
+							y: price
+						},
+						color: bandColor,
+						weight: 9,
+						opacity: .4
+					}),
+					/* @__PURE__ */ jsx(Label, {
+						x: (lo + hi) / 2,
+						y: price,
+						text: state === "surplus" ? `SURPLUS ${gap.toFixed(1)}` : `SHORTAGE ${(-gap).toFixed(1)}`,
+						color: bandColor,
+						size: 11,
+						dy: state === "surplus" ? -12 : 14
+					}),
+					/* @__PURE__ */ jsx(Polygon, {
+						points: state === "surplus" ? [
+							{
+								x: hi + .5,
+								y: price - .1
+							},
+							{
+								x: hi + .9,
+								y: price - .1
+							},
+							{
+								x: hi + .7,
+								y: price - .9
+							}
+						] : [
+							{
+								x: hi + .5,
+								y: price + .1
+							},
+							{
+								x: hi + .9,
+								y: price + .1
+							},
+							{
+								x: hi + .7,
+								y: price + .9
+							}
+						],
+						color: bandColor,
+						fill: bandColor,
+						fillOpacity: .8,
+						weight: 0
+					})
+				] }),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: eq.q,
+						y: 0
+					},
+					to: {
+						x: eq.q,
+						y: eq.p
+					},
+					color: "var(--stage-good)",
+					weight: 1,
+					dashed: true,
+					opacity: .6
+				}),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: 0,
+						y: eq.p
+					},
+					to: {
+						x: eq.q,
+						y: eq.p
+					},
+					color: "var(--stage-good)",
+					weight: 1,
+					dashed: true,
+					opacity: .6
+				}),
+				/* @__PURE__ */ jsx(Dot, {
+					x: eq.q,
+					y: eq.p,
+					r: cleared ? 8 : 5,
+					color: "var(--stage-good)"
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x: eq.q,
+					y: eq.p,
+					text: `P* ${eq.p.toFixed(1)}, Q* ${eq.q.toFixed(1)}`,
+					color: "var(--stage-good)",
+					size: 11,
+					dx: 10,
+					dy: -10
+				}),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: 0,
+						y: price
+					},
+					to: {
+						x: qtyMax,
+						y: price
+					},
+					color: "var(--stage-fg)",
+					weight: 1.5,
+					opacity: .5,
+					dashed: true
+				}),
+				/* @__PURE__ */ jsx(MovableDot, {
+					value: {
+						x: .35,
+						y: price
+					},
+					onMove: (p) => setPrice(clamp(p.y, .4, priceMax - .4)),
+					constrain: "vertical",
+					range: {
+						min: .4,
+						max: priceMax - .4
+					},
+					color: "var(--stage-fg)",
+					ariaLabel: "price"
+				}),
+				/* @__PURE__ */ jsx(Dot, {
+					x: qd,
+					y: price,
+					r: 4,
+					color: "var(--stage-accent)"
+				}),
+				/* @__PURE__ */ jsx(Dot, {
+					x: qs,
+					y: price,
+					r: 4,
+					color: "var(--stage-accent-2)"
+				})
+			]
+		})
+	}), /* @__PURE__ */ jsx(LiveRegion, { children: `Price ${price.toFixed(1)} for ${goodLabel}. Quantity demanded ${qd.toFixed(1)}, supplied ${qs.toFixed(1)}. ${state}. Equilibrium price ${eq.p.toFixed(1)}, quantity ${eq.q.toFixed(1)}.` })] });
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			shiftControls.demand && /* @__PURE__ */ jsx(Field, {
+				label: "shift demand",
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: dShift,
+					min: -4,
+					max: 4,
+					step: .5,
+					onChange: setDShift,
+					ariaLabel: "shift the demand curve"
+				})
+			}),
+			shiftControls.supply && /* @__PURE__ */ jsx(Field, {
+				label: "shift supply",
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: sShift,
+					min: -4,
+					max: 4,
+					step: .5,
+					onChange: setSShift,
+					ariaLabel: "shift the supply curve"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "price",
+				value: price.toFixed(1),
+				children: /* @__PURE__ */ jsx(CheckButton, {
+					onClick: () => setPrice(clamp(eq.p, .4, priceMax - .4)),
+					children: "Snap to equilibrium"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "Qd",
+				value: /* @__PURE__ */ jsx("span", {
+					style: { color: "var(--stage-accent)" },
+					children: qd.toFixed(1)
+				}),
+				children: /* @__PURE__ */ jsx("span", {})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "Qs",
+				value: /* @__PURE__ */ jsx("span", {
+					style: { color: "var(--stage-accent-2)" },
+					children: qs.toFixed(1)
+				}),
+				children: /* @__PURE__ */ jsx("span", {})
+			})
+		] }),
+		footer: /* @__PURE__ */ jsx(StatusPill, {
+			ok: cleared,
+			children: state === "cleared" ? "Market clears · Qd = Qs ✓" : state === "surplus" ? "Surplus → price pressured DOWN" : "Shortage → price pressured UP"
+		}),
+		children: figure
+	});
+}
+
+//#endregion
+export { MarketEquilibriumLab };

package/dist/commerce/index.d.mts

@@ -0,0 +1,9 @@
+import { Account, AccountCategory, CATEGORY_COLOR, Side, debitsEqualCredits, equationParts, money, normalBalance, statementOf } from "./accounting/core.mjs";
+import { EquationBalanceLab, EquationBalanceProps, Transaction, TxnEffect } from "./accounting/equation-balance.mjs";
+import { JournalPosterLab, JournalPosterProps, JournalTxn } from "./accounting/journal-poster.mjs";
+import { SortAccount, StatementSorterLab, StatementSorterProps } from "./accounting/statement-sorter.mjs";
+import { Curve, demandP, demandQ, equilibrium, pointElasticity, supplyP, supplyQ } from "./economics/core.mjs";
+import { MarketEquilibriumLab, MarketEquilibriumProps } from "./economics/market-equilibrium.mjs";
+import { ElasticityRevenueLab, ElasticityRevenueProps } from "./economics/elasticity-revenue.mjs";
+import { DemandShiftVsMoveLab, DemandShiftVsMoveProps, Shifter } from "./economics/demand-shift-vs-move.mjs";
+export { type Account, type AccountCategory, CATEGORY_COLOR, type Curve, DemandShiftVsMoveLab, type DemandShiftVsMoveProps, ElasticityRevenueLab, type ElasticityRevenueProps, EquationBalanceLab, type EquationBalanceProps, JournalPosterLab, type JournalPosterProps, type JournalTxn, MarketEquilibriumLab, type MarketEquilibriumProps, type Shifter, type Side, type SortAccount, StatementSorterLab, type StatementSorterProps, type Transaction, type TxnEffect, debitsEqualCredits, demandP, demandQ, equationParts, equilibrium, money, normalBalance, pointElasticity, statementOf, supplyP, supplyQ };

package/dist/commerce/index.mjs

@@ -0,0 +1,10 @@
+import { CATEGORY_COLOR, debitsEqualCredits, equationParts, money, normalBalance, statementOf } from "./accounting/core.mjs";
+import { EquationBalanceLab } from "./accounting/equation-balance.mjs";
+import { JournalPosterLab } from "./accounting/journal-poster.mjs";
+import { StatementSorterLab } from "./accounting/statement-sorter.mjs";
+import { demandP, demandQ, equilibrium, pointElasticity, supplyP, supplyQ } from "./economics/core.mjs";
+import { MarketEquilibriumLab } from "./economics/market-equilibrium.mjs";
+import { ElasticityRevenueLab } from "./economics/elasticity-revenue.mjs";
+import { DemandShiftVsMoveLab } from "./economics/demand-shift-vs-move.mjs";
+
+export { CATEGORY_COLOR, DemandShiftVsMoveLab, ElasticityRevenueLab, EquationBalanceLab, JournalPosterLab, MarketEquilibriumLab, StatementSorterLab, debitsEqualCredits, demandP, demandQ, equationParts, equilibrium, money, normalBalance, pointElasticity, statementOf, supplyP, supplyQ };

package/dist/core/easing.d.mts

@@ -0,0 +1,28 @@
+//#region src/core/easing.d.ts
+/**
+ * Easing / rate functions — pure `(t in [0,1]) => number`. Ported from manim's
+ * `rate_functions` + the standard web set. Shape `alpha` before interpolation.
+ */
+type Easing = (t: number) => number;
+declare const linear: Easing;
+/** Smootherstep (manim's default `smooth`): zero velocity AND accel at the ends. */
+declare const smooth: Easing;
+declare const easeInCubic: Easing;
+declare const easeOutCubic: Easing;
+declare const easeInOut: Easing;
+/** Accelerate from rest (manim `rush_into`). */
+declare const rushInto: Easing;
+/** Decelerate to rest (manim `rush_from`). */
+declare const rushFrom: Easing;
+/** Go to 1 then back to 0 (manim `there_and_back`) — great for pulses. */
+declare const thereAndBack: Easing;
+/** Overshoot then settle. */
+declare const elastic: Easing;
+/** Standard CSS-style cubic-bezier easing factory. */
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): Easing;
+/** Squash an easing into the sub-window [a,b] of [0,1] (manim `squish_rate_func`). */
+declare function squish(fn: Easing, a?: number, b?: number): Easing;
+/** Built-in registry — extend with `registerEasing` (see ./registry). */
+declare const EASINGS: Record<string, Easing>;
+//#endregion
+export { EASINGS, Easing, cubicBezier, easeInCubic, easeInOut, easeOutCubic, elastic, linear, rushFrom, rushInto, smooth, squish, thereAndBack };

package/dist/core/easing.mjs

@@ -0,0 +1,66 @@
+//#region src/core/easing.ts
+const linear = (t) => t;
+/** Smootherstep (manim's default `smooth`): zero velocity AND accel at the ends. */
+const smooth = (t) => {
+	const x = Math.min(1, Math.max(0, t));
+	return x * x * x * (x * (x * 6 - 15) + 10);
+};
+const easeInCubic = (t) => t * t * t;
+const easeOutCubic = (t) => 1 - (1 - t) ** 3;
+const easeInOut = (t) => t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+/** Accelerate from rest (manim `rush_into`). */
+const rushInto = (t) => 2 * smooth(t / 2);
+/** Decelerate to rest (manim `rush_from`). */
+const rushFrom = (t) => 2 * smooth(t / 2 + .5) - 1;
+/** Go to 1 then back to 0 (manim `there_and_back`) — great for pulses. */
+const thereAndBack = (t) => smooth(t < .5 ? 2 * t : 2 * (1 - t));
+/** Overshoot then settle. */
+const elastic = (t) => {
+	if (t === 0 || t === 1) return t;
+	const p = .3;
+	return 2 ** (-10 * t) * Math.sin((t - p / 4) * (2 * Math.PI) / p) + 1;
+};
+/** Standard CSS-style cubic-bezier easing factory. */
+function cubicBezier(x1, y1, x2, y2) {
+	const cx = 3 * x1;
+	const bx = 3 * (x2 - x1) - cx;
+	const ax = 1 - cx - bx;
+	const cy = 3 * y1;
+	const by = 3 * (y2 - y1) - cy;
+	const ay = 1 - cy - by;
+	const fx = (t) => ((ax * t + bx) * t + cx) * t;
+	const fy = (t) => ((ay * t + by) * t + cy) * t;
+	const dfx = (t) => (3 * ax * t + 2 * bx) * t + cx;
+	return (x) => {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let t = x;
+		for (let i = 0; i < 8; i++) {
+			const e = fx(t) - x;
+			if (Math.abs(e) < 1e-4) break;
+			const d = dfx(t);
+			if (Math.abs(d) < 1e-6) break;
+			t -= e / d;
+		}
+		return fy(Math.min(1, Math.max(0, t)));
+	};
+}
+/** Squash an easing into the sub-window [a,b] of [0,1] (manim `squish_rate_func`). */
+function squish(fn, a = .2, b = .8) {
+	return (t) => t < a ? 0 : t > b ? 1 : fn((t - a) / (b - a));
+}
+/** Built-in registry — extend with `registerEasing` (see ./registry). */
+const EASINGS = {
+	linear,
+	smooth,
+	easeInCubic,
+	easeOutCubic,
+	easeInOut,
+	rushInto,
+	rushFrom,
+	thereAndBack,
+	elastic
+};
+
+//#endregion
+export { EASINGS, cubicBezier, easeInCubic, easeInOut, easeOutCubic, elastic, linear, rushFrom, rushInto, smooth, squish, thereAndBack };

package/dist/core/index.d.mts

@@ -0,0 +1,10 @@
+import { Rng, gaussian, mulberry32, randInt, sample, shuffle } from "./rng.mjs";
+import { approxEq, clamp, cn, lerp, num, remap, toDeg, toRad } from "./util.mjs";
+import { RealFn, derivativeAt, estimateOneSidedLimit, integrate, riemannSum, sampleFunction, secantSlope } from "./numeric.mjs";
+import { Tex } from "./tex.mjs";
+import { RichText } from "../kit/rich.mjs";
+import { EASINGS, Easing, cubicBezier, easeInCubic, easeInOut, easeOutCubic, elastic, linear, rushFrom, rushInto, smooth, squish, thereAndBack } from "./easing.mjs";
+import { SciValue, derive, useSciValue, useValue, value } from "./reactive.mjs";
+import { Keyframe, TweenOptions, TweenState, keyframes, useTween } from "./timeline.mjs";
+import { RichSpan, parseRichText } from "@classytic/stage";
+export { EASINGS, type Easing, type Keyframe, type RealFn, type RichSpan, RichText, type Rng, type SciValue, Tex, type TweenOptions, type TweenState, approxEq, clamp, cn, cubicBezier, derivativeAt, derive, easeInCubic, easeInOut, easeOutCubic, elastic, estimateOneSidedLimit, gaussian, integrate, keyframes, lerp, linear, mulberry32, num, parseRichText, randInt, remap, riemannSum, rushFrom, rushInto, sample, sampleFunction, secantSlope, shuffle, smooth, squish, thereAndBack, toDeg, toRad, useSciValue, useTween, useValue, value };

package/dist/core/index.mjs

@@ -0,0 +1,11 @@
+import { approxEq, clamp, cn, lerp, num, remap, toDeg, toRad } from "./util.mjs";
+import { derivativeAt, estimateOneSidedLimit, integrate, riemannSum, sampleFunction, secantSlope } from "./numeric.mjs";
+import { gaussian, mulberry32, randInt, sample, shuffle } from "./rng.mjs";
+import { Tex } from "./tex.mjs";
+import { RichText } from "../kit/rich.mjs";
+import { EASINGS, cubicBezier, easeInCubic, easeInOut, easeOutCubic, elastic, linear, rushFrom, rushInto, smooth, squish, thereAndBack } from "./easing.mjs";
+import { derive, useSciValue, useValue, value } from "./reactive.mjs";
+import { keyframes, useTween } from "./timeline.mjs";
+import { parseRichText } from "@classytic/stage";
+
+export { EASINGS, RichText, Tex, approxEq, clamp, cn, cubicBezier, derivativeAt, derive, easeInCubic, easeInOut, easeOutCubic, elastic, estimateOneSidedLimit, gaussian, integrate, keyframes, lerp, linear, mulberry32, num, parseRichText, randInt, remap, riemannSum, rushFrom, rushInto, sample, sampleFunction, secantSlope, shuffle, smooth, squish, thereAndBack, toDeg, toRad, useSciValue, useTween, useValue, value };

package/dist/core/numeric.d.mts

@@ -0,0 +1,37 @@
+//#region src/core/numeric.d.ts
+/**
+ * numeric — small numerical-calculus helpers, used when an exact symbolic result
+ * isn't available (e.g. a function the differentiator doesn't handle) or when a
+ * widget just needs a number. Pure, dependency-free.
+ */
+type RealFn = (x: number) => number;
+/** Numerical derivative via the symmetric difference quotient. */
+declare function derivativeAt(fn: RealFn, x: number, h?: number): number;
+/** Slope of the secant line through (a, f(a)) and (b, f(b)). */
+declare function secantSlope(fn: RealFn, a: number, b: number): number;
+/** Sample a function across a range into `{x, y}` points (skips non-finite y is the caller's job). */
+declare function sampleFunction(fn: RealFn, range: [number, number], samples?: number): {
+  x: number;
+  y: number;
+}[];
+/** Riemann sum of `fn` over `[a, b]` with `n` subintervals. A teaching estimate. */
+declare function riemannSum(fn: RealFn, range: [number, number], n: number, mode?: 'left' | 'right' | 'mid'): number;
+/**
+ * Composite Simpson's rule — a high-accuracy definite-integral estimate (error
+ * O(h⁴), vs O(h) for a Riemann sum). Used as the "reference" a Riemann sum
+ * converges toward. `n` is forced even. Not exact, but accurate to ~machine
+ * precision for smooth integrands at n≈1000.
+ */
+declare function integrate(fn: RealFn, range: [number, number], n?: number): number;
+/**
+ * Estimate a one-sided limit of `fn` as x → c from `side` (+1 right, −1 left) by
+ * sampling a shrinking sequence of offsets. Returns the closest-in value and
+ * whether the sequence is *converging* (consecutive samples agree) — so callers
+ * can honestly report "estimated limit" + confidence rather than a hard claim.
+ */
+declare function estimateOneSidedLimit(fn: RealFn, c: number, side: 1 | -1): {
+  value: number;
+  converging: boolean;
+};
+//#endregion
+export { RealFn, derivativeAt, estimateOneSidedLimit, integrate, riemannSum, sampleFunction, secantSlope };

package/dist/core/numeric.mjs

@@ -0,0 +1,75 @@
+//#region src/core/numeric.ts
+/** Numerical derivative via the symmetric difference quotient. */
+function derivativeAt(fn, x, h = 1e-5) {
+	return (fn(x + h) - fn(x - h)) / (2 * h);
+}
+/** Slope of the secant line through (a, f(a)) and (b, f(b)). */
+function secantSlope(fn, a, b) {
+	return (fn(b) - fn(a)) / (b - a);
+}
+/** Sample a function across a range into `{x, y}` points (skips non-finite y is the caller's job). */
+function sampleFunction(fn, range, samples = 200) {
+	const [min, max] = range;
+	const out = [];
+	for (let i = 0; i <= samples; i++) {
+		const x = min + (max - min) * i / samples;
+		out.push({
+			x,
+			y: fn(x)
+		});
+	}
+	return out;
+}
+/** Riemann sum of `fn` over `[a, b]` with `n` subintervals. A teaching estimate. */
+function riemannSum(fn, range, n, mode = "mid") {
+	const [a, b] = range;
+	const dx = (b - a) / n;
+	let sum = 0;
+	for (let i = 0; i < n; i++) {
+		const x = mode === "left" ? a + i * dx : mode === "right" ? a + (i + 1) * dx : a + (i + .5) * dx;
+		sum += fn(x);
+	}
+	return sum * dx;
+}
+/**
+* Composite Simpson's rule — a high-accuracy definite-integral estimate (error
+* O(h⁴), vs O(h) for a Riemann sum). Used as the "reference" a Riemann sum
+* converges toward. `n` is forced even. Not exact, but accurate to ~machine
+* precision for smooth integrands at n≈1000.
+*/
+function integrate(fn, range, n = 1e3) {
+	const [a, b] = range;
+	const m = Math.max(2, Math.ceil(n / 2) * 2);
+	const h = (b - a) / m;
+	let sum = fn(a) + fn(b);
+	for (let i = 1; i < m; i++) sum += (i % 2 === 1 ? 4 : 2) * fn(a + i * h);
+	return sum * h / 3;
+}
+/**
+* Estimate a one-sided limit of `fn` as x → c from `side` (+1 right, −1 left) by
+* sampling a shrinking sequence of offsets. Returns the closest-in value and
+* whether the sequence is *converging* (consecutive samples agree) — so callers
+* can honestly report "estimated limit" + confidence rather than a hard claim.
+*/
+function estimateOneSidedLimit(fn, c, side) {
+	const vals = [
+		.1,
+		.01,
+		.001,
+		1e-4,
+		1e-5
+	].map((h) => fn(c + side * h)).filter((v) => Number.isFinite(v));
+	if (vals.length < 2) return {
+		value: NaN,
+		converging: false
+	};
+	const last = vals[vals.length - 1];
+	const prev = vals[vals.length - 2];
+	return {
+		value: last,
+		converging: Math.abs(last - prev) < .01 * (1 + Math.abs(last))
+	};
+}
+
+//#endregion
+export { derivativeAt, estimateOneSidedLimit, integrate, riemannSum, sampleFunction, secantSlope };

package/dist/core/reactive.d.mts

@@ -0,0 +1,24 @@
+//#region src/core/reactive.d.ts
+/**
+ * Tiny reactive value — the `ValueTracker` / signal at the heart of
+ * interactivity. A slider/drag updates a `value()`; anything derived from it
+ * recomputes; React components bound via `useValue` repaint. Framework-light
+ * (no external dep); the React glue is one hook.
+ */
+interface SciValue<T> {
+  get(): T;
+  set(next: T): void;
+  /** Functional update. */
+  update(fn: (prev: T) => T): void;
+  subscribe(fn: (v: T) => void): () => void;
+  readonly isSciValue: true;
+}
+declare function value<T>(initial: T): SciValue<T>;
+/** Read-only computed value derived from one or more `SciValue`s. */
+declare function derive<T>(deps: ReadonlyArray<SciValue<unknown>>, compute: () => T): SciValue<T>;
+/** Subscribe a React component to a `SciValue`; returns its current value. */
+declare function useValue<T>(sv: SciValue<T>): T;
+/** Create a stable `SciValue` that lives for the component's lifetime. */
+declare function useSciValue<T>(initial: T | (() => T)): SciValue<T>;
+//#endregion
+export { SciValue, derive, useSciValue, useValue, value };

package/dist/core/reactive.mjs

@@ -0,0 +1,51 @@
+import { useEffect, useReducer, useRef } from "react";
+
+//#region src/core/reactive.ts
+/**
+* Tiny reactive value — the `ValueTracker` / signal at the heart of
+* interactivity. A slider/drag updates a `value()`; anything derived from it
+* recomputes; React components bound via `useValue` repaint. Framework-light
+* (no external dep); the React glue is one hook.
+*/
+function value(initial) {
+	let current = initial;
+	const subs = /* @__PURE__ */ new Set();
+	const sv = {
+		isSciValue: true,
+		get: () => current,
+		set: (next) => {
+			if (Object.is(next, current)) return;
+			current = next;
+			for (const fn of subs) fn(current);
+		},
+		update: (fn) => sv.set(fn(current)),
+		subscribe: (fn) => {
+			subs.add(fn);
+			return () => subs.delete(fn);
+		}
+	};
+	return sv;
+}
+/** Read-only computed value derived from one or more `SciValue`s. */
+function derive(deps, compute) {
+	const out = value(compute());
+	for (const dep of deps) dep.subscribe(() => out.set(compute()));
+	return out;
+}
+/** Subscribe a React component to a `SciValue`; returns its current value. */
+function useValue(sv) {
+	const [, force] = useReducer((c) => c + 1, 0);
+	const ref = useRef(sv);
+	ref.current = sv;
+	useEffect(() => sv.subscribe(() => force()), [sv]);
+	return sv.get();
+}
+/** Create a stable `SciValue` that lives for the component's lifetime. */
+function useSciValue(initial) {
+	const ref = useRef(null);
+	if (ref.current === null) ref.current = value(typeof initial === "function" ? initial() : initial);
+	return ref.current;
+}
+
+//#endregion
+export { derive, useSciValue, useValue, value };