@classytic/labs 0.3.0 → 0.4.0

package/styles/domains/parts/physics-2.css

@@ -182,7 +182,11 @@
 .physics-expansion-scene {
   overflow: hidden;
   background:
-    radial-gradient(circle at 50% 42%, color-mix(in oklab, var(--stage-primary) 7%, transparent), transparent 52%),
+    radial-gradient(
+      circle at 50% 42%,
+      color-mix(in oklab, var(--stage-primary) 7%, transparent),
+      transparent 52%
+    ),
     var(--stage-bg);
 }
 .physics-expansion-scene .lab-figure {
@@ -302,19 +306,37 @@
   background: var(--stage-danger, #d65a3c);
 }
 .physics-efficiency-ledger progress {
+  /* `appearance: none` so the background below is what actually paints:
+     without it, Chrome keeps the element's native track rendering and the
+     `background`/`::-webkit-progress-bar` here are computed but never shown -
+     the coloured VALUE portion still renders regardless (Chrome respects
+     `::-webkit-progress-value` either way), so a 5% bar looked like a short
+     sliver with nothing after it.
+
+     That alone was not the whole bug. `--muted` is, by design, close to the
+     tone of the surface it sits on (the same reason `.lab-slider` no longer
+     uses it - see the comment on `[data-slot="slider-track"]`), so even with
+     the background PAINTING, a 5% bar against a near-white card was
+     `oklch(0.965)` track on an `oklch(1)` card: technically two colours,
+     visually one. The fix is the same one already applied to the slider
+     track: mix from the FOREGROUND instead of a surface token, which stays
+     visibly distinct from the card regardless of theme or host `--muted`. */
+  appearance: none;
+  -webkit-appearance: none;
+  -moz-appearance: none;
   width: 100%;
   height: 0.45rem;
   overflow: hidden;
   border: 0;
   border-radius: var(--lab-r-pill);
-  background: var(--muted, var(--stage-grid));
+  background: color-mix(in oklab, var(--stage-fg) 15%, transparent);
   accent-color: var(--stage-good, #16a34a);
 }
 .physics-efficiency-ledger progress[data-kind="waste"] {
   accent-color: var(--stage-danger, #d65a3c);
 }
 .physics-efficiency-ledger progress::-webkit-progress-bar {
-  background: var(--muted, var(--stage-grid));
+  background: color-mix(in oklab, var(--stage-fg) 15%, transparent);
 }
 .physics-efficiency-ledger progress::-webkit-progress-value {
   border-radius: var(--lab-r-pill);

package/styles/domains/parts/physics-3.css

@@ -258,29 +258,25 @@
     align-content: center;
   }
 
-  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus]
-    .lab-activity-workspace {
+  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus] .lab-activity-workspace {
     grid-template-columns: minmax(0, 2fr) minmax(18rem, 0.9fr);
     align-items: stretch;
     gap: 0;
     padding: var(--lab-sp-12) 0 0 var(--lab-sp-12);
   }
 
-  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus]
-    .lab-activity-canvas {
+  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus] .lab-activity-canvas {
     grid-column: 1;
     padding: 0 var(--lab-sp-12) var(--lab-sp-12) 0;
   }
 
-  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus]
-    .lab-activity-dock {
+  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus] .lab-activity-dock {
     grid-column: 2;
     border-top: 0;
     border-inline-start: 1px solid var(--border, var(--stage-grid));
   }
 
-  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus]
-    .lab-authored-controls {
+  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus] .lab-authored-controls {
     grid-template-columns: minmax(0, 1fr);
     align-content: center;
     height: 100%;
@@ -294,8 +290,7 @@
     grid-template-columns: minmax(0, 1fr);
   }
 
-  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus]
-    .lab-activity-inspector {
+  :is(.physics-atwood-activity, .physics-collision-activity)[data-focus] .lab-activity-inspector {
     grid-column: 1 / -1;
   }
 }
