@classytic/labs 0.4.0 → 0.5.0

package/dist/math/integration-workbench/preset.mjs

@@ -0,0 +1,489 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { ActionButton } from "../../kit/controls.mjs";
+import { Activity } from "../../kit/activity.mjs";
+import { ChallengeCard, useChallenge, useCheckpoint } from "../../kit/pedagogy.mjs";
+import { CoordPlane } from "../../kit/coords.mjs";
+import { MathExpressionError } from "../activity.mjs";
+import { TraceDescription, TraceLine, TraceNav, TraceRail, TraceStepCard } from "../../kit/engine-trace.mjs";
+import { FAMILY_LABEL, FAMILY_MISS, FAMILY_RULE, LIATE, STEP_LABEL, buildCase, choicesFor, integralTex, methodLabel, residualTex, robustWindow, sampleRuns } from "./model.mjs";
+import { useMemo, useState } from "react";
+import { Polygon, Polyline } from "@classytic/stage";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { evaluate } from "@classytic/stage/math";
+
+//#region src/math/integration-workbench/preset.tsx
+/**
+* IntegrationWorkbenchLab, "classify before you solve", on the stage SYMBOLIC integration engine.
+*
+* THE MISCONCEPTION. Students memorise the formula for each technique and still cannot say which one
+* an integrand calls for. Every earlier integration lab here (`IntegralExplorer`,
+* `FundamentalTheoremExplorer`) is numeric, so none could show WHY a technique applies.
+*
+* THE CONTRACT (lab-design §1):
+*   mission     name the technique ∫f dx calls for, before any working is shown
+*   action      pick one of four technique families (the answer plus three it is confused with)
+*   consequence the engine's own working unlocks, one step per press of "next step"
+*   evidence    each step's before → after, and the deciding evidence: u and dv with the LIATE
+*               class that chose u, u and du for a substitution, the factorised bottom and the
+*               decomposition for partial fractions
+*   explanation the check step: d/dx of the answer is plotted over f, and the two coincide
+*   transfer    a second integrand of a different family, so the learner has to re-classify
+*
+* A non-elementary integrand (e^{x²}) is a teaching state, not an error: the engine's list of
+* techniques that failed is shown, with the area under the curve computed numerically, because
+* the area exists even though no formula does.
+*
+* EVERY EXPRESSION FROM THE ENGINE. The working, the answer, its derivative, the residuals and the
+* plotted curves all come from `solveIntegral` / `verifyAntiderivative` and the engine pieces
+* `model.ts` names. This file only lays them out.
+*
+* GATE. The working stays hidden until the learner names the right family, or has had two tries
+* (a wrong tap alone never reveals the answer; lab-design §8).
+*/
+const C_F = "var(--stage-fg)";
+const C_DF = "var(--stage-accent)";
+/** A very long derivative (a trig power's chain rule) is summarised by the plot and the residual, not typeset. */
+const readable = (t) => !!t && t.length <= 160;
+function LiateLadder({ priority, tieBreak, uTex }) {
+	const name = LIATE.find((l) => l.key === priority)?.name ?? priority;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "math-iw-liate-wrap",
+		children: [/* @__PURE__ */ jsx("ol", {
+			className: "math-iw-liate",
+			"aria-label": `LIATE order; u is ${name.toLowerCase()}`,
+			children: LIATE.map((l) => /* @__PURE__ */ jsxs("li", {
+				"data-u": l.key === priority || void 0,
+				children: [/* @__PURE__ */ jsx("b", { children: l.letter }), /* @__PURE__ */ jsx("span", { children: l.name })]
+			}, l.key))
+		}), /* @__PURE__ */ jsx("p", {
+			className: "math-iw-note",
+			children: tieBreak ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				"Both factors are algebraic, so LIATE ties: ",
+				tieBreak,
+				"."
+			] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				uTex ? /* @__PURE__ */ jsx(Tex$1, { tex: `u = ${uTex}` }) : "u",
+				" is the ",
+				name.toLowerCase(),
+				" factor, the highest LIATE class present, so it is the one to differentiate."
+			] })
+		})]
+	});
+}
+function StepCard({ step, index, total }) {
+	const u = step.evidence.find((e) => e.label === "u");
+	return /* @__PURE__ */ jsxs(TraceStepCard, {
+		index,
+		total,
+		chip: step.label,
+		children: [
+			/* @__PURE__ */ jsx(TraceLine, { tex: step.lineTex }),
+			/* @__PURE__ */ jsx(TraceDescription, { children: step.description }),
+			step.evidence.length > 0 && /* @__PURE__ */ jsx("dl", {
+				className: "math-iw-evidence",
+				children: step.evidence.map((e) => /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: e.label }), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx(Tex$1, { tex: e.tex }) })] }, e.label))
+			}),
+			step.liate && /* @__PURE__ */ jsx(LiateLadder, {
+				priority: step.liate.priority,
+				tieBreak: step.liate.tieBreak,
+				uTex: u?.tex
+			}),
+			step.considered && /* @__PURE__ */ jsxs("p", {
+				className: "math-iw-note",
+				children: [
+					"Also considered for u:",
+					" ",
+					step.considered.map((t, i) => /* @__PURE__ */ jsxs("span", { children: [i > 0 && ", ", /* @__PURE__ */ jsx(Tex$1, { tex: t })] }, i)),
+					"."
+				]
+			})
+		]
+	});
+}
+/** Answers the engine produced, differentiated, found wrong and discarded: a teaching note, not an error. */
+function RejectedNote({ rejected }) {
+	if (rejected.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "math-iw-note",
+		"data-rejected": true,
+		children: rejected.map((r, i) => /* @__PURE__ */ jsxs("p", { children: [
+			"The engine tried ",
+			r.label,
+			" first",
+			r.tex ? /* @__PURE__ */ jsxs(Fragment$1, { children: [", giving ", /* @__PURE__ */ jsx(Tex$1, { tex: r.tex })] }) : null,
+			". That answer did not differentiate back to the integrand, so it was rejected."
+		] }, i))
+	});
+}
+function CheckCard({ c, total }) {
+	const v = c.verified;
+	const d = v?.checks.derivative;
+	return /* @__PURE__ */ jsxs(TraceStepCard, {
+		index: total - 1,
+		total,
+		chip: STEP_LABEL.check,
+		data: { check: true },
+		ariaLabel: `Step ${total} of ${total}: check`,
+		children: [
+			/* @__PURE__ */ jsx(TraceLine, { tex: `${integralTex(c.ast)} = ${c.FTex} + C` }),
+			/* @__PURE__ */ jsx(TraceDescription, { children: "Differentiate the answer. If the derivative gives back the integrand, the answer is right: on the plot the dashed curve of F'(x) lies on f(x)." }),
+			/* @__PURE__ */ jsxs("dl", {
+				className: "math-iw-evidence",
+				children: [readable(c.dFTex) && /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: "F'(x)" }), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx(Tex$1, { tex: c.dFTex }) })] }), d && /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: "matches f(x)" }), /* @__PURE__ */ jsxs("dd", {
+					className: "math-iw-verdict",
+					"data-pass": v?.pass || void 0,
+					children: [
+						v?.pass ? "at" : "fails at",
+						" ",
+						d.valid,
+						" of ",
+						v?.samples,
+						" points, largest gap",
+						" ",
+						/* @__PURE__ */ jsx(Tex$1, { tex: residualTex(v?.maxResidual ?? NaN) })
+					]
+				})] })]
+			}),
+			/* @__PURE__ */ jsx(RejectedNote, { rejected: c.rejected })
+		]
+	});
+}
+function UnsolvedCard({ c }) {
+	return /* @__PURE__ */ jsxs(TraceStepCard, {
+		index: 0,
+		total: 1,
+		head: "Engine verdict",
+		chip: "No formula",
+		data: { unsolved: true },
+		children: [
+			/* @__PURE__ */ jsx("ol", {
+				className: "math-iw-tried",
+				"aria-label": "Techniques the engine tried",
+				children: c.attempted.map((m) => /* @__PURE__ */ jsxs("li", { children: [
+					/* @__PURE__ */ jsx("span", {
+						"aria-hidden": true,
+						children: "✕"
+					}),
+					" ",
+					methodLabel(m)
+				] }, m))
+			}),
+			/* @__PURE__ */ jsxs(TraceDescription, { children: [
+				"Every technique the engine knows failed. Its reason: ",
+				c.reason,
+				". A failed search is not a proof on its own, but for integrands such as e^(x^2) and sin(x)/x it has been proved that no formula built from powers, logs, exponentials and trig functions exists."
+			] }),
+			c.area && /* @__PURE__ */ jsx("dl", {
+				className: "math-iw-evidence",
+				children: /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("dt", { children: "area, 0 to 1" }), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx(Tex$1, { tex: `\\int_{${c.area.a}}^{${c.area.b}} ${c.fTex}\\,dx \\approx ${c.area.value.toFixed(4)}` }) })] })
+			}),
+			/* @__PURE__ */ jsx(RejectedNote, { rejected: c.rejected })
+		]
+	});
+}
+function Rail({ steps, frame }) {
+	return /* @__PURE__ */ jsx(TraceRail, {
+		labels: [...steps.map((s) => s.label), STEP_LABEL.check],
+		frame
+	});
+}
+function CasePlot({ c, showDerivative, domain, height }) {
+	const [a, b] = domain;
+	const fRuns = useMemo(() => sampleRuns(c.ast, a, b), [
+		c,
+		a,
+		b
+	]);
+	const dRuns = useMemo(() => showDerivative && c.kind === "solved" && c.dF ? sampleRuns(c.dF, a, b) : [], [
+		c,
+		showDerivative,
+		a,
+		b
+	]);
+	const [yMin, yMax] = robustWindow(fRuns.flat().map((p) => p.y));
+	const clip = (runs) => {
+		const out = [];
+		const inside = (p) => p.y >= yMin && p.y <= yMax;
+		const edge = (p) => ({
+			x: p.x,
+			y: Math.max(yMin, Math.min(yMax, p.y))
+		});
+		for (const r of runs) {
+			let cur = [];
+			r.forEach((p, i) => {
+				if (inside(p)) {
+					if (cur.length === 0 && i > 0) cur.push(edge(r[i - 1]));
+					cur.push(p);
+				} else if (cur.length) {
+					cur.push(edge(p));
+					out.push(cur);
+					cur = [];
+				}
+			});
+			if (cur.length > 1) out.push(cur);
+		}
+		return out;
+	};
+	const area = useMemo(() => {
+		if (c.kind !== "unsolved" || !c.area) return null;
+		const pts = [{
+			x: c.area.a,
+			y: 0
+		}];
+		for (let i = 0; i <= 60; i++) {
+			const x = c.area.a + (c.area.b - c.area.a) * i / 60;
+			pts.push({
+				x,
+				y: evaluate(c.ast, { x })
+			});
+		}
+		pts.push({
+			x: c.area.b,
+			y: 0
+		});
+		return pts;
+	}, [c]);
+	return /* @__PURE__ */ jsxs("figure", {
+		className: "math-iw-plot",
+		children: [/* @__PURE__ */ jsxs(CoordPlane, {
+			view: {
+				xMin: a,
+				xMax: b,
+				yMin,
+				yMax
+			},
+			height,
+			preserveAspect: false,
+			ariaLabel: showDerivative ? `f(x) = ${c.source} drawn solid, with the derivative of the answer drawn dashed on top of it` : `Graph of the integrand f(x) = ${c.source}`,
+			children: [
+				area && /* @__PURE__ */ jsx(Polygon, {
+					points: area,
+					color: C_DF,
+					fill: C_DF,
+					fillOpacity: .28,
+					weight: 0
+				}),
+				clip(fRuns).map((r, i) => showDerivative ? /* @__PURE__ */ jsx(Polyline, {
+					points: r,
+					color: C_F,
+					weight: 7,
+					opacity: .22
+				}, `f${i}`) : /* @__PURE__ */ jsx(Polyline, {
+					points: r,
+					color: C_F,
+					weight: 2.5
+				}, `f${i}`)),
+				clip(dRuns).map((r, i) => /* @__PURE__ */ jsx(Polyline, {
+					points: r,
+					color: C_DF,
+					weight: 2.5,
+					dashed: true
+				}, `d${i}`))
+			]
+		}), /* @__PURE__ */ jsxs("figcaption", {
+			className: "math-iw-legend",
+			children: [
+				/* @__PURE__ */ jsxs("span", { children: [/* @__PURE__ */ jsx("i", {
+					"data-line": "f",
+					"data-wide": showDerivative || void 0,
+					"aria-hidden": true
+				}), " f(x), the integrand"] }),
+				showDerivative && /* @__PURE__ */ jsxs("span", { children: [/* @__PURE__ */ jsx("i", {
+					"data-line": "df",
+					"aria-hidden": true
+				}), " F'(x), the derivative of the answer"] }),
+				area && /* @__PURE__ */ jsxs("span", { children: [/* @__PURE__ */ jsx("i", {
+					"data-line": "area",
+					"aria-hidden": true
+				}), " area from 0 to 1"] })
+			]
+		})]
+	});
+}
+function IntegrationWorkbenchLab({ f = "x*exp(x)", transfer, title = "Name the technique, then watch it work", prompt = "Look at the integrand and decide which technique it calls for before any working appears. Then step through the engine’s working and check the answer by differentiating it.", domain, height = 230, revealed = false, initialStep } = {}) {
+	const sources = useMemo(() => [f, transfer].filter((s) => typeof s === "string" && s.trim().length > 0), [f, transfer]);
+	const cases = useMemo(() => sources.map((s) => buildCase(s)), [sources]);
+	const [round, setRound] = useState(0);
+	const [frames, setFrames] = useState(() => [initialStep ?? 0, 0]);
+	const questions = useMemo(() => cases.map((c, i) => {
+		if (c.kind === "error") return {
+			id: `technique-${i}`,
+			prompt: "",
+			choices: [],
+			answer: ""
+		};
+		const alsoValid = c.kind === "solved" ? c.alsoValid : [];
+		return {
+			id: `technique-${i}`,
+			prompt: "Which technique does this integral call for first?",
+			choices: choicesFor(c.family, c.source, alsoValid).map((fam) => ({
+				value: fam,
+				label: FAMILY_LABEL[fam],
+				feedback: FAMILY_MISS[fam]
+			})),
+			answer: c.family,
+			explain: FAMILY_RULE[c.family]
+		};
+	}), [cases]);
+	const predict = useChallenge(questions);
+	const hintsUsed = questions.reduce((n, q) => n + Math.max(0, (predict.attempts[q.id] ?? 0) - 1), 0);
+	useCheckpoint({
+		solved: predict.allCorrect,
+		activity: "integration-workbench.classify",
+		hintsUsed,
+		attemptKey: sources.join("|")
+	});
+	const failed = cases.find((c) => c.kind === "error");
+	if (failed) return /* @__PURE__ */ jsx(MathExpressionError, {
+		title,
+		expression: failed.source,
+		error: failed.error
+	});
+	const r = Math.min(round, cases.length - 1);
+	const c = cases[r];
+	const q = questions[r];
+	const picked = predict.picks[q.id];
+	const tries = predict.attempts[q.id] ?? 0;
+	const correct = picked === q.answer;
+	const shown = revealed && r === 0 || correct || tries >= 2;
+	const frameCount = c.kind === "solved" ? c.steps.length + 1 : 1;
+	const frame = Math.max(0, Math.min(frames[r] ?? 0, frameCount - 1));
+	const atEnd = frame === frameCount - 1;
+	const setFrame = (next) => setFrames((prev) => {
+		const out = [...prev];
+		out[r] = Math.max(0, Math.min(next, frameCount - 1));
+		return out;
+	});
+	const hasTransfer = cases.length > 1;
+	const canTransfer = hasTransfer && r === 0 && shown && atEnd;
+	const showDerivative = shown && c.kind === "solved" && atEnd;
+	const currentStep = c.kind === "solved" && frame < c.steps.length ? c.steps[frame] : null;
+	const narration = !shown ? "Name the technique to reveal the working." : c.kind === "unsolved" ? `No elementary formula: every technique failed for ${c.source}.` : currentStep ? `Step ${frame + 1} of ${frameCount}, ${currentStep.label}. ${currentStep.description}` : `Check: the derivative of the answer ${c.verified?.pass ? "matches" : "does not match"} the integrand.`;
+	const hero = /* @__PURE__ */ jsxs("div", {
+		className: "math-iw-integrand",
+		children: [/* @__PURE__ */ jsx(Tex$1, {
+			block: true,
+			tex: integralTex(c.ast)
+		}), shown && /* @__PURE__ */ jsx("span", {
+			className: "math-iw-tag",
+			children: FAMILY_LABEL[c.family]
+		})]
+	});
+	const board = /* @__PURE__ */ jsxs("div", {
+		className: "math-iw-board",
+		"data-revealed": shown || void 0,
+		children: [shown && /* @__PURE__ */ jsx("section", {
+			className: "math-iw-work",
+			"aria-label": "The working",
+			children: c.kind === "unsolved" ? /* @__PURE__ */ jsx(UnsolvedCard, { c }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Rail, {
+				steps: c.steps,
+				frame
+			}), currentStep ? /* @__PURE__ */ jsx(StepCard, {
+				step: currentStep,
+				index: frame,
+				total: frameCount
+			}) : /* @__PURE__ */ jsx(CheckCard, {
+				c,
+				total: frameCount
+			})] })
+		}), /* @__PURE__ */ jsx(CasePlot, {
+			c,
+			showDerivative,
+			domain: domain ?? (c.kind === "unsolved" && c.area ? [-1.5, 1.5] : [-2.5, 2.5]),
+			height
+		})]
+	});
+	const dock = shown && (c.kind === "solved" || hasTransfer) ? /* @__PURE__ */ jsxs("div", {
+		className: "math-iw-dock",
+		children: [
+			c.kind === "solved" && /* @__PURE__ */ jsx(TraceNav, {
+				frame,
+				count: frameCount,
+				onFrame: setFrame
+			}),
+			hasTransfer && r === 0 && (canTransfer || c.kind === "unsolved") && /* @__PURE__ */ jsx(ActionButton, {
+				className: "lab-primary-action",
+				onClick: () => setRound(1),
+				children: "Next integrand"
+			}),
+			hasTransfer && r === 1 && /* @__PURE__ */ jsx(ActionButton, {
+				onClick: () => setRound(0),
+				children: "Back to the first integrand"
+			})
+		]
+	}) : null;
+	const outline = c.kind === "solved" ? /* @__PURE__ */ jsxs("ol", {
+		className: "math-iw-outline",
+		children: [c.steps.map((s, i) => /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("span", {
+			className: "math-iw-chip",
+			children: s.label
+		}), /* @__PURE__ */ jsx(Tex$1, { tex: s.lineTex })] }, i)), /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("span", {
+			className: "math-iw-chip",
+			children: STEP_LABEL.check
+		}), /* @__PURE__ */ jsxs("span", { children: [
+			c.verified?.pass ? "Passed" : "Failed",
+			": F'(x) = f(x) at",
+			" ",
+			c.verified?.checks.derivative.valid,
+			" points; F(b) − F(a) matches the numerical area on",
+			" ",
+			c.verified?.checks.quadrature.valid,
+			" intervals."
+		] })] })]
+	}) : /* @__PURE__ */ jsxs("p", {
+		className: "math-iw-note",
+		children: [
+			"Tried, in order: ",
+			c.attempted.map(methodLabel).join(", "),
+			"."
+		]
+	});
+	const feedbackTone = !shown ? "info" : c.kind === "unsolved" ? "warning" : showDerivative ? c.verified?.pass ? "success" : "warning" : "info";
+	const feedback = !shown ? "A technique is chosen from the shape of the integrand: what is multiplied, what is inside what, and whether a derivative is sitting next to its function." : c.kind === "unsolved" ? `${FAMILY_RULE["no-formula"]} Numerical methods still find its value.` : showDerivative ? "Differentiation undoes integration: the derivative of the answer lies exactly on the integrand." : correct || revealed && r === 0 ? FAMILY_RULE[c.family] : `This one is ${FAMILY_LABEL[c.family].toLowerCase()}. ${FAMILY_RULE[c.family]}`;
+	return /* @__PURE__ */ jsxs(Activity.Root, {
+		className: "math-integration-workbench-activity",
+		children: [
+			/* @__PURE__ */ jsxs(Activity.Header, { children: [/* @__PURE__ */ jsx(Activity.Heading, {
+				eyebrow: "Calculus · integration",
+				title,
+				description: prompt
+			}), /* @__PURE__ */ jsx(Activity.FocusButton, {})] }),
+			/* @__PURE__ */ jsxs(Activity.Status, { children: [/* @__PURE__ */ jsx("strong", { children: hasTransfer ? `Integrand ${r + 1} of ${cases.length}` : "One integrand" }), /* @__PURE__ */ jsx("span", { children: shown ? FAMILY_LABEL[c.family] : "Technique not named yet" })] }),
+			/* @__PURE__ */ jsxs(Activity.Workspace, { children: [
+				/* @__PURE__ */ jsx(Activity.Canvas, {
+					label: "The integrand, the working and the check plot",
+					children: /* @__PURE__ */ jsxs("div", {
+						className: "lab-predict-gate",
+						children: [
+							hero,
+							!(revealed && r === 0) && /* @__PURE__ */ jsx(ChallengeCard, {
+								questions: [q],
+								state: predict,
+								title: hasTransfer ? `Integrand ${r + 1}: name the technique` : "Name the technique first"
+							}),
+							board
+						]
+					})
+				}),
+				dock && /* @__PURE__ */ jsx(Activity.Dock, {
+					label: "Step through the working",
+					children: dock
+				}),
+				shown && /* @__PURE__ */ jsx(Activity.Inspector, {
+					label: "The whole working",
+					children: /* @__PURE__ */ jsx(Activity.InspectorSection, { children: outline })
+				})
+			] }),
+			/* @__PURE__ */ jsxs(Activity.Feedback, {
+				tone: feedbackTone,
+				children: [/* @__PURE__ */ jsx("span", { children: !shown ? "Classify" : c.kind === "unsolved" ? "No formula" : showDerivative ? "Checked" : "Why" }), /* @__PURE__ */ jsx("div", { children: feedback })]
+			}),
+			/* @__PURE__ */ jsx(Activity.LiveRegion, { children: narration })
+		]
+	});
+}
+
+//#endregion
+export { IntegrationWorkbenchLab };

