@classytic/labs 0.1.0 → 0.2.0

package/dist/circuits/transistor/index.d.mts

@@ -0,0 +1 @@
+import { TransistorLab, TransistorProps } from "./preset.mjs";

package/dist/circuits/transistor/preset.d.mts

@@ -0,0 +1,27 @@
+import { LabAskSpec } from "../../kit/ask.mjs";
+import { ReactNode } from "react";
+
+//#region src/circuits/transistor/preset.d.ts
+interface TransistorProps {
+  supply?: number;
+  vth?: number;
+  loadK?: number;
+  /** which panels to show: the schematic, the transfer graph, or both (default). */
+  show?: 'both' | 'circuit' | 'graph';
+  title?: string;
+  prompt?: string;
+  ask?: LabAskSpec;
+  activity?: string;
+}
+declare function TransistorLab({
+  supply,
+  vth,
+  loadK,
+  show,
+  title,
+  prompt,
+  ask,
+  activity
+}?: TransistorProps): ReactNode;
+//#endregion
+export { TransistorLab, TransistorProps };

package/dist/circuits/transistor/preset.mjs

@@ -0,0 +1,329 @@
+'use client';
+
+import { Slider } from "../../kit/controls.mjs";
+import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { ChallengeCard, useChallenge, useCheckpoint } from "../../kit/pedagogy.mjs";
+import { BulbGlyph, CellGlyph, FlowDots, MosfetGlyph, Tag, Wire } from "../../kit/electronics.mjs";
+import { useReducedMotion } from "../../kit/anim.mjs";
+import { LabAsk } from "../../kit/ask.mjs";
+import { CoordPlane } from "../../kit/coords.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, Polyline, Segment, useFrameLoop } from "@classytic/stage";
+import { solveDC } from "@classytic/stage/circuit";
+
+//#region src/circuits/transistor/preset.tsx
+/**
+* TransistorLab — an NMOS as the thing that lets a tiny input steer a big current.
+* Drawn with the shared electronics glyphs (CellGlyph / BulbGlyph / MosfetGlyph) on
+* a real schematic: a supply lights a lamp through the transistor, and the GATE
+* voltage decides whether the channel conducts. Below the threshold the lamp is
+* dark; past it the gate opens a much larger drain current and the lamp glows. The
+* transfer curve and operating point are swept straight from the circuit engine.
+*/
+const PREDICT_Q = [{
+	id: "on",
+	prompt: "A MOSFET conducts only when the gate voltage exceeds its threshold Vₜₕ. With the gate held BELOW Vₜₕ, is the transistor ON or OFF?",
+	choices: [{
+		value: "on",
+		label: "ON (lamp lit, drain current flows)"
+	}, {
+		value: "off",
+		label: "OFF (lamp dark, no drain current)"
+	}],
+	answer: "off",
+	explain: "Below threshold the channel never forms, so no drain current flows and the lamp stays dark. The transistor only turns ON once the gate climbs past Vₜₕ, opening a much larger drain current."
+}];
+const K = .02;
+const C_OK = "var(--stage-good)";
+const C_BAD = "var(--stage-danger, #e03131)";
+const W = 520, H = 210, xL = 55, xR = 430, yT = 48, yB = 172, HALF = 28;
+const CELL_X = 120, LAMP_X = 250;
+const MCX = xR - 9, MCY = 220 / 2, MHALF = (yB - yT) / 2;
+const GATE_TERM = MCX - 13 - 24;
+const LOOP = [
+	[xL, yT],
+	[xR, yT],
+	[xR, yB],
+	[xL, yB],
+	[xL, yT]
+];
+function TransistorLab({ supply = 5, vth = 2, loadK = 1, show = "both", title = "The transistor: a small input controls a big current", prompt = "Turn the gate voltage. Below the threshold the channel is shut and the lamp is dark; past it, the gate opens a much larger drain current.", ask, activity = "transistor" } = {}) {
+	const [Vg, setVg] = useState(3);
+	const [Rk, setRk] = useState(loadK);
+	const [phase, setPhase] = useState(0);
+	const reduce = useReducedMotion();
+	const ch = useChallenge(PREDICT_Q);
+	useCheckpoint({
+		solved: ch.allCorrect,
+		activity: `${activity}:predict`
+	});
+	const R = Rk * 1e3;
+	const mk = (vg) => [
+		{
+			kind: "V",
+			n1: 1,
+			n2: 0,
+			value: supply
+		},
+		{
+			kind: "V",
+			n1: 3,
+			n2: 0,
+			value: vg
+		},
+		{
+			kind: "R",
+			n1: 1,
+			n2: 2,
+			value: R,
+			id: "load"
+		},
+		{
+			kind: "M",
+			n1: 2,
+			n2: 0,
+			n3: 3,
+			value: 0,
+			vth,
+			k: K,
+			id: "q"
+		}
+	];
+	const sol = solveDC(mk(Vg));
+	const Id = (sol.current["q"] ?? 0) * 1e3;
+	const Vdrain = sol.nodeV[2] ?? 0;
+	const maxId = supply / R * 1e3;
+	const on = Id > .05;
+	const brightness = Math.max(0, Math.min(1, Id / maxId));
+	useFrameLoop((f) => setPhase((p) => (p + f.dtMs / 1e3 * (.1 + .4 * brightness)) % 1), { running: on && !reduce });
+	const scene = /* @__PURE__ */ jsx("div", {
+		style: {
+			borderRadius: 14,
+			overflow: "hidden",
+			background: "var(--stage-bg)",
+			border: "1px solid var(--stage-grid)"
+		},
+		children: /* @__PURE__ */ jsxs("svg", {
+			viewBox: `0 0 ${W} ${H}`,
+			width: "100%",
+			role: "img",
+			"aria-label": `NMOS circuit, ${on ? "on, lamp lit" : "off, lamp dark"}`,
+			children: [
+				/* @__PURE__ */ jsx(Wire, {
+					points: LOOP,
+					live: on
+				}),
+				on && /* @__PURE__ */ jsx(FlowDots, {
+					points: LOOP,
+					phase
+				}),
+				/* @__PURE__ */ jsx(CellGlyph, {
+					cx: CELL_X,
+					cy: yT,
+					half: HALF,
+					live: on,
+					label: `${supply} V`
+				}),
+				/* @__PURE__ */ jsx(BulbGlyph, {
+					cx: LAMP_X,
+					cy: yT,
+					half: HALF,
+					live: on,
+					brightness,
+					label: "lamp"
+				}),
+				/* @__PURE__ */ jsx(MosfetGlyph, {
+					cx: MCX,
+					cy: MCY,
+					half: MHALF,
+					on,
+					live: on
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: GATE_TERM - 48,
+					y1: MCY,
+					x2: GATE_TERM,
+					y2: MCY,
+					stroke: "var(--stage-wire)",
+					strokeWidth: 2.5,
+					strokeLinecap: "round"
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: GATE_TERM - 48,
+					cy: MCY,
+					r: 3,
+					fill: "var(--stage-metal)"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: GATE_TERM - 52,
+					y: MCY - 8,
+					text: "gate",
+					color: "var(--stage-fg)",
+					size: 11,
+					weight: 600,
+					anchor: "end"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: GATE_TERM - 52,
+					y: 124,
+					text: `${Vg.toFixed(1)} V`,
+					color: on ? C_OK : C_BAD,
+					size: 11,
+					weight: 700,
+					anchor: "end"
+				})
+			]
+		})
+	});
+	const pts = [];
+	for (let vg = 0; vg <= 5.0001; vg += .1) pts.push({
+		x: vg,
+		y: (solveDC(mk(vg)).current["q"] ?? 0) * 1e3
+	});
+	const gview = {
+		xMin: 0,
+		xMax: 5,
+		yMin: 0,
+		yMax: Math.max(2, Math.ceil(maxId * 1.1))
+	};
+	const graph = /* @__PURE__ */ jsxs(CoordPlane, {
+		view: gview,
+		height: 150,
+		preserveAspect: false,
+		step: 1,
+		ariaLabel: "NMOS transfer curve",
+		children: [
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: vth,
+					y: 0
+				},
+				to: {
+					x: vth,
+					y: gview.yMax
+				},
+				color: "var(--stage-muted)",
+				weight: 1,
+				dashed: true
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: vth,
+				y: gview.yMax,
+				text: `Vₜₕ = ${vth} V`,
+				color: "var(--stage-muted)",
+				size: 10,
+				dy: -4,
+				dx: 4,
+				anchor: "start"
+			}),
+			/* @__PURE__ */ jsx(Polyline, {
+				points: pts,
+				color: "var(--stage-accent)",
+				weight: 2.5
+			}),
+			/* @__PURE__ */ jsx(Dot, {
+				x: Vg,
+				y: Math.max(0, Math.min(gview.yMax, Id)),
+				r: 5,
+				color: on ? C_OK : C_BAD
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 5,
+				y: gview.yMax * .95,
+				text: "drain current (mA) vs gate (V)",
+				color: "var(--stage-muted)",
+				size: 10,
+				anchor: "end"
+			})
+		]
+	});
+	const figure = show === "circuit" ? scene : show === "graph" ? graph : /* @__PURE__ */ jsxs("div", {
+		style: {
+			display: "flex",
+			flexDirection: "column",
+			gap: 10
+		},
+		children: [scene, graph]
+	});
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [/* @__PURE__ */ jsx(Field, {
+			label: "gate voltage",
+			value: `${Vg.toFixed(1)} V`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: Vg,
+				min: 0,
+				max: 5,
+				step: .1,
+				onChange: setVg,
+				ariaLabel: "gate voltage"
+			})
+		}), /* @__PURE__ */ jsx(Field, {
+			label: "load R",
+			value: `${Rk.toFixed(1)} kΩ`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: Rk,
+				min: .5,
+				max: 5,
+				step: .1,
+				onChange: setRk,
+				ariaLabel: "load resistance"
+			})
+		})] }),
+		aside: /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				gap: 10
+			},
+			children: [/* @__PURE__ */ jsx("div", {
+				className: "lab-pill",
+				"data-state": on ? "ok" : "no",
+				role: "status",
+				style: { alignSelf: "flex-start" },
+				children: on ? `✓ ON, lamp ${Math.round(brightness * 100)}% bright` : "✗ OFF, gate below threshold, lamp dark"
+			}), /* @__PURE__ */ jsx(Callout, {
+				tone: "result",
+				children: /* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "grid",
+						gap: 6,
+						fontVariantNumeric: "tabular-nums",
+						fontSize: 13
+					},
+					children: [
+						/* @__PURE__ */ jsxs("span", { children: [
+							"gate V",
+							/* @__PURE__ */ jsx("sub", { children: "gs" }),
+							" = ",
+							/* @__PURE__ */ jsxs("strong", { children: [Vg.toFixed(1), " V"] }),
+							" (threshold ",
+							vth,
+							" V)"
+						] }),
+						/* @__PURE__ */ jsxs("span", { children: ["drain current = ", /* @__PURE__ */ jsx("strong", { children: Math.abs(Id) < .001 ? "≈ 0" : Id.toFixed(2) + " mA" })] }),
+						/* @__PURE__ */ jsxs("span", { children: ["drain voltage = ", /* @__PURE__ */ jsxs("strong", { children: [Vdrain.toFixed(2), " V"] })] }),
+						/* @__PURE__ */ jsx("span", {
+							style: { color: "var(--stage-muted)" },
+							children: "a small gate voltage steers a much larger drain current, switch or amplifier"
+						})
+					]
+				})
+			})]
+		}),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ChallengeCard, {
+			questions: PREDICT_Q,
+			state: ch,
+			title: "Predict first"
+		}), ask ? /* @__PURE__ */ jsx(LabAsk, {
+			ask,
+			activity
+		}) : null] }),
+		children: figure
+	});
+}
+
+//#endregion
+export { TransistorLab };