@@ -316,6 +311,43 @@
   }
 }
 
+/* The current authored step already carries the action. Repeating the catalogue description above
+   it delayed the first experiment by almost a full phone viewport. Wide/reference views retain it. */
+@container lab-activity (max-width: 30rem) {
+  :is(.physics-atwood-activity, .physics-spin-activity, .lab-dc-motor) .lab-activity-description {
+    display: none;
+  }
+
+  :is(.physics-atwood-activity, .physics-spin-activity, .lab-dc-motor) .lab-activity-header {
+    padding: var(--lab-sp-10) var(--lab-sp-12) var(--lab-sp-6);
+  }
+
+  .lab-dc-motor .lab-activity-heading h3 {
+    font-size: var(--lab-t-title);
+    line-height: var(--lab-lh-title);
+  }
+
+  .lab-dc-motor .lab-activity-canvas {
+    padding-inline: var(--lab-sp-6);
+  }
+
+  /* A 500-unit machine cannot carry eight readable labels in a 320px card. Keep pole identity and
+     live torque—the assessed evidence—and move construction detail to the inspector and alt text. */
+  .lab-dc-motor .lab-figure .fig-text {
+    display: none;
+  }
+
+  .lab-dc-motor .lab-figure :is(.dc-motor-pole-label, .dc-motor-torque-label) {
+    display: block;
+    font-size: 22px;
+  }
+
+  .physics-spin-activity .lab-figure .fig-text[data-size="eyebrow"] {
+    font-size: var(--lab-t-body);
+    letter-spacing: 0;
+  }
+}
+
 .physics-emphasis {
   color: var(--stage-fg);
   font-weight: var(--lab-w-semibold);
@@ -389,4 +421,13 @@
 /* The unavailable aim stays in the table so the comparison keeps its shape. */
 .physics-river-compare tr[data-dead] {
   opacity: 0.55;
-}
+}
+
+/* Primary scene labels for the refraction and lens investigations. A 600-unit scene shown on a
+   phone renders its labels small enough to lose, so these two carry the next step up the type
+   scale. They live with the physics rules rather than in figure.css: a named label inside one
+   domain's scene is that domain's art direction, not the shared figure vocabulary. */
+.fig-text:is(.physics-refraction-primary-label, .physics-lens-primary-label) {
+  font-size: var(--lab-t-lg);
+  font-weight: var(--lab-w-semibold);
+}

package/styles/domains/physics.css

@@ -1,7 +1,6 @@
-/* physics labs (32 KiB). Import after core.css and figure.css:
+/* physics labs (~35 KiB of rules). Import after core.css and figure.css:
      @import "@classytic/labs/styles/domains/physics.css";
-   Generated by scripts/split-domains.mjs. */
-@import "./shared.css";
+   core.css carries the rules that belong to no single subject; there is no shared.css to add. */
 @import "./parts/physics-1.css";
 @import "./parts/physics-2.css";
 @import "./parts/physics-3.css";

package/styles/domains/probability.css

@@ -1,7 +1,6 @@
-/* probability labs (14 KiB). Import after core.css and figure.css:
+/* probability labs (~14 KiB of rules). Import after core.css and figure.css:
      @import "@classytic/labs/styles/domains/probability.css";
-   Generated by scripts/split-domains.mjs. */
-@import "./shared.css";
+   core.css carries the rules that belong to no single subject; there is no shared.css to add. */
 @import "./parts/probability-1.css";
 @import "./parts/probability-2.css";
 @import "./parts/probability-3.css";

package/styles/domains/statistics.css

@@ -1,5 +1,4 @@
-/* statistics labs (6 KiB). Import after core.css and figure.css:
+/* statistics labs (~6 KiB of rules). Import after core.css and figure.css:
      @import "@classytic/labs/styles/domains/statistics.css";
-   Generated by scripts/split-domains.mjs. */
-@import "./shared.css";
+   core.css carries the rules that belong to no single subject; there is no shared.css to add. */
 @import "./parts/statistics.css";

