@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/math/functions/graph/model.mjs

@@ -1,5 +1,6 @@
 import { defineLabModel } from "../../../../model/define.mjs";
 import { refuse as refuse$1 } from "../../../../model/index.mjs";
+import { parameterNameProblem } from "../../_shared/parameter-name.mjs";
 import { autoRange, decadeTicks, fmtNum, niceTicks } from "./axis.mjs";
 import { isRefusal } from "@classytic/stage/result";
 import { z } from "zod";
@@ -41,15 +42,24 @@ const graphModel = defineLabModel({
 		equations: z.array(equationSchema).min(1).max(6).default(["sin(x)"]).describe("one or more formulas in x (and any slider names)"),
 		params: z.array(paramSchema).max(6).default([]).describe("learner-draggable sliders named in the equations"),
 		xRange: z.tuple([z.number().finite(), z.number().finite()]).default([-6.5, 6.5]).describe("the visible x window"),
+		xLabel: z.string().trim().min(1).max(120).default("x").describe("horizontal quantity and optional units; expressions still use x"),
+		yLabel: z.string().trim().min(1).max(120).default("y").describe("vertical quantity and optional units"),
 		yScale: z.enum(["linear", "log"]).default("linear").describe("log plots log10(y) with decade ticks, for exponentials and rates"),
-		axes: z.enum(["boundary", "origin"]).default("boundary").describe("boundary scale rails or true x=0 and y=0 axes")
+		axes: z.enum(["boundary", "origin"]).default("boundary").describe("boundary scale rails or true x=0 and y=0 axes"),
+		yRange: z.tuple([z.number().finite(), z.number().finite()]).optional().describe("fix the visible y window (curves are cut at its edges); default: fit the curves"),
+		probe: z.number().finite().optional().describe("show a draggable vertical line starting at this x, reading each curve where it crosses")
 	}),
 	resolve(p) {
 		if (p.xRange[1] <= p.xRange[0]) return refuse$1("bad-x-range", "The x window needs a maximum greater than its minimum.", { prop: "xRange" });
 		if (p.axes === "origin" && (p.yScale === "log" || p.xRange[0] > 0 || p.xRange[1] < 0)) return refuse$1("origin-axes-unavailable", "Origin axes require a linear scale and an x window containing zero.");
+		if (p.yRange && p.yRange[1] <= p.yRange[0]) return refuse$1("bad-y-range", "The y window needs a maximum greater than its minimum.", { prop: "yRange" });
+		if (p.yRange && p.yScale === "log" && p.yRange[0] <= 0) return refuse$1("bad-y-range", "A log scale needs a y window above zero.", { prop: "yRange" });
+		if (p.yRange && p.axes === "origin" && (p.yRange[0] > 0 || p.yRange[1] < 0)) return refuse$1("origin-axes-unavailable", "Origin axes need a y window containing zero.", { prop: "yRange" });
+		if (p.probe !== undefined && (p.probe < p.xRange[0] || p.probe > p.xRange[1])) return refuse$1("probe-outside-window", "The probe must start inside the x window.", { prop: "probe" });
 		const names = new Set();
 		for (const prm of p.params) {
-			if (prm.name === "x") return refuse$1("reserved-param-name", "The input x cannot also be a parameter. Choose another parameter name.", { prop: "params" });
+			const problem = parameterNameProblem(prm.name);
+			if (problem) return refuse$1(problem.code, problem.message, { prop: "params" });
 			if (names.has(prm.name)) return refuse$1("duplicate-param", `Two sliders are both named "${prm.name}".`, { prop: "params" });
 			names.add(prm.name);
 			if (prm.max <= prm.min) return refuse$1("bad-param-range", `Slider "${prm.name}" needs a maximum greater than its minimum.`, { prop: "params" });
@@ -62,7 +72,7 @@ const graphModel = defineLabModel({
 			const unbound = compiled ? [...freeVars(compiled.ast)].filter((name) => name !== "x" && !names.has(name)) : [];
 			return {
 				expr: spec.expr,
-				latex: spec.label ?? (compiled ? toLatex(compiled.ast) : spec.expr),
+				latex: spec.label ?? `y=${compiled ? toLatex(compiled.ast) : spec.expr}`,
 				color: spec.color ?? PALETTE[i % PALETTE.length],
 				compiled: unbound.length ? null : compiled,
 				...isRefusal(res) ? { error: `${res.code}: ${res.message}` } : {},
@@ -76,12 +86,14 @@ const graphModel = defineLabModel({
 	},
 	initial: (s) => ({
 		focus: s.params[0]?.name ?? "",
-		values: Object.fromEntries(s.params.map((prm) => [prm.name, prm.value]))
+		values: Object.fromEntries(s.params.map((prm) => [prm.name, prm.value])),
+		probeX: s.probe ?? (s.xRange[0] + s.xRange[1]) / 2,
+		probed: false
 	}),
 	controls: (c) => ({
 		focus: c.choice({
 			label: "Parameter",
-			when: (s) => s.params.length > 0,
+			when: (s) => s.params.length > 1,
 			unset: true,
 			options: (s) => s.params.map((prm) => ({
 				value: prm.name,
@@ -95,7 +107,6 @@ const graphModel = defineLabModel({
 		}),
 		param: c.number({
 			label: (_s, st) => `Value of ${st.focus || "parameter"}`,
-			availabilityFrom: ["focus"],
 			when: (s, st) => s.params.some((prm) => prm.name === st.focus),
 			step: (s, st) => s.params.find((prm) => prm.name === st.focus)?.step ?? .1,
 			range: (s, st) => {
@@ -110,6 +121,19 @@ const graphModel = defineLabModel({
 					[st.focus]: v
 				}
 			})
+		}),
+		probe: c.number({
+			label: "probe line x",
+			when: (s) => s.probe !== undefined,
+			step: (s) => niceStep(s.xRange),
+			range: (s) => [s.xRange[0], s.xRange[1]],
+			get: (st) => st.probeX,
+			set: (st, probeX) => ({
+				...st,
+				probeX,
+				probed: true
+			}),
+			format: (v) => `x = ${fmtNum(v)}`
 		})
 	}),
 	read(s, st) {
@@ -128,9 +152,24 @@ const graphModel = defineLabModel({
 			})), domain, [xMin, xMax]);
 			return sampled.ok ? sampled.value : [];
 		});
-		const [autoMin, autoMax] = autoRange(curveSegments.flatMap((segments) => segments.flatMap((segment) => segment.map((point) => point.y))));
-		const dispMin = s.axes === "origin" ? Math.min(0, autoMin) : autoMin;
-		const dispMax = s.axes === "origin" ? Math.max(0, autoMax) : autoMax;
+		const [autoMin, autoMax] = s.yRange ? [disp(s.yRange[0]), disp(s.yRange[1])] : autoRange(curveSegments.flatMap((segments) => segments.flatMap((segment) => segment.map((point) => point.y))));
+		const dispMin = s.axes === "origin" && !s.yRange ? Math.min(0, autoMin) : autoMin;
+		const dispMax = s.axes === "origin" && !s.yRange ? Math.max(0, autoMax) : autoMax;
+		const shown = s.yRange ? curveSegments.map((segments) => clipSegments(segments, dispMin, dispMax)) : curveSegments;
+		const probe = s.probe === undefined ? null : {
+			x: st.probeX,
+			points: s.curves.map((curve) => {
+				if (!curve.compiled) return null;
+				const y = curve.compiled.fn({
+					...st.values,
+					x: st.probeX
+				});
+				return Number.isFinite(y) ? {
+					y,
+					disp: disp(y)
+				} : null;
+			})
+		};
 		return {
 			values: st.values,
 			isLog,
@@ -138,13 +177,60 @@ const graphModel = defineLabModel({
 			xMax,
 			dispMin,
 			dispMax,
-			curveSegments,
+			curveSegments: shown,
+			probe,
+			probed: st.probed,
 			xTicks: niceTicks(xMin, xMax, 6),
 			yTicks: isLog ? decadeTicks(dispMin, dispMax) : niceTicks(dispMin, dispMax, 5)
 		};
 	},
-	describe: (s, _st, r) => `${s.curves.length} function${s.curves.length === 1 ? "" : "s"} shown from x ${fmtNum(r.xMin)} to ${fmtNum(r.xMax)}${r.isLog ? ", log scale" : ""}.`
+	goals: { 
+	/** The learner moved the probe line at least once. */
+probed: (r) => r.probed },
+	witness: (s) => ({
+		focus: s.params[0]?.name ?? "",
+		values: Object.fromEntries(s.params.map((prm) => [prm.name, prm.value])),
+		probeX: s.probe ?? (s.xRange[0] + s.xRange[1]) / 2,
+		probed: true
+	}),
+	describe: (s, _st, r) => `${s.curves.length} function${s.curves.length === 1 ? "" : "s"} shown from ${s.xLabel} ${fmtNum(r.xMin)} to ${fmtNum(r.xMax)}${r.isLog ? ", log scale" : ""}. Vertical axis: ${s.yLabel}.${r.probe ? ` Probe at ${s.xLabel} = ${fmtNum(r.probe.x)}: ${r.probe.points.map((pt, i) => pt ? `${s.curves[i].expr} = ${fmtNum(pt.y)}` : `${s.curves[i].expr} undefined`).join(", ")}.` : ""}`
 });
+/** A probe step that lands on round numbers: a tenth of a nice tick spacing. */
+function niceStep([a, b]) {
+	const ticks = niceTicks(a, b, 6);
+	const spacing = ticks.length > 1 ? Math.abs(ticks[1] - ticks[0]) : (b - a) / 6;
+	return spacing / 10;
+}
+/** Split each sampled piece where it leaves [lo, hi], ending each part exactly on the edge. */
+function clipSegments(segments, lo, hi) {
+	const out = [];
+	const inside = (p) => p.y >= lo && p.y <= hi;
+	const edge = (a, b) => {
+		const y = b.y > hi || a.y > hi ? hi : lo;
+		const t = (y - a.y) / (b.y - a.y);
+		return {
+			x: a.x + t * (b.x - a.x),
+			y
+		};
+	};
+	for (const seg of segments) {
+		let cur = [];
+		for (let i = 0; i < seg.length; i++) {
+			const p = seg[i];
+			const prev = seg[i - 1];
+			if (inside(p)) {
+				if (prev && !inside(prev) && Number.isFinite(prev.y)) cur.push(edge(prev, p));
+				cur.push(p);
+			} else {
+				if (prev && inside(prev) && Number.isFinite(p.y)) cur.push(edge(prev, p));
+				if (cur.length > 1) out.push(cur);
+				cur = [];
+			}
+		}
+		if (cur.length > 1) out.push(cur);
+	}
+	return out;
+}
 
 //#endregion
-export { graphModel };
+export { clipSegments, graphModel };

package/dist/domains/math/functions/graph/runtime.mjs

@@ -23,7 +23,7 @@ function Graph(props) {
 				scenario.curves.length === 1 ? "curve" : "curves"
 			] }),
 			/* @__PURE__ */ jsxs("span", { children: [
-				"x: ",
+				"Input window: ",
 				fmtNum(reading.xMin),
 				" to ",
 				fmtNum(reading.xMax)

package/dist/domains/math/functions/graph/scene.mjs

@@ -1,13 +1,15 @@
 'use client';
 
 import { Tex } from "../../../../core/tex.mjs";
-import { Figure, STROKE } from "../../../../kit/figure/figure.mjs";
+import { FigText } from "../../../../kit/figure/text.mjs";
+import { Figure, HUE, STROKE } from "../../../../kit/figure/figure.mjs";
+import { GripSlider } from "../../../../kit/figure/grip.mjs";
 import { Readout } from "../../../../kit/frame.mjs";
-import { Stack } from "../../../../kit/layout.mjs";
-import { GraphLegend, GraphPanel, sceneGraph } from "../../../../kit/scene/graph.mjs";
-import "../../../../kit/figure/index.mjs";
 import { useControl } from "../../../../runtime/use-control.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
+import { useNarrow } from "../../../../kit/figure/narrow.mjs";
+import { Stack } from "../../../../kit/layout.mjs";
+import { GraphLegend, GraphPanel, graphAxisLabelLines, sceneGraph } from "../../../../kit/scene/graph.mjs";
 import { SceneSettings } from "../../../../kit/scene-settings.mjs";
 import { fmtNum } from "./axis.mjs";
 import { graphModel } from "./model.mjs";
@@ -18,11 +20,20 @@ function GraphScene() {
 	const { scenario: s, reading: r } = useLabView(graphModel);
 	const focus = useControl(graphModel, "focus");
 	const param = useControl(graphModel, "param");
+	const probe = useControl(graphModel, "probe");
+	const { ref, width } = useNarrow();
+	const figureWidth = Math.min(480, width || 480);
+	const plotWidth = Math.max(1, figureWidth - 86);
+	const yAxisLabel = r.isLog ? `${s.yLabel} (log scale)` : s.yLabel;
+	const xRows = graphAxisLabelLines(s.xLabel, plotWidth).length;
+	const yRows = graphAxisLabelLines(yAxisLabel, plotWidth).length;
+	const topExtra = (yRows - 1) * 18;
+	const probeRail = r.probe ? 40 : 0;
 	const graph = {
 		...sceneGraph({
 			x: 60,
-			y: 30,
-			w: 394,
+			y: 36 + topExtra,
+			w: plotWidth,
 			h: 250
 		}, [r.xMin, r.xMax], [r.dispMin, r.dispMax]),
 		xTicks: r.xTicks,
@@ -30,45 +41,103 @@ function GraphScene() {
 	};
 	const yTickLabel = (value) => r.isLog ? `1e${Number.isInteger(value) ? value : value.toFixed(1)}` : fmtNum(value);
 	return /* @__PURE__ */ jsxs(Stack, { children: [
-		/* @__PURE__ */ jsx(Figure, {
-			viewBox: [480, 332],
-			domain: "math",
-			composition: "content",
-			label: `Graph of ${s.curves.map((curve) => curve.expr).join(", ")}${r.isLog ? ", logarithmic y scale" : ""}`,
-			children: /* @__PURE__ */ jsx(GraphPanel, {
-				graph,
-				xLabel: "x",
-				xLabelOffset: 40,
-				yLabelOffset: 10,
-				yLabel: r.isLog ? "y (log scale)" : "y",
-				axes: s.axes,
-				xTickLabel: fmtNum,
-				yTickLabel,
-				showYMinTick: true,
-				children: r.curveSegments.map((segments, i) => /* @__PURE__ */ jsx("g", {
-					"data-graph-curve": i,
-					children: segments.map((points, j) => /* @__PURE__ */ jsx("path", {
-						"data-curve-segment": j,
-						d: points.map((point, k) => `${k === 0 ? "M" : "L"}${graph.X(point.x)},${graph.Y(point.y)}`).join(" "),
-						stroke: s.curves[i].color,
-						strokeWidth: STROKE.edge,
-						fill: "none",
-						strokeLinejoin: "round",
-						strokeLinecap: "round"
-					}, j))
-				}, i))
+		/* @__PURE__ */ jsx("div", {
+			ref,
+			children: /* @__PURE__ */ jsxs(Figure, {
+				viewBox: [figureWidth, 338 + topExtra + (xRows - 1) * 18 + probeRail],
+				domain: "math",
+				composition: "content",
+				label: `Graph of ${s.curves.map((curve) => curve.expr).join(", ")}${r.isLog ? ", logarithmic y scale" : ""}; horizontal axis ${s.xLabel}; vertical axis ${s.yLabel}`,
+				children: [/* @__PURE__ */ jsxs(GraphPanel, {
+					graph,
+					xLabel: s.xLabel,
+					xLabelWidth: plotWidth,
+					yLabelWidth: plotWidth,
+					yLabelAnchor: s.yLabel === "y" && !r.isLog ? "middle" : "start",
+					xLabelOffset: 40 + probeRail,
+					yLabelOffset: 24 + topExtra,
+					yLabel: yAxisLabel,
+					axes: s.axes,
+					xTickLabel: fmtNum,
+					yTickLabel,
+					showYMinTick: true,
+					children: [r.curveSegments.map((segments, i) => /* @__PURE__ */ jsx("g", {
+						"data-graph-curve": i,
+						children: segments.map((points, j) => /* @__PURE__ */ jsx("path", {
+							"data-curve-segment": j,
+							d: points.map((point, k) => `${k === 0 ? "M" : "L"}${graph.X(point.x)},${graph.Y(point.y)}`).join(" "),
+							stroke: s.curves[i].color,
+							strokeWidth: STROKE.edge,
+							fill: "none",
+							strokeLinejoin: "round",
+							strokeLinecap: "round"
+						}, j))
+					}, i)), r.probe ? /* @__PURE__ */ jsxs("g", {
+						"data-graph-probe": true,
+						children: [/* @__PURE__ */ jsx("line", {
+							x1: graph.X(r.probe.x),
+							y1: graph.Y(r.dispMax),
+							x2: graph.X(r.probe.x),
+							y2: graph.Y(r.dispMin),
+							stroke: HUE.soft,
+							strokeWidth: STROKE.line,
+							strokeDasharray: "4 3"
+						}), r.probe.points.map((pt, i) => pt && pt.disp >= r.dispMin && pt.disp <= r.dispMax ? /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("circle", {
+							cx: graph.X(r.probe.x),
+							cy: graph.Y(pt.disp),
+							r: 5,
+							fill: s.curves[i].color,
+							stroke: HUE.paper,
+							strokeWidth: STROKE.line
+						}), /* @__PURE__ */ jsx(FigText, {
+							x: graph.X(r.probe.x) + (r.probe.x > (r.xMin + r.xMax) / 2 ? -10 : 10),
+							y: graph.Y(pt.disp) - 10,
+							anchor: r.probe.x > (r.xMin + r.xMax) / 2 ? "end" : "start",
+							tone: "ink",
+							size: "label",
+							children: fmtNum(pt.y)
+						})] }, i) : null)]
+					}) : null]
+				}), r.probe ? /* @__PURE__ */ jsxs("g", {
+					"data-graph-probe-control": true,
+					children: [/* @__PURE__ */ jsx(GripSlider, {
+						cx: graph.X(r.probe.x),
+						cy: graph.Y(r.dispMin) + probeRail,
+						r: 9,
+						hit: 22,
+						axis: "x",
+						label: "the probe line: drag it along x to read each curve",
+						control: probe,
+						toValue: (pt) => Math.min(r.xMax, Math.max(r.xMin, graph.xAt(pt.x))),
+						children: /* @__PURE__ */ jsx("circle", {
+							cx: graph.X(r.probe.x),
+							cy: graph.Y(r.dispMin) + probeRail,
+							r: 8,
+							fill: "var(--fig-surface-strong)",
+							stroke: HUE.ink,
+							strokeWidth: STROKE.line
+						})
+					}), /* @__PURE__ */ jsx(FigText, {
+						x: graph.X(r.probe.x),
+						y: graph.Y(r.dispMax) - 8,
+						anchor: "middle",
+						tone: "soft",
+						size: "label",
+						children: `x = ${fmtNum(r.probe.x)}`
+					})]
+				}) : null]
 			})
 		}),
 		/* @__PURE__ */ jsx(GraphLegend, { entries: s.curves.map((curve, i) => ({
 			id: String(i),
 			color: curve.color,
-			label: /* @__PURE__ */ jsx(Tex, { tex: `y=${curve.latex}` })
+			label: /* @__PURE__ */ jsx(Tex, { tex: curve.latex })
 		})) }),
 		/* @__PURE__ */ jsx(SceneSettings, {
 			controls: [focus, param],
 			label: "Graph parameters"
 		}),
-		s.params.length > 0 && (focus.hidden || param.hidden) ? /* @__PURE__ */ jsx(Readout, {
+		s.params.length > 0 && param.hidden ? /* @__PURE__ */ jsx(Readout, {
 			tone: "info",
 			label: "Current parameters",
 			value: s.params.map((prm) => `${prm.name} = ${fmtNum(r.values[prm.name])}`).join(" · ")

package/dist/domains/math/functions/graph-transform/scene.mjs

@@ -1,11 +1,11 @@
 'use client';
 
-import { useShell } from "../../../../kit/shell/context.mjs";
+import { useShellMeta } from "../../../../kit/shell/context.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { CoordPlane } from "../../../../kit/coords.mjs";
 import { graphTransformModel } from "./model.mjs";
-import { Dot, Label, Polyline, Segment } from "@classytic/stage";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, Polyline, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/functions/graph-transform/scene.tsx
 const C_ORIGINAL = "var(--stage-muted)";
@@ -15,7 +15,7 @@ const C_TRAIL = "var(--stage-good)";
 const pointLabel = (p) => `(${Math.round(p.x * 100) / 100}, ${Math.round(p.y * 100) / 100})`;
 function GraphTransformScene() {
 	const { scenario: s, reading } = useLabView(graphTransformModel);
-	const { meta } = useShell();
+	const meta = useShellMeta();
 	const showSteps = meta.sequence.current.phase !== "predict";
 	return /* @__PURE__ */ jsxs(CoordPlane, {
 		view: {
@@ -56,7 +56,7 @@ function GraphTransformScene() {
 					x: reading.currentPoint.x,
 					y: reading.currentPoint.y,
 					text: pointLabel(reading.currentPoint),
-					size: 11,
+					size: 12,
 					dx: reading.currentPoint.x > s.d0 + .7 * (s.d1 - s.d0) ? -10 : 10,
 					anchor: reading.currentPoint.x > s.d0 + .7 * (s.d1 - s.d0) ? "end" : "start",
 					dy: reading.currentPoint.y > reading.vMax - .15 * (reading.vMax - reading.vMin) ? 14 : -12

package/dist/domains/math/functions/injective-classifier/scene.mjs

@@ -7,8 +7,8 @@ import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { PlaneGrip } from "../../../../kit/plane-grip.mjs";
 import { CoordPlane, num } from "../../../../kit/coords.mjs";
 import { injectiveClassifierModel } from "./model.mjs";
-import { Dot, Label, Polyline, Segment } from "@classytic/stage";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, Polyline, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/functions/injective-classifier/scene.tsx
 const C_F = "var(--stage-fg)";

package/dist/domains/math/functions/inverse-functions/scene.mjs

@@ -8,9 +8,9 @@ import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { PlaneGrip } from "../../../../kit/plane-grip.mjs";
 import { CoordClip, CoordPlane, clearOfLabel as clearOfLabel$1, num } from "../../../../kit/coords.mjs";
 import { inverseFunctionsModel } from "./model.mjs";
-import { Dot, Label, Polyline, Segment } from "@classytic/stage";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { toLatex } from "@classytic/stage/math";
+import { Dot, Label, Polyline, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/functions/inverse-functions/scene.tsx
 const C_F = "var(--stage-fg)";

package/dist/domains/math/functions/linearisation/scene.mjs

@@ -4,8 +4,8 @@ import { Tex } from "../../../../core/tex.mjs";
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { CoordPlane } from "../../../../kit/coords.mjs";
 import { gradientAndIntercept, linearisationModel, originalY, transformedY } from "./model.mjs";
-import { Dot, Plot } from "@classytic/stage";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Plot } from "@classytic/stage/primitives";
 
 //#region src/domains/math/functions/linearisation/scene.tsx
 const HEIGHT_DEFAULT = 160;

package/dist/domains/math/functions/modulus-function/scene.mjs

@@ -3,8 +3,8 @@
 import { useLabView } from "../../../../runtime/use-lab-view.mjs";
 import { CoordPlane, num } from "../../../../kit/coords.mjs";
 import { modulusFunctionModel } from "./model.mjs";
-import { Dot, Label, Polyline, Segment } from "@classytic/stage";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Dot, Label, Polyline, Segment } from "@classytic/stage/primitives";
 
 //#region src/domains/math/functions/modulus-function/scene.tsx
 const C_F = "var(--stage-muted)";

package/dist/domains/math/functions/modulus-inequality/activity.mjs

@@ -3,24 +3,41 @@ import { num } from "../../../../kit/coords.mjs";
 import { OP_LATEX, modulusInequalityModel } from "./model.mjs";
 
 //#region src/domains/math/functions/modulus-inequality/activity.ts
-/** Predict the SHAPE of the solution (one connected interval, or two separate rays) before stage
-*  reveals the bands. Which bound fired and why is the authored content; this lab asks only the
-*  one question the AND/OR asymmetry turns on. */
+/** Predict the actual solution set, rather than mistaking the AND/OR branch for its shape. */
 const modulusInequalityActivity = defineActivity(modulusInequalityModel, (s) => {
 	const ineq = `$|f(x)| ${OP_LATEX[s.op]} ${num(s.k)}$`;
 	const question = {
 		id: "modulus-shape",
-		prompt: `Is the solution to ${ineq} one connected interval, or two separate rays?`,
-		choices: [{
-			value: "one",
-			label: "One interval (AND)"
-		}, {
-			value: "two",
-			label: "Two rays (OR)"
-		}],
-		answer: s.oneConnected ? "one" : "two",
-		explain: s.oneConnected ? `${ineq} is an AND: $f(x)$ has to clear both bounds at once, which is exactly one connected stretch of the line.` : `${ineq} is an OR: $f(x)$ only has to clear one tail, which lands in two separate, disconnected pieces.`,
-		tryAgain: "Look at the comparison direction, not the sign of k: less-than bounds f(x) on both sides at once; greater-than only needs one side."
+		prompt: `What shape is the solution set of ${ineq}?`,
+		choices: [
+			{
+				value: "empty",
+				label: "No real solutions"
+			},
+			{
+				value: "point",
+				label: "A single point"
+			},
+			{
+				value: "all",
+				label: "All real numbers"
+			},
+			{
+				value: "one",
+				label: "One interval"
+			},
+			{
+				value: "two",
+				label: "Two separate rays"
+			},
+			{
+				value: "multiple",
+				label: "Several separate pieces"
+			}
+		],
+		answer: s.solutionShape,
+		explain: `${s.conclusion} The AND/OR rule combines the two bounds; the resulting set also depends on $f(x)$ and $k$.`,
+		tryAgain: "Test whether the absolute value can meet the bound, including equality. AND means both bounds must hold; OR means either one can hold."
 	};
 	return {
 		pattern: "investigation",
@@ -36,13 +53,13 @@ const modulusInequalityActivity = defineActivity(modulusInequalityModel, (s) =>
 			id: "q-modulus-shape",
 			phase: "predict",
 			title: question.prompt,
-			lead: "Will the solution lie between the crossings, or outside them?",
+			lead: "Consider the bound and the crossings, including any equality cases.",
 			success: "q-modulus-shape"
 		}, {
 			id: "play",
 			phase: "observe",
 			title: "AND or OR? |f(x)| against k",
-			lead: "Read the solution bands, now confirmed by stage.",
+			lead: "Read the solution set, now confirmed by Stage.",
 			reveal: ["model", "evidence"]
 		}]
 	};

package/dist/domains/math/functions/modulus-inequality/endpoint-label-layout.mjs

@@ -0,0 +1,38 @@
+import { stageLabelBox } from "../../../../kit/diagram/label-placement.mjs";
+
+//#region src/domains/math/functions/modulus-inequality/endpoint-label-layout.ts
+/** Presentation-only lanes. Each label is measured as the Stage `<Label size={12}>` the scene draws. */
+function endpointLabelLayout(labels, width) {
+	const rows = [];
+	const placements = labels.map(({ px, text }) => {
+		const halfWidth = stageLabelBox(text, {
+			x: 0,
+			y: 0
+		}, { size: 12 }).halfWidth;
+		const labelPx = Math.max(halfWidth + 8, Math.min(width - halfWidth - 8, px));
+		const left = labelPx - halfWidth;
+		const right = labelPx + halfWidth;
+		let row = 0;
+		while (rows[row]?.some((box) => left < box.right + 8 && right > box.left - 8)) row++;
+		(rows[row] ??= []).push({
+			left,
+			right
+		});
+		const dy = (row % 2 === 0 ? 1 : -1) * (22 + Math.floor(row / 2) * 20);
+		return {
+			px,
+			labelPx,
+			dy,
+			left,
+			right
+		};
+	});
+	const extent = Math.max(0, ...placements.map(({ dy }) => Math.abs(dy)));
+	return {
+		placements,
+		height: Math.max(100, 2 * extent + 40)
+	};
+}
+
+//#endregion
+export { endpointLabelLayout };

package/dist/domains/math/functions/modulus-inequality/manifest.mjs

@@ -8,8 +8,20 @@ var manifest_default = defineLab({
 	domain: "math",
 	group: "Functions",
 	title: "AND or OR? |f(x)| against k",
-	description: "|f(x)| < k versus |f(x)| > k, side by side on one figure: the two shifted boundary lines f(x) = k and f(x) = −k, and a number line whose shape IS the answer — one connected band for the AND (less-than), two separate bands for the OR (greater-than). Backed directly by stage.inequalities.solveAbsoluteInequality’s branch/reason evidence, author-configurable in f(x), k and the comparison. Differs from the existing modulus-cases lab (a fixed, non-kernel worked example of equation case-splitting): this lab is kernel-backed and the AND/OR branch itself is the subject, not an equation walkthrough.",
+	description: "Compare |f(x)| with k using Stage’s AND/intersection and OR/union evidence. Predict and inspect the actual solution set: an interval, two rays, isolated points, several pieces, no real solutions or all real numbers. Author f(x), k and the comparison; nonlinear functions and zero or negative bounds retain their true solution topology.",
 	model: modulusInequalityModel,
+	qualityEvidence: {
+		"interaction-test": {
+			status: "planned",
+			reference: "tests/domains/math/modulus-inequality/model.test.ts",
+			note: "Existing tests cover scenarios, refusals and descriptions. A complete choice, check and reveal interaction still needs portable evidence."
+		},
+		"text-alternative": {
+			status: "verified",
+			reference: "tests/domains/math/modulus-inequality/endpoint-evidence.test.tsx",
+			note: "Included/excluded endpoint names and withheld solution evidence before reveal; model.test.ts also checks neutral descriptions."
+		}
+	},
 	examples: [
 		{
 			name: "default",
@@ -30,6 +42,38 @@ var manifest_default = defineLab({
 				k: 3,
 				op: ">"
 			}
+		},
+		{
+			name: "No real solutions",
+			props: {
+				f: "x-2",
+				k: -1,
+				op: "<"
+			}
+		},
+		{
+			name: "One point at a zero bound",
+			props: {
+				f: "x-2",
+				k: 0,
+				op: "<="
+			}
+		},
+		{
+			name: "All real numbers at a zero bound",
+			props: {
+				f: "x-2",
+				k: 0,
+				op: ">="
+			}
+		},
+		{
+			name: "Two isolated points",
+			props: {
+				f: "x^2-1",
+				k: 0,
+				op: "<="
+			}
 		}
 	],
 	experience: {