package/dist/commerce/accounting/core.d.mts

@@ -1,6 +1,6 @@
 //#region src/commerce/accounting/core.d.ts
 /**
- * The SIMPLE, CORRECT double-entry core — the single source of truth every
+ * The SIMPLE, CORRECT double-entry core, the single source of truth every
  * accounting lab shares. Deliberately NOT the industry @classytic/ledger engine
  * (events/repositories/FX/fiscal-close): a teaching lab needs only the rules,
  * which are these (verified against that production ledger):

package/dist/commerce/accounting/equation-balance.mjs

@@ -12,17 +12,17 @@ import { Circle, Label, Segment, Stage, StageAssetDefs } from "@classytic/stage"
 
 //#region src/commerce/accounting/equation-balance.tsx
 /**
-* EquationBalanceLab — the balance sheet that must stay LEVEL.
+* EquationBalanceLab, the balance sheet that must stay LEVEL.
 *
 * Apply each authored transaction one at a time; weights slide onto a two-pan
-* scale (left = Assets, right = Liabilities + Equity) and the beam re-levels —
+* scale (left = Assets, right = Liabilities + Equity) and the beam re-levels , 
 * because every balanced entry changes both sides equally, "Assets = Liabilities
 * + Equity" stops being a formula and becomes a felt constraint. A free-post mode
 * lets the learner nudge ONE side and watch the books visibly tip (the #1
 * misconception drill). Reuses the shared ScaleFrame; tokenized; reduced-motion safe.
 *
 * The A = L + E rearrangement (Equity = Assets − Liabilities) belongs in a paired
-* MathDerivation — this lab only makes the constraint felt.
+* MathDerivation, this lab only makes the constraint felt.
 */
 const DEMO_ACCOUNTS = [
 	{
@@ -92,7 +92,7 @@ const PIVOT = {
 	y: 1.2
 };
 const HB = 4.2, PAN_HANG = 1.35, PAN_R = 1.75, BASE_Y = -3.6;
-function EquationBalanceLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS, freePost = false, start = 0, title = "The balance sheet that must stay level", prompt = "Apply each transaction — Assets must always equal Liabilities + Equity.", height = 320, objectives }) {
+function EquationBalanceLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS, freePost = false, start = 0, title = "The balance sheet that must stay level", prompt = "Apply each transaction, Assets must always equal Liabilities + Equity.", height = 320, objectives }) {
 	const [applied, setApplied] = useState(clamp(start, 0, transactions.length));
 	const [extraA, setExtraA] = useState(0);
 	const [extraLE, setExtraLE] = useState(0);
@@ -282,7 +282,7 @@ function EquationBalanceLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS
 		})] }),
 		footer: /* @__PURE__ */ jsx(StatusPill, {
 			ok: balanced,
-			children: balanced ? "Books balance ✓" : `Off by ${money(Math.abs(imbalance))} — not balanced`
+			children: balanced ? "Books balance ✓" : `Off by ${money(Math.abs(imbalance))}, not balanced`
 		}),
 		children: figure
 	});