package/styles/domains.css

@@ -13,9 +13,10 @@
    Generated by scripts/split-domains.mjs; edit the sheets, not this list.
    ───────────────────────────────────────────────────────────────────────────── */
 
+@import "./domains/parts/algorithms-0.css";
+@import "./domains/parts/networking.css";
 @import "./domains/parts/physics-1.css";
 @import "./domains/parts/math-1.css";
-@import "./domains/parts/shared-1.css";
 @import "./domains/parts/math-2.css";
 @import "./domains/parts/physics-2.css";
 @import "./domains/parts/algorithms-1.css";
@@ -23,7 +24,6 @@
 @import "./domains/parts/editor.css";
 @import "./domains/parts/logic-1.css";
 @import "./domains/parts/algorithms-2.css";
-@import "./domains/parts/shared-2.css";
 @import "./domains/parts/math-3.css";
 @import "./domains/parts/discrete-1.css";
 @import "./domains/parts/physics-3.css";

package/styles/figure.css

@@ -13,7 +13,20 @@
      bold 3.5    the one emphasised path in a figure
    ───────────────────────────────────────────────────────────────────────────── */
 
-.lab-figure {
+/* The tokens bind on BOTH rendering models.
+
+   They used to live on `.lab-figure` alone, which quietly made the figure palette unusable
+   outside a `<Figure>`: `HUE.metal` resolves to `--fig-metal`, so any scene drawn on a `<Stage>`
+   had to pick `--stage-*` directly and opted out of the roles, the domain palette and every
+   `tint`/`shade` helper. That is the "two parallel colour vocabularies" split, and it is why the
+   shared balance apparatus, the annotation helpers and the concrete-twin scenes could not
+   converge without first being rewritten into a different rendering model.
+
+   Binding the same tokens on `stage-root` costs nothing (custom properties only declare; nothing
+   reads them there yet) and lets a Stage-based scene speak the figure language today. Layout
+   rules stay on `.lab-figure`, below, because only the figure IS the svg. */
+.lab-figure,
+.stage-root {
   /* strokes */
   --fig-hair: 1;
   --fig-line: 1.75;
@@ -77,6 +90,34 @@
   --fig-device-edge: oklch(0.3 0.012 260);
   --fig-cavity: oklch(0.22 0.01 260);
 
+  /* OBSERVED colours: pinned, for the same reason the device ladder is pinned.
+     A white precipitate is not a semantic role, it is a reading a learner takes off the tube, and
+     qualitative analysis tells silver chloride from silver bromide from silver iodide by nothing
+     else. Every other pale option in this file is mixed toward --fig-paper, which is the page
+     background and therefore DARK in dark mode: "white precipitate" drawn that way disappears in
+     one theme, and the lesson loses its evidence. These three keep their lightness so the
+     observation survives the theme, and they stay in the same order as the real solids. */
+  --fig-solid-white: oklch(0.94 0.006 260);
+  --fig-solid-cream: oklch(0.91 0.045 88);
+  --fig-solid-yellow: oklch(0.84 0.14 96);
+  /* Manganate(VII) purple. `shade(hue-1, 80)` was reached for first and came out NAVY, because
+     hue-1 is the blue-violet accent: there is no magenta in the semantic palette at all. The
+     purple-to-colourless change is the whole sulfite and sulfur-dioxide observation, so it gets a
+     pinned hue like the solids rather than the nearest blue. */
+  --fig-solid-purple: oklch(0.47 0.2 322);
+  --fig-solid-dark: oklch(0.4 0.016 285);
+  /* Pinned endpoints for shading a pinned colour.
+     `material()` builds its ramp with `tint()`, which mixes toward --fig-paper. Run a pinned
+     observation colour through it and the inversion comes straight back: tint(white, 26) is 26%
+     white over a near-black page, so the "lit" face lands DARKER than the body and a white
+     precipitate read as grey mountains. An observed solid is shaded against these two fixed
+     neutrals instead, so its ramp holds its order in both themes. */
+  --fig-obs-dark: oklch(0.32 0.02 260);
+  --fig-obs-lit: oklch(0.98 0.005 260);
+}
+
+/* Layout: only the figure is itself the <svg>. */
+.lab-figure {
   display: block;
   width: 100%;
   height: auto;
@@ -114,6 +155,11 @@
   --fig-hue-2: var(--stage-cat-7);
   --fig-hue-3: var(--stage-cat-3);
 }
+.lab-figure[data-fig-domain="computing"] {
+  --fig-hue-1: var(--stage-accent);
+  --fig-hue-2: var(--stage-cat-5);
+  --fig-hue-3: var(--stage-cat-7);
+}
 
 /* Type. Sizes are user units; the figure's viewBox decides the on-screen size
    (rule: ≥ 12 px on screen at the narrowest layout the figure renders in).
@@ -148,12 +194,18 @@
   letter-spacing: var(--lab-ls-caps);
   text-transform: uppercase;
 }
+/* Keep the written case. See FigText's `caps` prop: the uppercase transform rewrites content the
+   author did not write, and case carries meaning in a chemical symbol or an orbital name. */
+.fig-text[data-caps="false"] {
+  text-transform: none;
+}
 .fig-text[data-tone="soft"] {
   fill: var(--fig-ink-soft);
 }
 .fig-text[data-tone="hue-1"] {
   fill: color-mix(in oklab, var(--fig-hue-1) 78%, var(--fig-ink));
 }
+
 .fig-text[data-tone="hue-2"] {
   fill: color-mix(in oklab, var(--fig-hue-2) 78%, var(--fig-ink));
 }
@@ -163,6 +215,9 @@
 .fig-text[data-tone="hot"] {
   fill: color-mix(in oklab, var(--fig-hot) 82%, var(--fig-ink));
 }
+.fig-text[data-tone="warn"] {
+  fill: color-mix(in oklab, var(--fig-warn) 82%, var(--fig-ink));
+}
 .fig-text[data-tone="good"] {
   fill: color-mix(in oklab, var(--fig-good) 82%, var(--fig-ink));
 }
@@ -173,7 +228,23 @@
 .fig-text[data-halo="false"] {
   stroke: none;
 }
-
+.fig-action {
+  cursor: pointer;
+  outline: none;
+  touch-action: manipulation;
+  transition:
+    filter var(--lab-dur-fast) var(--lab-ease),
+    opacity var(--lab-dur-fast) var(--lab-ease);
+}
+.fig-action:hover,
+.fig-action:focus-visible,
+.fig-action[data-selected] {
+  filter: brightness(1.08);
+}
+.fig-action:focus-visible {
+  outline: 2px solid var(--ring, var(--stage-accent));
+  outline-offset: 2px;
+}
 /* Motion: figure primitives animate geometry through CSS transitions so a
    changed value glides instead of jumping; reduced motion snaps. */
 .fig-ease {
@@ -232,16 +303,71 @@
    signals are covered, the OS preference and an explicit choice, matching the
    illustration rules below. */
 @media (prefers-color-scheme: dark) {
-  :root:not([data-theme="light"]):not(.light) .lab-figure {
+  :root:not([data-theme="light"]):not(.light) :is(.lab-figure, .stage-root) {
     --fig-device: oklch(0.46 0.012 260);
     --fig-device-soft: oklch(0.56 0.012 260);
     --fig-device-edge: oklch(0.34 0.012 260);
     --fig-cavity: oklch(0.16 0.01 260);
+    /* Dimmed a touch so a white solid is not the brightest thing on a dark page, but still
+       unmistakably pale. The ORDER white > cream > yellow is what carries the diagnosis. */
+    --fig-solid-white: oklch(0.9 0.006 260);
+    --fig-solid-cream: oklch(0.87 0.05 88);
+    --fig-solid-yellow: oklch(0.81 0.15 96);
+    --fig-solid-purple: oklch(0.56 0.21 322);
+    --fig-solid-dark: oklch(0.46 0.016 285);
+    --fig-solid-dark: oklch(0.46 0.016 285);
   }
 }
-:root:is([data-theme="dark"], .dark) .lab-figure {
+:root:is([data-theme="dark"], .dark) :is(.lab-figure, .stage-root) {
   --fig-device: oklch(0.46 0.012 260);
   --fig-device-soft: oklch(0.56 0.012 260);
   --fig-device-edge: oklch(0.34 0.012 260);
   --fig-cavity: oklch(0.16 0.01 260);
+  --fig-solid-white: oklch(0.9 0.006 260);
+  --fig-solid-cream: oklch(0.87 0.05 88);
+  --fig-solid-yellow: oklch(0.81 0.15 96);
+  --fig-solid-purple: oklch(0.56 0.21 322);
+}
+/* Explanatory state motion: short, composited, and local to the newest datum. */
+.lab-figure-arrive {
+  transform-box: fill-box;
+  transform-origin: center;
+  animation: lab-figure-arrive var(--lab-dur-slow) var(--lab-ease) both;
+}
+
+.lab-figure-activate {
+  transform-box: fill-box;
+  transform-origin: center;
+  animation: lab-figure-activate var(--lab-dur-base) var(--lab-ease) both;
+}
+
+@keyframes lab-figure-arrive {
+  from {
+    opacity: 0;
+    transform: translateY(-70%) scale(0.94);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes lab-figure-activate {
+  from {
+    opacity: 0.55;
+    transform: scale(0.94);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes lab-figure-fade {
+  from {
+    opacity: 0.65;
+  }
+  to {
+    opacity: 1;
+  }
 }

package/dist/kit/answer-check.d.mts

@@ -1,38 +0,0 @@
-//#region src/kit/answer-check.d.ts
-/**
- * answer-check, the "is the student right?" layer of the interactive-problem
- * engine. Pure, built on @classytic/stage's expr engine. Two real modes (the ones
- * exams need): a NUMBER (value within tolerance, parsed so `pi/2` or `2*sqrt(5)`
- * count) and an EXPRESSION (any algebraically-EQUIVALENT form accepted, checked
- * BOTH symbolically, simplify(student − answer) → 0, AND numerically by sampling,
- * so `(x+1)(x+2)` ≡ `x^2+3x+2`). No hand-marking, no "exact-string" brittleness.
- */
-/** Evaluate a numeric answer string (`3.14`, `pi/2`, `2*sqrt(5)`) → number (NaN if invalid). */
-declare function parseValue(raw: string): number;
-/** Numeric match with a relative-ish tolerance (default ~1% of scale). */
-declare function checkNumber(student: number, value: number, tol?: number): boolean;
-interface ExprCheckOpts {
-  /** Variables to sample (defaults to the union of both sides' free vars). */
-  vars?: string[];
-  /** Sampling domain for the numeric pass. */
-  domain?: [number, number];
-  tol?: number;
-  samples?: number;
-}
-/** True if `student` is algebraically equivalent to `answer` (symbolic OR numeric). */
-declare function checkExpression(student: string, answer: string, opts?: ExprCheckOpts): boolean;
-type AnswerSpec = {
-  kind: 'number';
-  value: number;
-  tol?: number;
-} | {
-  kind: 'expression';
-  value: string;
-  vars?: string[];
-  domain?: [number, number];
-  tol?: number;
-};
-/** Check a raw student string against an authored answer spec. */
-declare function checkAnswer(spec: AnswerSpec, raw: string): boolean;
-//#endregion
-export { AnswerSpec, ExprCheckOpts, checkAnswer, checkExpression, checkNumber, parseValue };

package/dist/kit/answer-check.mjs

@@ -1,93 +0,0 @@
-import { compileExpr, parseExpr, simplify } from "@classytic/stage";
-
-//#region src/kit/answer-check.ts
-/**
-* answer-check, the "is the student right?" layer of the interactive-problem
-* engine. Pure, built on @classytic/stage's expr engine. Two real modes (the ones
-* exams need): a NUMBER (value within tolerance, parsed so `pi/2` or `2*sqrt(5)`
-* count) and an EXPRESSION (any algebraically-EQUIVALENT form accepted, checked
-* BOTH symbolically, simplify(student − answer) → 0, AND numerically by sampling,
-* so `(x+1)(x+2)` ≡ `x^2+3x+2`). No hand-marking, no "exact-string" brittleness.
-*/
-/** Compile, returning the usable form or null (never the error union). */
-function tryCompile(src) {
-	const c = compileExpr(src);
-	if (c.error !== void 0) return null;
-	return c;
-}
-/** Evaluate a numeric answer string (`3.14`, `pi/2`, `2*sqrt(5)`) → number (NaN if invalid). */
-function parseValue(raw) {
-	const c = tryCompile(normalizeMathInput(raw));
-	return c ? c.fn({}) : NaN;
-}
-/**
-* Make exam-natural input parse: accept implicit multiplication (`2x` → `2*x`,
-* `)(` → `)*(`) and a leading `y =` (`y = 2x − 3` → `2*x - 3`). Conservative ,
-* never inserts `*` before `(` after a letter, so function calls like `sin(x)`
-* survive. Unicode minus → ascii.
-*/
-const SUPERSCRIPT = {
-	"⁰": "0",
-	"¹": "1",
-	"²": "2",
-	"³": "3",
-	"⁴": "4",
-	"⁵": "5",
-	"⁶": "6",
-	"⁷": "7",
-	"⁸": "8",
-	"⁹": "9"
-};
-function normalizeMathInput(raw) {
-	let s = raw.trim().replace(/−/g, "-").replace(/×/g, "*").replace(/÷/g, "/");
-	s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹]+/g, (m) => "^" + [...m].map((ch) => SUPERSCRIPT[ch]).join(""));
-	s = s.replace(/\*\*/g, "^");
-	s = s.replace(/\s+/g, "");
-	s = s.replace(/^y=/i, "");
-	s = s.replace(/(\d)(?![eE][+-]?\d)([a-zA-Z(])/g, "$1*$2");
-	s = s.replace(/\)([a-zA-Z0-9(])/g, ")*$1");
-	return s;
-}
-/** Numeric match with a relative-ish tolerance (default ~1% of scale). */
-function checkNumber(student, value, tol = .01) {
-	if (!Number.isFinite(student) || !Number.isFinite(value)) return false;
-	return Math.abs(student - value) <= tol * Math.max(1, Math.abs(value));
-}
-const isZeroNode = (n, eps = 1e-9) => n.type === "num" && Math.abs(n.value) < eps;
-/** True if `student` is algebraically equivalent to `answer` (symbolic OR numeric). */
-function checkExpression(student, answer, opts = {}) {
-	const a = tryCompile(normalizeMathInput(student));
-	const b = tryCompile(normalizeMathInput(answer));
-	if (!a || !b) return false;
-	try {
-		if (isZeroNode(simplify(parseExpr(`(${normalizeMathInput(student)}) - (${normalizeMathInput(answer)})`)), opts.tol ?? 1e-9)) return true;
-	} catch {}
-	const vars = opts.vars ?? [...new Set([...a.vars, ...b.vars])];
-	const [lo, hi] = opts.domain ?? [-3.3, 3.7];
-	const tol = opts.tol ?? 1e-6;
-	const samples = opts.samples ?? 32;
-	const PHI = .6180339887498949;
-	const R2 = .4142135623730951;
-	let finite = 0;
-	for (let i = 0; i < samples; i++) {
-		const scope = {};
-		vars.forEach((v, j) => {
-			scope[v] = lo + (hi - lo) * (((i + 1) * PHI + (j + 1) * R2) % 1);
-		});
-		const ya = a.fn(scope);
-		const yb = b.fn(scope);
-		if (!Number.isFinite(ya) || !Number.isFinite(yb)) continue;
-		finite++;
-		if (Math.abs(ya - yb) > tol * Math.max(1, Math.abs(ya), Math.abs(yb))) return false;
-	}
-	return finite >= 5;
-}
-/** Check a raw student string against an authored answer spec. */
-function checkAnswer(spec, raw) {
-	if (!raw || !raw.trim()) return false;
-	if (spec.kind === "number") return checkNumber(parseValue(raw), spec.value, spec.tol);
-	return checkExpression(raw, spec.value, spec);
-}
-
-//#endregion
-export { checkAnswer, checkExpression, checkNumber, normalizeMathInput, parseValue };

package/dist/kit/calc.d.mts

@@ -1,33 +0,0 @@
-//#region src/kit/calc.d.ts
-/**
- * Worked-calculation core. A lab that just prints an answer teaches nothing; this
- * makes a calculation SHOW ITS WORKING — every substitution and simplification as
- * a rendered line — so an author can demonstrate HOW a rule computes, not just
- * what it returns. Pure + dependency-free: the engine produces data (a value plus
- * a list of LaTeX steps); a component renders it.
- *
- * Pair with kit/rule's <RuleCard> (formula + analogy + this calculation +
- * derivation + tricks) to turn a bare formula into a smart, authorable concept.
- */
-/** One line of a worked calculation: a LaTeX expression + an optional plain note. */
-interface CalcStep {
-  tex: string;
-  /** Why this step follows ("substitute n = 5", "the falling product"). */
-  note?: string;
-}
-/** The result of a worked calculation: the final value + the steps that got there. */
-interface Worked {
-  value: number;
-  steps: CalcStep[];
-}
-/** A tiny fluent builder: calc().step('…','…').step('…').done(value). */
-declare class Calc {
-  private readonly _steps;
-  step(tex: string, note?: string): this;
-  done(value: number): Worked;
-}
-declare const calc: () => Calc;
-/** Format a number for inline LaTeX (thin-space thousands so big counts read). */
-declare function texNum(n: number): string;
-//#endregion
-export { Calc, CalcStep, Worked, calc, texNum };

package/dist/kit/calc.mjs

@@ -1,27 +0,0 @@
-//#region src/kit/calc.ts
-/** A tiny fluent builder: calc().step('…','…').step('…').done(value). */
-var Calc = class {
-	_steps = [];
-	step(tex, note) {
-		this._steps.push(note === void 0 ? { tex } : {
-			tex,
-			note
-		});
-		return this;
-	}
-	done(value) {
-		return {
-			value,
-			steps: this._steps
-		};
-	}
-};
-const calc = () => new Calc();
-/** Format a number for inline LaTeX (thin-space thousands so big counts read). */
-function texNum(n) {
-	if (!Number.isFinite(n)) return "\\text{?}";
-	return Math.abs(n) >= 1e4 ? n.toLocaleString("en-US").replace(/,/g, "{,}") : String(n);
-}
-
-//#endregion
-export { Calc, calc, texNum };

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

@@ -1,49 +0,0 @@
-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$1 {
-  m: number;
-  c: number;
-  at: {
-    x: number;
-    y: number;
-  };
-  f: Fn1;
-}
-/**
- * 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;
-}): number[];
-/** Points where f and g meet on [a,b]. */
-declare function intersections(f: Fn1, g: Fn1, a: number, b: number, opts?: {
-  steps?: number;
-  tol?: number;
-}): {
-  x: number;
-  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$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$1 | null;
-/** Composite-Simpson definite integral ∫_a^b f dx. */
-declare function integrate(f: Fn1, a: number, b: number, n?: number): number;
-/**
- * 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$1 as Line, areaBetween, integrate, intersections, normalAt, roots, tangentAt };