package/dist/math/interactive/preset.mjs

@@ -5,8 +5,8 @@ import { Activity } from "../../kit/activity.mjs";
 import { Field, Stat, StatList } from "../../kit/frame.mjs";
 import { AskBox } from "../../kit/pedagogy.mjs";
 import { useMemo, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { Axes, Dot, Grid, Plot, Stage } from "@classytic/stage";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { areaBetween, checkAnswer, compileExpr, intersections, normalAt, roots, tangentAt } from "@classytic/stage/math";
 
 //#region src/math/interactive/preset.tsx

package/dist/math/iteration/preset.mjs

@@ -8,8 +8,8 @@ import { useCheckpoint } from "../../kit/pedagogy.mjs";
 import { PlaneAxes, clearOfLabel } from "../../kit/coords.mjs";
 import { cobweb, iterationProblems, run, verdict } from "./core.mjs";
 import { useMemo, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
 import { Dot, Grid, Label, Polyline, Stage } from "@classytic/stage";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { compileExpr, evaluate } from "@classytic/stage/math";
 
 //#region src/math/iteration/preset.tsx

package/dist/math/limit-explorer/preset.mjs

@@ -3,11 +3,13 @@
 import { clamp } from "../../core/util.mjs";
 import { estimateOneSidedLimit } from "../../core/numeric.mjs";
 import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { STROKE } from "../../kit/figure/figure.mjs";
+import { ChallengeCard, useChallenge, useCheckpoint } from "../../kit/pedagogy.mjs";
 import { normalizeRange, valueInRange } from "../calculus/core.mjs";
 import { MathActivity, MathExpressionError, MathResetTransport } from "../activity.mjs";
 import { Fragment, useEffect, useMemo, useState } from "react";
+import { Axes, Grid, MovableDot, Plot, Point, Segment, Stage, fmt, useCoords } from "@classytic/stage";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-import { Axes, Grid, MovableDot, Plot, Point, Segment, Stage } from "@classytic/stage";
 import { compileExpr, evaluate, toLatex } from "@classytic/stage/math";
 
 //#region src/math/limit-explorer/preset.tsx
@@ -24,6 +26,44 @@ const STEPS = [
 	.001
 ];
 const fmt$1 = (v) => Number.isFinite(v) ? v.toFixed(4) : "-";
+const PREDICT_QUESTIONS = [{
+	id: "hole-limit",
+	prompt: "A function has a HOLE at x = c: f(c) is undefined. Can the two-sided limit still exist there?",
+	choices: [
+		{
+			value: "yes",
+			label: "Yes -- the limit only depends on values NEAR c, not on f(c) itself"
+		},
+		{
+			value: "no-undefined",
+			label: "No -- if f(c) is undefined, the limit is undefined too",
+			feedback: "A limit is a statement about where f is heading as x closes in on c, from both sides. It never asks what f(c) actually is. That is exactly why a limit can exist at a hole where the function value cannot."
+		},
+		{
+			value: "no-continuous",
+			label: "No -- a limit only exists where the function is continuous",
+			feedback: "Continuity needs three things: the limit exists, f(c) is defined, AND they match. A hole breaks only the second one. The limit itself doesn't require f to be defined at c at all."
+		}
+	],
+	answer: "yes",
+	explain: "The limit describes nearby behavior only. f(c) being undefined does not stop the two sides from converging to the same value."
+}];
+/**
+* The hole itself, drawn where the audit found nothing: an open circle at (c, L), pixel-sized
+* like `Point` so it reads at any zoom, but PAINTED with the page background so the curve
+* visibly breaks there instead of a solid dot implying f(c) IS defined.
+*/
+function HoleMarker({ x, y }) {
+	const [px, py] = useCoords().toPx(x, y);
+	return /* @__PURE__ */ jsx("circle", {
+		cx: fmt(px),
+		cy: fmt(py),
+		r: 5,
+		fill: "var(--stage-bg)",
+		stroke: "var(--stage-accent)",
+		strokeWidth: STROKE.line
+	});
+}
 function LimitExplorer({ equation = "(x^2 - 1)/(x - 1)", xRange = [-1, 3], c: cInit = 1, title = "Approaching a limit", height = 320 } = {}) {
 	const [xMin, xMax] = normalizeRange(xRange, [-1, 3]);
 	const initialC = valueInRange(cInit, [xMin, xMax], 1);
@@ -44,6 +84,12 @@ function LimitExplorer({ equation = "(x^2 - 1)/(x - 1)", xRange = [-1, 3], c: cI
 			fLatex: toLatex(ast)
 		};
 	}, [equation]);
+	const predict = useChallenge(PREDICT_QUESTIONS);
+	useCheckpoint({
+		solved: predict.allCorrect,
+		activity: "limit-explorer.predict"
+	});
+	const locked = !predict.answeredAll;
 	if (!model.ok) return /* @__PURE__ */ jsx(MathExpressionError, {
 		title,
 		expression: equation,
@@ -101,6 +147,10 @@ function LimitExplorer({ equation = "(x^2 - 1)/(x - 1)", xRange = [-1, 3], c: cI
 				weight: 1,
 				dashed: true
 			}),
+			!Number.isFinite(atC) && agrees && Number.isFinite(estimate) && /* @__PURE__ */ jsx(HoleMarker, {
+				x: c,
+				y: estimate
+			}),
 			STEPS.map((hstep, i) => {
 				const r = 4 - i * .6;
 				const yl = f(c - hstep);
@@ -152,18 +202,46 @@ function LimitExplorer({ equation = "(x^2 - 1)/(x - 1)", xRange = [-1, 3], c: cI
 		]
 	})] });
 	const reset = () => setC(initialC);
+	const gatedFigure = /* @__PURE__ */ jsxs("div", {
+		className: "lab-predict-gate",
+		children: [/* @__PURE__ */ jsx(ChallengeCard, {
+			questions: PREDICT_QUESTIONS,
+			state: predict,
+			title: "Predict first"
+		}), /* @__PURE__ */ jsx("div", {
+			className: "lab-predict-body",
+			"data-locked": locked || void 0,
+			children: locked ? /* @__PURE__ */ jsxs("div", {
+				className: "lab-predict-lock",
+				role: "status",
+				"aria-live": "polite",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "lab-predict-lock-mark",
+						"aria-hidden": true,
+						children: "?"
+					}),
+					/* @__PURE__ */ jsx("strong", { children: "Predict whether a limit can exist at a hole, then explore" }),
+					/* @__PURE__ */ jsx("span", { children: "Choose an answer above, then explore the model." })
+				]
+			}) : figure
+		})]
+	});
 	return /* @__PURE__ */ jsx(MathActivity, {
 		className: "math-limit-explorer",
 		eyebrow: "Calculus · limits",
 		title,
 		description: "Drag c and compare values approaching from the left and right. The function value at c may be missing while the limit still exists.",
-		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		status: locked ? /* @__PURE__ */ jsx("strong", { children: "Predict first, then explore" }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
 			/* @__PURE__ */ jsx("strong", { children: agrees ? "Two-sided limit exists" : "Sides do not agree" }),
 			/* @__PURE__ */ jsxs("span", { children: ["c ", c.toFixed(3)] }),
 			!Number.isFinite(atC) ? /* @__PURE__ */ jsx("span", { children: "hole at c" }) : null
 		] }),