package/dist/commerce/accounting/journal-poster.mjs

@@ -10,16 +10,16 @@ import { useLearner } from "@classytic/stage";
 
 //#region src/commerce/accounting/journal-poster.tsx
 /**
-* JournalPosterLab — post the entry, fill the T-accounts, balance the trial.
+* JournalPosterLab, post the entry, fill the T-accounts, balance the trial.
 *
 * For each authored business event the learner picks the DEBIT account (left) and
 * the CREDIT account (right) from the chart of accounts. On Post the lab gives
 * INSTANT feedback: a correct entry drops into the matching T-accounts' left/right
-* columns (green); a wrong pick is coached with the reason ("Cash is an Asset — it
+* columns (green); a wrong pick is coached with the reason ("Cash is an Asset, it
 * increases with a DEBIT, the left side") instead of just "wrong". A live trial
 * balance sums ΣDebit vs ΣCredit and only reads level when they match.
 *
-* Reuses the shared accounting core (normalBalance / debit=credit) — no ledger dep.
+* Reuses the shared accounting core (normalBalance / debit=credit), no ledger dep.
 * The DEALER mnemonic + trial-balance traps belong in a paired MathDerivation.
 */
 const DEMO_ACCOUNTS = [
@@ -91,7 +91,7 @@ const DEMO_TXNS = [
 		amount: 800
 	}
 ];
