@classytic/labs 0.1.0 → 0.2.0

package/dist/kit/expr-analysis.d.mts

@@ -3,7 +3,7 @@ import { Node } from "@classytic/stage";
 //#region src/kit/expr-analysis.d.ts
 type Fn1 = (x: number) => number;
 /** A straight line y = m·x + c, with the point it was taken at and an evaluator. */
-interface Line {
+interface Line$1 {
   m: number;
   c: number;
   at: {
@@ -12,7 +12,14 @@ interface Line {
   };
   f: Fn1;
 }
-/** Real roots of f on [a,b] via a sign-change scan refined by bisection. */
+/**
+ * Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+ *   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+ *   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+ *      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+ *      change sign. False minima (a parabola that never reaches 0) are rejected
+ *      by the accept tolerance, so no phantom roots.
+ */
 declare function roots(f: Fn1, a: number, b: number, opts?: {
   steps?: number;
   tol?: number;
@@ -26,12 +33,17 @@ declare function intersections(f: Fn1, g: Fn1, a: number, b: number, opts?: {
   y: number;
 }[];
 /** Exact tangent line to `ast` at x = x0 (params baked in via `scope`). */
-declare function tangentAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+declare function tangentAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line$1 | null;
 /** Normal line to `ast` at x = x0 (⟂ the tangent). Null if the tangent is horizontal. */
-declare function normalAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line | null;
+declare function normalAt(ast: Node, x0: number, varName?: string, params?: Record<string, number>): Line$1 | null;
 /** Composite-Simpson definite integral ∫_a^b f dx. */
 declare function integrate(f: Fn1, a: number, b: number, n?: number): number;
-/** Unsigned area between f and g over [a,b]. */
+/**
+ * Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+ * pieces where g > f don't cancel the pieces where f > g (which a single
+ * |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+ * wants.
+ */
 declare function areaBetween(f: Fn1, g: Fn1, a: number, b: number, n?: number): number;
 //#endregion
-export { Fn1, Line, areaBetween, integrate, intersections, normalAt, roots, tangentAt };
+export { Fn1, Line$1 as Line, areaBetween, integrate, intersections, normalAt, roots, tangentAt };

package/dist/kit/expr-analysis.mjs

@@ -2,10 +2,10 @@ import { differentiate, evaluate } from "@classytic/stage";
 
 //#region src/kit/expr-analysis.ts
 /**
-* expr-analysis — the numeric/symbolic "solving" layer of the interactive-problem
+* expr-analysis, the numeric/symbolic "solving" layer of the interactive-problem
 * engine, built on @classytic/stage's expr engine. Pure functions (no React) so a
-* creator's authored config can derive the quantities A-level questions ask for —
-* roots, intersections, tangents/normals, areas — without anyone hand-coding a lab.
+* creator's authored config can derive the quantities A-level questions ask for , 
+* roots, intersections, tangents/normals, areas, without anyone hand-coding a lab.
 *
 * Everything works on a compiled scalar `Fn1 = (x) => number` (params already baked
 * into the closure) plus, for exact tangents, the parsed `Node` AST.
@@ -13,39 +13,79 @@ import { differentiate, evaluate } from "@classytic/stage";
 function pushUnique(out, x, tol) {
 	if (!out.some((p) => Math.abs(p - x) <= tol)) out.push(x);
 }
-/** Real roots of f on [a,b] via a sign-change scan refined by bisection. */
+/** Newton's method from x0 using a central-difference derivative (we only hold
+*  the numeric f, not its AST). Returns the polished root, or null on a flat
+*  derivative / divergence. Used to recover tangent (even-multiplicity) roots a
+*  sign-change scan can't see. */
+function newton(f, x0, tol) {
+	let x = x0;
+	for (let k = 0; k < 40; k++) {
+		const fx = f(x);
+		if (!Number.isFinite(fx)) return null;
+		if (Math.abs(fx) <= tol) return x;
+		const h = Math.max(1e-7, Math.abs(x) * 1e-7);
+		const d = (f(x + h) - f(x - h)) / (2 * h);
+		if (!Number.isFinite(d) || Math.abs(d) < 1e-13) return null;
+		const nx = x - fx / d;
+		if (!Number.isFinite(nx)) return null;
+		if (Math.abs(nx - x) <= tol) return nx;
+		x = nx;
+	}
+	return Math.abs(f(x)) <= tol ? x : null;
+}
+/**
+* Real roots of f on [a,b]. Two passes so it doesn't miss the roots students do:
+*   1. sign-change brackets refined by BISECTION (odd-multiplicity / crossings);
+*   2. local minima of |f| polished by NEWTON, accepted only if |f| really drops
+*      to ~0 — this recovers TANGENT / double roots (e.g. x² at 0) that never
+*      change sign. False minima (a parabola that never reaches 0) are rejected
+*      by the accept tolerance, so no phantom roots.
+*/
 function roots(f, a, b, opts = {}) {
 	const steps = opts.steps ?? 1e3;
 	const tol = opts.tol ?? 1e-9;
 	const grid = (b - a) / steps;
 	const out = [];
-	let xPrev = a;
-	let fPrev = f(a);
-	for (let i = 1; i <= steps; i++) {
+	const xs = [], fs = [];
+	for (let i = 0; i <= steps; i++) {
 		const x = a + grid * i;
-		const fx = f(x);
-		if (Number.isFinite(fPrev) && Number.isFinite(fx)) {
-			if (fPrev === 0) pushUnique(out, xPrev, grid);
-			else if (fPrev * fx < 0) {
-				let lo = xPrev;
-				let hi = x;
-				let flo = fPrev;
-				for (let k = 0; k < 80 && hi - lo > tol; k++) {
-					const mid = (lo + hi) / 2;
-					const fm = f(mid);
-					if (!Number.isFinite(fm)) break;
-					if (flo * fm <= 0) hi = mid;
-					else {
-						lo = mid;
-						flo = fm;
-					}
+		xs.push(x);
+		fs.push(f(x));
+	}
+	let maxAbs = 0;
+	for (const v of fs) if (Number.isFinite(v)) maxAbs = Math.max(maxAbs, Math.abs(v));
+	const acceptTol = 1e-7 * (1 + maxAbs);
+	for (let i = 1; i <= steps; i++) {
+		const fPrev = fs[i - 1], fx = fs[i];
+		if (!Number.isFinite(fPrev) || !Number.isFinite(fx)) continue;
+		if (fPrev === 0) {
+			pushUnique(out, xs[i - 1], grid);
+			continue;
+		}
+		if (fPrev * fx < 0) {
+			let lo = xs[i - 1], hi = xs[i], flo = fPrev;
+			for (let k = 0; k < 80 && hi - lo > tol; k++) {
+				const mid = (lo + hi) / 2;
+				const fm = f(mid);
+				if (!Number.isFinite(fm)) break;
+				if (flo * fm <= 0) hi = mid;
+				else {
+					lo = mid;
+					flo = fm;
 				}
-				pushUnique(out, (lo + hi) / 2, grid);
 			}
+			pushUnique(out, (lo + hi) / 2, grid);
 		}
-		xPrev = x;
-		fPrev = fx;
 	}
+	for (let i = 1; i < steps; i++) {
+		const p = fs[i - 1], c = fs[i], q = fs[i + 1];
+		if (!Number.isFinite(p) || !Number.isFinite(c) || !Number.isFinite(q)) continue;
+		if (Math.abs(c) <= Math.abs(p) && Math.abs(c) <= Math.abs(q) && Math.abs(c) < .05 * (1 + maxAbs)) {
+			const r = newton(f, xs[i], tol);
+			if (r != null && r >= a - grid && r <= b + grid && Math.abs(f(r)) <= acceptTol) pushUnique(out, r, grid);
+		}
+	}
+	out.sort((u, v) => u - v);
 	return out;
 }
 /** Points where f and g meet on [a,b]. */
@@ -102,9 +142,23 @@ function integrate(f, a, b, n = 1e3) {
 	for (let i = 1; i < N; i++) s += (i % 2 ? 4 : 2) * f(a + i * h);
 	return h / 3 * s;
 }
-/** Unsigned area between f and g over [a,b]. */
+/**
+* Geometric area between f and g over [a,b]. SPLITS at every crossing so the
+* pieces where g > f don't cancel the pieces where f > g (which a single
+* |∫(f−g)| would). Sums |∫| over each sub-interval — the area an exam actually
+* wants.
+*/
 function areaBetween(f, g, a, b, n = 1e3) {
-	return Math.abs(integrate((x) => f(x) - g(x), a, b, n));
+	const d = (x) => f(x) - g(x);
+	const cuts = [
+		a,
+		...roots(d, a, b).filter((x) => x > a + 1e-9 && x < b - 1e-9).sort((u, v) => u - v),
+		b
+	];
+	const per = Math.max(20, Math.round(n / Math.max(1, cuts.length - 1)));
+	let area = 0;
+	for (let i = 0; i < cuts.length - 1; i++) area += Math.abs(integrate(d, cuts[i], cuts[i + 1], per));
+	return area;
 }
 
 //#endregion

package/dist/kit/frame.d.mts

@@ -17,13 +17,13 @@ interface LabFrameProps {
   children: ReactNode;
   /** Optional narrow side column (readouts, a guess, a result callout). */
   aside?: ReactNode;
-  /** The single controls bar — pass <ControlBar>…</ControlBar>. */
+  /** The single controls bar, pass <ControlBar>…</ControlBar>. */
   controls?: ReactNode;
   /** Quiet footer: feedback / hints / reveal / a note. */
   footer?: ReactNode;
-  /** Ref on the outer container — e.g. for useInView() to pause a sim off-screen. */
+  /** Ref on the outer container, e.g. for useInView() to pause a sim off-screen. */
   rootRef?: Ref<HTMLDivElement>;
-  /** Creator's per-control hide/lock policy — flows to every Field/Control below. */
+  /** Creator's per-control hide/lock policy, flows to every Field/Control below. */
   controlConfig?: ControlConfig;
 }
 declare function LabFrame({

package/dist/kit/frame.mjs

@@ -5,24 +5,24 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/kit/frame.tsx
 /**
-* LabFrame — the shared layout shell every lab composes into, so labs stop being
+* LabFrame, the shared layout shell every lab composes into, so labs stop being
 * hand-rolled inline-styled one-offs and read as ONE product. Structure:
 *
-*   title + one-line prompt           (header — no walls of text)
+*   title + one-line prompt           (header, no walls of text)
 *   [▸ goals]                         (collapsed disclosure, reveal-on-action)
 *   ┌─ figure (dominant) ─┬─ aside ─┐ (one grid; aside optional + narrow)
 *   └─────────────────────┴─────────┘
 *   [ one controls bar ]             (ALL knobs in one place, never scattered)
 *   feedback / hints / reveal        (quiet footer)
 *
-* Everything styles off `.lab-*` in @classytic/labs/styles.css — no inline layout.
+* Everything styles off `.lab-*` in @classytic/labs/styles.css, no inline layout.
 * Pair with the existing pedagogy kit (HintLadder, RevealSolution, Feedback).
 *
-* CREATOR CONTROL — `controlConfig` lets the author decide, per knob, what a learner
+* CREATOR CONTROL, `controlConfig` lets the author decide, per knob, what a learner
 * may touch: `{ hide: ['mass'], lock: ['angle'] }`. Hidden knobs vanish; locked knobs
 * stay visible but read-only (their value is whatever the creator set as the initial
 * prop). LabFrame provides this as context; `Field` (keyed by its `name ?? label`) and
-* the `Control` wrapper consume it — so a lab opts in with ~2 lines and every knob,
+* the `Control` wrapper consume it, so a lab opts in with ~2 lines and every knob,
 * existing or new, honours it. The mechanism is uniform: no per-knob boolean props.
 */
 const ControlCtx = createContext(void 0);
@@ -83,6 +83,25 @@ function LabFrame({ title, prompt, objectives, children, aside, controls, footer
 function ControlBar({ children }) {
 	return /* @__PURE__ */ jsx(Fragment$1, { children });
 }
+/**
+* Group an inline expression (parens, steppers, "→ result", …) so it reads as ONE
+* unit. `.lab-controls` is a grid that gives EACH ControlBar child its own ~185px
+* cell, which scatters a multi-piece expression across columns. Wrap those pieces
+* in `<ControlExpr>` and they stay together (one cell, tight gaps, baseline-aligned).
+*/
+function ControlExpr({ children }) {
+	return /* @__PURE__ */ jsx("span", {
+		style: {
+			gridColumn: "1 / -1",
+			display: "flex",
+			alignItems: "center",
+			flexWrap: "wrap",
+			gap: 8,
+			fontWeight: 600
+		},
+		children
+	});
+}
 const LockMark = () => /* @__PURE__ */ jsxs("svg", {
 	className: "lab-field-lock",
 	viewBox: "0 0 24 24",
@@ -202,4 +221,4 @@ function MeterBar({ label, frac, color, value }) {
 }
 
 //#endregion
-export { Callout, Control, ControlBar, Field, LabFrame, LiveRegion, MeterBar };
+export { Callout, Control, ControlBar, ControlExpr, Field, LabFrame, LiveRegion, MeterBar };

package/dist/kit/gameshow.mjs

@@ -148,7 +148,7 @@ function DoorGlyph({ x, y, w, h, label, open = 0, picked = false, dim = false, c
 		]
 	});
 }
-/** The prize — a shiny car (side view) in box (x,y,w,h). */
+/** The prize, a shiny car (side view) in box (x,y,w,h). */
 function CarGlyph({ x, y, w, h }) {
 	const X = (f) => x + w * f, Y = (f) => y + h * f;
 	const edge = "color-mix(in oklab, var(--stage-warn) 55%, black)";
@@ -214,7 +214,7 @@ function CarGlyph({ x, y, w, h }) {
 		] }, f))
 	] });
 }
-/** The booby prize — a goat head in box (x,y,w,h). Big swept horns + beard so it
+/** The booby prize, a goat head in box (x,y,w,h). Big swept horns + beard so it
 *  reads as a goat, not a mouse. */
 function GoatGlyph({ x, y, w, h }) {
 	const X = (f) => x + w * f, Y = (f) => y + h * f;

package/dist/kit/index.d.mts

@@ -1,5 +1,17 @@
-import { Callout, ControlBar, ControlConfig, Field, LabFrame } from "./frame.mjs";
 import { ChallengeCard, ChallengeChoice, ChallengeQuestion, ChallengeState, CheckpointArgs, Feedback, HintLadder, Hints, Objectives, RevealSolution, RevealSolutionProps, useChallenge, useCheckpoint, useHints } from "./pedagogy.mjs";
+import { Calc, CalcStep, Worked, calc, texNum } from "./calc.mjs";
+import { RuleCard, RuleDef, RuleInput, RuleLab, WorkedSteps } from "./rule.mjs";
+import { ReceiptItem, ReceiptScene, ReceiptSceneProps } from "./receipt.mjs";
+import { Clue, ClueBalance, ClueBar, ClueCoins, ClueReceipt, ClueScene, ClueSceneKind, ClueSceneMeta, ClueTiles, Unknown, UnknownChip, clueTotal, getClueScene, listClueScenes, registerClueScene } from "./clue-scene.mjs";
+import { Callout, ControlBar, ControlConfig, Field, LabFrame } from "./frame.mjs";
 import { StepNav, Steps, useSteps } from "./steps.mjs";
 import { PlayGate, PlayWrap, usePlayGate } from "./play.mjs";
-export { Callout, ChallengeCard, type ChallengeChoice, type ChallengeQuestion, type ChallengeState, type CheckpointArgs, ControlBar, type ControlConfig, Feedback, Field, HintLadder, type Hints, LabFrame, Objectives, type PlayGate, PlayWrap, RevealSolution, type RevealSolutionProps, StepNav, type Steps, useChallenge, useCheckpoint, useHints, usePlayGate, useSteps };
+import { GuessTone, Vessel, VesselGlyph, VesselGlyphProps, VesselProps } from "./vessel.mjs";
+import { PredictPlot, PredictPlotProps } from "./predict.mjs";
+import { DotCluster, DotClusterProps } from "./cluster.mjs";
+import { Blank, FillSlot, SlotFill, SlotFillProps, SlotFillState, SlotTray, useSlotFill } from "./slot-fill.mjs";
+import { QuantityInput, QuantityScene, SceneMeta, getScene, listScenes, registerScene } from "./scenes.mjs";
+import { DataSceneSpec, dataScene, registerDataScene } from "./data-scene.mjs";
+import { SceneStudio, SceneStudioProps } from "./scene-studio.mjs";
+import { SceneLibrary, SceneLibraryManager, loadSceneLibrary, registerScenes, saveSceneLibrary, useSceneLibrary } from "./scene-library.mjs";
+export { Blank, Calc, type CalcStep, Callout, ChallengeCard, type ChallengeChoice, type ChallengeQuestion, type ChallengeState, type CheckpointArgs, type Clue, ClueBalance, ClueBar, ClueCoins, ClueReceipt, ClueScene, type ClueSceneKind, type ClueSceneMeta, ClueTiles, ControlBar, type ControlConfig, type DataSceneSpec, DotCluster, type DotClusterProps, Feedback, Field, type FillSlot, type GuessTone, HintLadder, type Hints, LabFrame, Objectives, type PlayGate, PlayWrap, PredictPlot, type PredictPlotProps, type QuantityInput, type QuantityScene, type ReceiptItem, ReceiptScene, type ReceiptSceneProps, RevealSolution, type RevealSolutionProps, RuleCard, type RuleDef, type RuleInput, RuleLab, type SceneLibrary, SceneLibraryManager, type SceneMeta, SceneStudio, type SceneStudioProps, SlotFill, type SlotFillProps, type SlotFillState, SlotTray, StepNav, type Steps, type Unknown, UnknownChip, Vessel, VesselGlyph, type VesselGlyphProps, type VesselProps, type Worked, WorkedSteps, calc, clueTotal, dataScene, getClueScene, getScene, listClueScenes, listScenes, loadSceneLibrary, registerClueScene, registerDataScene, registerScene, registerScenes, saveSceneLibrary, texNum, useChallenge, useCheckpoint, useHints, usePlayGate, useSceneLibrary, useSlotFill, useSteps };

package/dist/kit/index.mjs

@@ -1,6 +1,18 @@
 import { Callout, ControlBar, Field, LabFrame } from "./frame.mjs";
 import { ChallengeCard, Feedback, HintLadder, Objectives, RevealSolution, useChallenge, useCheckpoint, useHints } from "./pedagogy.mjs";
 import { PlayWrap, usePlayGate } from "./play.mjs";
+import { PredictPlot } from "./predict.mjs";
+import { Vessel, VesselGlyph } from "./vessel.mjs";
+import { DotCluster } from "./cluster.mjs";
+import { getScene, listScenes, registerScene } from "./scenes.mjs";
+import { Blank, SlotFill, SlotTray, useSlotFill } from "./slot-fill.mjs";
+import { Calc, calc, texNum } from "./calc.mjs";
+import { ReceiptScene } from "./receipt.mjs";
+import { ClueBalance, ClueBar, ClueCoins, ClueReceipt, ClueScene, ClueTiles, UnknownChip, clueTotal, getClueScene, listClueScenes, registerClueScene } from "./clue-scene.mjs";
+import { RuleCard, RuleLab, WorkedSteps } from "./rule.mjs";
 import { StepNav, useSteps } from "./steps.mjs";
+import { dataScene, registerDataScene } from "./data-scene.mjs";
+import { SceneStudio } from "./scene-studio.mjs";
+import { SceneLibraryManager, loadSceneLibrary, registerScenes, saveSceneLibrary, useSceneLibrary } from "./scene-library.mjs";
 
-export { Callout, ChallengeCard, ControlBar, Feedback, Field, HintLadder, LabFrame, Objectives, PlayWrap, RevealSolution, StepNav, useChallenge, useCheckpoint, useHints, usePlayGate, useSteps };
+export { Blank, Calc, Callout, ChallengeCard, ClueBalance, ClueBar, ClueCoins, ClueReceipt, ClueScene, ClueTiles, ControlBar, DotCluster, Feedback, Field, HintLadder, LabFrame, Objectives, PlayWrap, PredictPlot, ReceiptScene, RevealSolution, RuleCard, RuleLab, SceneLibraryManager, SceneStudio, SlotFill, SlotTray, StepNav, UnknownChip, Vessel, VesselGlyph, WorkedSteps, calc, clueTotal, dataScene, getClueScene, getScene, listClueScenes, listScenes, loadSceneLibrary, registerClueScene, registerDataScene, registerScene, registerScenes, saveSceneLibrary, texNum, useChallenge, useCheckpoint, useHints, usePlayGate, useSceneLibrary, useSlotFill, useSteps };