-		figure,
-		measurements: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+		figure: gatedFigure,
+		measurements: locked ? /* @__PURE__ */ jsx("p", {
+			className: "math-explain",
+			children: "Answer the prediction above to reveal the approached values."
+		}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
 			className: "math-result-probe",
 			children: [
 				/* @__PURE__ */ jsx("span", { children: "Approached value" }),
@@ -179,13 +257,13 @@ function LimitExplorer({ equation = "(x^2 - 1)/(x - 1)", xRange = [-1, 3], c: cI
 			className: "math-explain",
 			children: "A limit describes nearby behavior. It does not require the function to be defined at the approach point."
 		})] }),
-		conclusion: agrees ? "The left and right approaches settle on the same value, so the two-sided limit exists." : "The left and right approaches do not converge to the same value, so the two-sided limit does not exist.",
+		conclusion: locked ? "Commit to a prediction above before the model reveals its conclusion." : agrees ? "The left and right approaches settle on the same value, so the two-sided limit exists." : "The left and right approaches do not converge to the same value, so the two-sided limit does not exist.",
 		transport: /* @__PURE__ */ jsx(MathResetTransport, {
 			onReset: reset,
 			state: "Drag the approach point",
 			detail: `c ${c.toFixed(3)}`
 		}),
-		details,
+		details: locked ? void 0 : details,
 		graphLabel: "Function graph with two-sided limit approach",
 		inspectorLabel: "Limit estimate"
 	});

package/dist/math/linear-map/index.d.mts

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

package/dist/math/linear-map/preset.d.mts

@@ -0,0 +1,19 @@
+import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
+import { ReactNode } from "react";
+//#region src/math/linear-map/preset.d.ts
+interface LinearMapProps {
+  a?: number;
+  b?: number;
+  c?: number;
+  d?: number;
+  targetDeterminant?: number;
+  maxEntry?: number;
+  height?: number;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: string | AuthoredActivity;
+}
+declare function LinearMapLab({ a: a0, b: b0, c: c0, d: d0, targetDeterminant, maxEntry, height, title, prompt, objectives, activity }: LinearMapProps): ReactNode;
+//#endregion
+export { LinearMapLab, LinearMapProps };