-function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS, showTrialBalance = true, title = "Post the entry — fill the T-accounts", prompt = "Choose the debit (left) and credit (right) account for each event.", objectives }) {
+function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS, showTrialBalance = true, title = "Post the entry: fill the T-accounts", prompt = "Choose the debit (left) and credit (right) account for each event.", objectives }) {
 	const [idx, setIdx] = useState(0);
 	const [debitId, setDebitId] = useState(null);
 	const [creditId, setCreditId] = useState(null);
@@ -107,7 +107,7 @@ function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS,
 		const c = catOf(id);
 		if (!c) return "";
 		const article = /^[AEIOU]/.test(c) ? "an" : "a";
-		return `${nameOf(id)} is ${article} ${c} — it increases with a ${normalBalance(c).toUpperCase()} (${normalBalance(c) === "debit" ? "left" : "right"}).`;
+		return `${nameOf(id)} is ${article} ${c}, it increases with a ${normalBalance(c).toUpperCase()} (${normalBalance(c) === "debit" ? "left" : "right"}).`;
 	};
 	const txn = transactions[idx];
 	const allDone = idx >= transactions.length;
@@ -228,7 +228,7 @@ function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS,
 						color: "var(--stage-good)",
 						margin: 0
 					},
-					children: "All entries posted ✓ — the trial balance is level."
+					children: "All entries posted ✓, the trial balance is level."
 				}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
 					/* @__PURE__ */ jsxs("p", {
 						style: {
@@ -277,7 +277,7 @@ function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS,
 								border: "1px dashed var(--stage-grid)",
 								background: debitId ? "color-mix(in oklab, var(--stage-accent) 14%, transparent)" : "transparent"
 							},
-							children: ["DEBIT (left): ", /* @__PURE__ */ jsx("b", { children: debitId ? nameOf(debitId) : "—" })]
+							children: ["DEBIT (left): ", /* @__PURE__ */ jsx("b", { children: debitId ? nameOf(debitId) : ", " })]
 						}), /* @__PURE__ */ jsxs("span", {
 							style: {
 								flex: 1,
@@ -286,7 +286,7 @@ function JournalPosterLab({ accounts = DEMO_ACCOUNTS, transactions = DEMO_TXNS,
 								border: "1px dashed var(--stage-grid)",
 								background: creditId ? "color-mix(in oklab, var(--stage-accent-2) 14%, transparent)" : "transparent"
 							},
-							children: ["CREDIT (right): ", /* @__PURE__ */ jsx("b", { children: creditId ? nameOf(creditId) : "—" })]
+							children: ["CREDIT (right): ", /* @__PURE__ */ jsx("b", { children: creditId ? nameOf(creditId) : ", " })]
 						})]
 					}),
 					/* @__PURE__ */ jsx("div", {

package/dist/commerce/accounting/statement-sorter.mjs

@@ -9,9 +9,9 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/commerce/accounting/statement-sorter.tsx
 /**
-* StatementSorterLab — sort the accounts into the two statements.
+* StatementSorterLab, sort the accounts into the two statements.
 *
-* The financial statements aren't new objects — they're a SORTING of the ledger
+* The financial statements aren't new objects, they're a SORTING of the ledger
 * accounts into their home: Income/Expense → Income Statement (this period's
 * "result"), Asset/Liability/Equity → Balance Sheet (the cumulative "standing").
 * The learner sends each account to a statement (wrong picks are coached, not just
@@ -69,7 +69,7 @@ function StatementSorterLab({ accounts = DEMO, asOfLabel = "", showClosing = tru
 				[a.id]: tray
 			}));
 			setHint(null);
-		} else setHint(`${a.name} is ${a.category === "Asset" || a.category === "Income" ? "an" : "a"} ${a.category} — it belongs on the ${statementOf(a.category)}.`);
+		} else setHint(`${a.name} is ${a.category === "Asset" || a.category === "Income" ? "an" : "a"} ${a.category}, it belongs on the ${statementOf(a.category)}.`);
 	};
 	const unsorted = accounts.filter((a) => !place[a.id]);
 	const inTray = (t) => accounts.filter((a) => place[a.id] === t);
@@ -293,7 +293,7 @@ function StatementSorterLab({ accounts = DEMO, asOfLabel = "", showClosing = tru
 				children: "Close the books → carry profit to Equity"
 			}), closed && /* @__PURE__ */ jsx(StatusPill, {
 				ok: balanced,
-				children: balanced ? "Net profit carried to Equity — A = L + E holds ✓" : "Equation does not balance"
+				children: balanced ? "Net profit carried to Equity, A = L + E holds ✓" : "Equation does not balance"
 			})]
 		}), /* @__PURE__ */ jsx(LiveRegion, { children: hint ?? (closed ? `Net profit ${money(profit)} carried to equity; assets ${money(assets)} equal liabilities plus equity ${money(liabilities + equity)}.` : `${unsorted.length} accounts left to sort.`) })] }),
 		children: figure

package/dist/commerce/economics/core.d.mts

@@ -1,6 +1,6 @@
 //#region src/commerce/economics/core.d.ts
 /**
- * The simple linear supply/demand core — single source of truth shared by every
+ * The simple linear supply/demand core, single source of truth shared by every
  * economics lab (market equilibrium, shift-vs-move, elasticity). Pure functions,
  * no dependencies.
  *
@@ -18,7 +18,7 @@ declare const demandP: (d: Curve, q: number) => number;
 declare const supplyP: (s: Curve, q: number) => number;
 declare const demandQ: (d: Curve, p: number) => number;
 declare const supplyQ: (s: Curve, p: number) => number;
-/** Where Qd = Qs — the market-clearing price + quantity. */
+/** Where Qd = Qs, the market-clearing price + quantity. */
 declare function equilibrium(d: Curve, s: Curve): {
   q: number;
   p: number;

package/dist/commerce/economics/core.mjs

@@ -3,7 +3,7 @@ const demandP = (d, q) => d.intercept - d.slope * q;
 const supplyP = (s, q) => s.intercept + s.slope * q;
 const demandQ = (d, p) => Math.max(0, (d.intercept - p) / d.slope);
 const supplyQ = (s, p) => Math.max(0, (p - s.intercept) / s.slope);
-/** Where Qd = Qs — the market-clearing price + quantity. */
+/** Where Qd = Qs, the market-clearing price + quantity. */
 function equilibrium(d, s) {
 	const q = (d.intercept - s.intercept) / (d.slope + s.slope);
 	return {

package/dist/commerce/economics/demand-shift-vs-move.mjs

@@ -11,12 +11,12 @@ import { Axes, Dot, Label, MovableDot, Segment, Stage } from "@classytic/stage";
 
 //#region src/commerce/economics/demand-shift-vs-move.tsx
 /**
-* DemandShiftVsMoveLab — shift the curve vs move along it.
+* DemandShiftVsMoveLab, shift the curve vs move along it.
 *
 * The #1 micro misconception. Dragging the PRICE slider slides a dot ALONG a
-* fixed demand curve — a change in QUANTITY demanded (the curve never moves).
+* fixed demand curve, a change in QUANTITY demanded (the curve never moves).
 * Clicking a non-price TRIBE factor (Tastes, Related-good prices, Income, Buyers,
-* Expectations) translates the WHOLE curve — a change in DEMAND — and the
+* Expectations) translates the WHOLE curve, a change in DEMAND, and the
 * equilibrium moves along supply to a new P* and Q*. A predict-then-check asks
 * for the P/Q direction before the reveal. The decision rule: only the good's OWN
 * price (the axis variable) moves you along; anything else shifts the curve.
@@ -96,7 +96,7 @@ function DemandShiftVsMoveLab({ demand = DEMAND0, supply = SUPPLY0, shifters = S
 		if (!pending) return;
 		const truth = dirOf(pending);
 		const ok = guess === truth;
-		setVerdict(ok ? `✓ Right — ${pending.label} shifts demand ${pending.delta > 0 ? "right" : "left"}, so P* and Q* both go ${truth}.` : `Not quite — ${pending.label} shifts demand ${pending.delta > 0 ? "right" : "left"}: P* and Q* both go ${truth}.`);
+		setVerdict(ok ? `✓ Right, ${pending.label} shifts demand ${pending.delta > 0 ? "right" : "left"}, so P* and Q* both go ${truth}.` : `Not quite, ${pending.label} shifts demand ${pending.delta > 0 ? "right" : "left"}: P* and Q* both go ${truth}.`);
 		apply(pending);
 		setPending(null);
 		if (ok) setSolved(true);
@@ -301,11 +301,11 @@ function DemandShiftVsMoveLab({ demand = DEMAND0, supply = SUPPLY0, shifters = S
 		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [
 			last === "move" && /* @__PURE__ */ jsx(StatusPill, {
 				ok: false,
-				children: "MOVEMENT along the curve — Δ quantity demanded (own price changed)"
+				children: "MOVEMENT along the curve, Δ quantity demanded (own price changed)"
 			}),
 			last === "shift" && /* @__PURE__ */ jsx(StatusPill, {
 				ok: true,
-				children: "SHIFT of the whole curve — Δ demand (a TRIBE factor)"
+				children: "SHIFT of the whole curve, Δ demand (a TRIBE factor)"
 			}),
 			!last && /* @__PURE__ */ jsx("p", {
 				className: "lab-prompt",

package/dist/commerce/economics/elasticity-revenue.mjs

@@ -10,12 +10,12 @@ import { Axes, Dot, Label, MovableDot, Polygon, Segment, Stage } from "@classyti
 
 //#region src/commerce/economics/elasticity-revenue.tsx
 /**
-* ElasticityRevenueLab — the stretch test: elasticity is NOT slope.
+* ElasticityRevenueLab, the stretch test: elasticity is NOT slope.
 *
-* Rotate one demand line about a pivot from steep (inelastic — few substitutes,
-* e.g. insulin) to flat (elastic — many substitutes, e.g. one water brand). Drag
+* Rotate one demand line about a pivot from steep (inelastic, few substitutes,
+* e.g. insulin) to flat (elastic, many substitutes, e.g. one water brand). Drag
 * the price down the line and the total-revenue rectangle (P×Q) grows on the
-* elastic upper half and shrinks on the inelastic lower half — the revenue
+* elastic upper half and shrinks on the inelastic lower half, the revenue
 * see-saw. The point-elasticity pill flips ELASTIC → UNIT → INELASTIC down a
 * SINGLE straight line, killing the "slope = elasticity" error.
 *
@@ -38,7 +38,7 @@ const PRESETS = [
 function ElasticityRevenueLab({ pivot = {
 	p: 5,
 	q: 5
-}, priceMax = 11, qtyMax = 13, anchorPresets = PRESETS, title = "The stretch test — elasticity is not slope", prompt = "Rotate the curve (substitutes), then drag the price: watch the revenue box + the elasticity flip.", height = 320, objectives }) {
+}, priceMax = 11, qtyMax = 13, anchorPresets = PRESETS, title = "The stretch test: elasticity is not slope", prompt = "Rotate the curve (substitutes), then drag the price: watch the revenue box + the elasticity flip.", height = 320, objectives }) {
 	const [b, setB] = useState(.8);
 	const curve = {
 		intercept: pivot.p + b * pivot.q,
@@ -185,7 +185,7 @@ function ElasticityRevenueLab({ pivot = {
 				})
 			]
 		})
-	}), /* @__PURE__ */ jsx(LiveRegion, { children: `At price ${price.toFixed(1)}, quantity ${q.toFixed(1)}, revenue ${revenue.toFixed(1)}. Elasticity ${E === Infinity ? "infinite" : E.toFixed(2)} — ${kind}.` })] });
+	}), /* @__PURE__ */ jsx(LiveRegion, { children: `At price ${price.toFixed(1)}, quantity ${q.toFixed(1)}, revenue ${revenue.toFixed(1)}. Elasticity ${E === Infinity ? "infinite" : E.toFixed(2)}, ${kind}.` })] });
 	return /* @__PURE__ */ jsx(LabFrame, {
 		title,
 		prompt,

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

@@ -11,15 +11,15 @@ import { Axes, Dot, Label, MovableDot, Polygon, Segment, Stage } from "@classyti
 
 //#region src/commerce/economics/market-equilibrium.tsx
 /**
-* MarketEquilibriumLab — Marshall's scissors: where the market clears.
+* 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 —
+* 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
+* 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).
+* 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.
 */
@@ -34,7 +34,7 @@ const SUPPLY0 = {
 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 }) {
+}, 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 = {

package/dist/core/easing.d.mts

@@ -1,6 +1,6 @@
 //#region src/core/easing.d.ts
 /**
- * Easing / rate functions — pure `(t in [0,1]) => number`. Ported from manim's
+ * 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;
@@ -14,7 +14,7 @@ declare const easeInOut: Easing;
 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. */
+/** 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;
@@ -22,7 +22,7 @@ declare const elastic: Easing;
 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). */
+/** 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 };