@classytic/labs 0.1.0

package/dist/statistics/sequence/preset.mjs

@@ -0,0 +1,302 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { Chip, Slider } from "../../kit/controls.mjs";
+import { ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
+import { infiniteSum, nthTerm, partialSum, partialSums, terms } from "../core/sequences.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useControlSurface } from "@classytic/stage";
+
+//#region src/statistics/sequence/preset.tsx
+/**
+* SequenceLab — arithmetic & geometric sequences you can watch grow. Each term is
+* a bar (the pattern: a steady ladder for arithmetic, an explosion or a fading
+* tail for geometric); a line traces the RUNNING TOTAL across them. The magic
+* moment is geometric convergence: when |r|<1 the running-total line flattens onto
+* a dashed S∞ guide — an infinite sum with a finite answer, seen, not just stated.
+*
+* Closed forms come from the sequences kernel and are shown (KaTeX) beside the
+* brute running total, so formula and picture are provably the same thing.
+*/
+const W = 540, H = 250, ML = 36, MR = 16, MT = 20, MB = 30;
+const PW = W - ML - MR, PH = H - MT - MB;
+const r2 = (x) => Math.round(x * 100) / 100;
+const fnum = (x) => Number.isInteger(x) ? String(x) : r2(x).toString();
+function SequenceLab({ kind = "geometric", first = 1, step = .5, count = 8, title = "Sequences & series", prompt, objectives, hints: hintList, controlId }) {
+	const [k, setK] = useState(kind);
+	const [a1, setA1] = useState(first);
+	const [d, setD] = useState(step);
+	const [n, setN] = useState(count);
+	const hints = useHints(hintList);
+	const spec = {
+		kind: k,
+		first: a1,
+		step: d
+	};
+	const ts = useMemo(() => terms(spec, n), [
+		k,
+		a1,
+		d,
+		n
+	]);
+	const sums = useMemo(() => partialSums(spec, n), [
+		k,
+		a1,
+		d,
+		n
+	]);
+	const sInf = infiniteSum(spec);
+	const Sn = partialSum(spec, n);
+	const all = [
+		0,
+		...ts,
+		...sums,
+		...sInf != null ? [sInf] : []
+	];
+	const yMax = Math.max(...all), yMin = Math.min(...all);
+	const pad = (yMax - yMin) * .08 || 1;
+	const yLo = yMin - pad, yHi = yMax + pad;
+	const yOf = (v) => 220 - (v - yLo) / (yHi - yLo) * PH;
+	const colW = PW / n;
+	const cx = (i) => ML + colW * (i + .5);
+	const y0 = yOf(0);
+	useControlSurface(controlId, {
+		kind: {
+			type: "enum",
+			label: "sequence kind",
+			options: ["arithmetic", "geometric"],
+			get: () => k,
+			set: (v) => setK(v)
+		},
+		first: {
+			type: "number",
+			label: "first term a₁",
+			min: -5,
+			max: 10,
+			step: .5,
+			get: () => a1,
+			set: setA1
+		},
+		step: {
+			type: "number",
+			label: k === "arithmetic" ? "common difference d" : "common ratio r",
+			min: k === "arithmetic" ? -5 : -2,
+			max: k === "arithmetic" ? 5 : 2,
+			step: k === "arithmetic" ? 1 : .1,
+			get: () => d,
+			set: setD
+		},
+		count: {
+			type: "number",
+			label: "how many terms",
+			min: 2,
+			max: 16,
+			step: 1,
+			get: () => n,
+			set: setN
+		}
+	});
+	const isArith = k === "arithmetic";
+	const termTex = isArith ? `a_n = ${fnum(a1)} + (n-1)\\cdot ${fnum(d)}` : `a_n = ${fnum(a1)}\\cdot (${fnum(d)})^{\\,n-1}`;
+	const sumTex = isArith ? `S_n = \\tfrac{n}{2}\\,(2a_1+(n-1)d)` : `S_n = a_1\\dfrac{1-r^{\\,n}}{1-r}`;
+	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsxs("div", {
+			className: "lab-bar",
+			style: {
+				gap: 8,
+				flexWrap: "wrap"
+			},
+			children: [/* @__PURE__ */ jsx(Chip, {
+				selected: isArith,
+				onClick: () => setK("arithmetic"),
+				children: "arithmetic (+d)"
+			}), /* @__PURE__ */ jsx(Chip, {
+				selected: !isArith,
+				onClick: () => setK("geometric"),
+				children: "geometric (×r)"
+			})]
+		}),
+		/* @__PURE__ */ jsx("div", {
+			style: {
+				borderRadius: 14,
+				background: "var(--stage-bg)",
+				border: "1px solid var(--stage-grid)",
+				padding: 8
+			},
+			children: /* @__PURE__ */ jsxs("svg", {
+				viewBox: `0 0 ${W} ${H}`,
+				style: {
+					width: "100%",
+					maxWidth: W,
+					height: "auto",
+					display: "block"
+				},
+				role: "img",
+				"aria-label": `${k} sequence, ${n} terms, running total ${fnum(Sn)}`,
+				children: [
+					/* @__PURE__ */ jsx("line", {
+						x1: ML,
+						y1: y0,
+						x2: W - MR,
+						y2: y0,
+						stroke: "var(--stage-muted)",
+						strokeWidth: 1
+					}),
+					sInf != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("line", {
+						x1: ML,
+						y1: yOf(sInf),
+						x2: W - MR,
+						y2: yOf(sInf),
+						stroke: "var(--stage-good)",
+						strokeWidth: 1.5,
+						strokeDasharray: "6 5"
+					}), /* @__PURE__ */ jsxs("text", {
+						x: W - MR,
+						y: yOf(sInf) - 5,
+						textAnchor: "end",
+						fontSize: 11,
+						fontWeight: 700,
+						fill: "var(--stage-good)",
+						children: ["S∞ = ", fnum(sInf)]
+					})] }),
+					ts.map((t, i) => {
+						const bw = Math.min(28, colW * .5);
+						const top = Math.min(yOf(t), y0), h = Math.abs(yOf(t) - y0);
+						return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
+							x: cx(i) - bw / 2,
+							y: top,
+							width: bw,
+							height: Math.max(.5, h),
+							rx: 3,
+							fill: "color-mix(in oklab, var(--stage-accent) 78%, transparent)"
+						}), /* @__PURE__ */ jsx("text", {
+							x: cx(i),
+							y: y0 + (t >= 0 ? 14 : -6),
+							textAnchor: "middle",
+							fontSize: 10,
+							fill: "var(--stage-muted)",
+							children: i + 1
+						})] }, i);
+					}),
+					/* @__PURE__ */ jsx("polyline", {
+						points: sums.map((s, i) => `${cx(i)},${yOf(s)}`).join(" "),
+						fill: "none",
+						stroke: "var(--stage-good)",
+						strokeWidth: 2.5
+					}),
+					sums.map((s, i) => /* @__PURE__ */ jsx("circle", {
+						cx: cx(i),
+						cy: yOf(s),
+						r: 3,
+						fill: "var(--stage-good)"
+					}, i))
+				]
+			})
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				gap: 16,
+				flexWrap: "wrap",
+				alignItems: "center",
+				margin: "10px 0",
+				fontVariantNumeric: "tabular-nums"
+			},
+			children: [
+				/* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(Tex$1, { tex: termTex }) }),
+				/* @__PURE__ */ jsx("span", {
+					style: {
+						color: "var(--stage-accent)",
+						fontWeight: 700
+					},
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `a_{${n}} = ${fnum(nthTerm(spec, n))}` })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					style: {
+						color: "var(--stage-good)",
+						fontWeight: 700
+					},
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `S_{${n}} = ${fnum(Sn)}` })
+				}),
+				sInf != null ? /* @__PURE__ */ jsx("span", {
+					style: {
+						color: "var(--stage-good)",
+						fontWeight: 700
+					},
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `S_\\infty = ${fnum(sInf)}` })
+				}) : !isArith && /* @__PURE__ */ jsxs("span", {
+					style: {
+						color: "var(--stage-bad)",
+						fontWeight: 600
+					},
+					children: [
+						"diverges (",
+						/* @__PURE__ */ jsx(Tex$1, { tex: "|r| \\\\ge 1" }),
+						")"
+					]
+				})
+			]
+		})
+	] });
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Field, {
+				label: "a₁",
+				value: fnum(a1),
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: a1,
+					min: -5,
+					max: 10,
+					step: .5,
+					onChange: setA1,
+					ariaLabel: "first term"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: isArith ? "d" : "r",
+				value: fnum(d),
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: d,
+					min: isArith ? -5 : -2,
+					max: isArith ? 5 : 2,
+					step: isArith ? 1 : .1,
+					onChange: setD,
+					ariaLabel: isArith ? "common difference" : "common ratio"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "terms",
+				value: n,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: n,
+					min: 2,
+					max: 16,
+					step: 1,
+					onChange: setN,
+					ariaLabel: "number of terms"
+				})
+			})
+		] }),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("p", {
+			style: {
+				fontSize: 12.5,
+				color: "var(--stage-muted)",
+				marginTop: 4
+			},
+			children: [/* @__PURE__ */ jsx(Tex$1, { tex: sumTex }), !isArith && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				" — with ",
+				/* @__PURE__ */ jsx(Tex$1, { tex: "|r| < 1" }),
+				" the tail shrinks to nothing, so the total converges."
+			] })]
+		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
+		children: figure
+	});
+}
+
+//#endregion
+export { SequenceLab };

package/dist/statistics/z-table/preset.d.mts

@@ -0,0 +1,28 @@
+import { ReactNode } from "react";
+
+//#region src/statistics/z-table/preset.d.ts
+type ZTail = 'left' | 'right';
+interface ZTableProps {
+  x?: number;
+  mu?: number;
+  sigma?: number;
+  tail?: ZTail;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  hints?: string[];
+  controlId?: string;
+}
+declare function ZTableLab({
+  x,
+  mu,
+  sigma,
+  tail,
+  title,
+  prompt,
+  objectives,
+  hints: hintList,
+  controlId
+}: ZTableProps): ReactNode;
+//#endregion
+export { ZTableLab, ZTableProps, ZTail };

package/dist/statistics/z-table/preset.mjs

@@ -0,0 +1,348 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { Chip } from "../../kit/controls.mjs";
+import { ControlBar, LabFrame } from "../../kit/frame.mjs";
+import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
+import { normalCdf, normalPdf, zScore } from "../core/normal.mjs";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useControlSurface } from "@classytic/stage";
+
+//#region src/statistics/z-table/preset.tsx
+/**
+* ZTableLab — read a z-table like the exam expects, and see what each lookup MEANS.
+* Standardize a raw value (x → z = (x−μ)/σ), then the classic Φ(z) table lights up
+* the row/column and cell for that z, while a mini standard-normal curve shades the
+* matching tail and shows the probability. Click any cell to jump there (and the
+* raw value x updates to stay consistent). Negative z is handled by the symmetry
+* Φ(−z) = 1 − Φ(z), spelled out rather than hidden.
+*
+* Φ comes from the normal kernel (`normalCdf`); the table is just that function laid
+* out as the familiar grid — one source of truth, no transcribed magic numbers.
+*/
+const CW = 230, CH = 116, CPAD = 6;
+const ROWS = Array.from({ length: 35 }, (_, i) => i / 10);
+const COLS = Array.from({ length: 10 }, (_, j) => j / 100);
+const f2 = (x) => x.toFixed(2);
+const f4 = (x) => x.toFixed(4);
+function ZTableLab({ x = 650, mu = 500, sigma = 100, tail = "left", title = "The z-table", prompt, objectives, hints: hintList, controlId }) {
+	const [xv, setXv] = useState(x);
+	const [m, setM] = useState(mu);
+	const [sg, setSg] = useState(sigma);
+	const [t, setT] = useState(tail);
+	const hints = useHints(hintList);
+	const z = zScore(xv, m, sg);
+	const phi = normalCdf(z);
+	const prob = t === "left" ? phi : 1 - phi;
+	const zLook = Math.round(Math.min(3.49, Math.abs(z)) * 100) / 100;
+	const xMinC = -3.5, xMaxC = 3.5, yMaxC = normalPdf(0) * 1.1;
+	const cx = (v) => CPAD + (v - xMinC) / (xMaxC - xMinC) * (CW - 2 * CPAD);
+	const cy = (v) => CH - 16 - v / yMaxC * (CH - 26);
+	const curve = useMemo(() => Array.from({ length: 121 }, (_, i) => {
+		const v = xMinC + i / 120 * (xMaxC - xMinC);
+		return `${cx(v).toFixed(1)},${cy(normalPdf(v)).toFixed(1)}`;
+	}).join(" "), []);
+	const shade = useMemo(() => {
+		const loX = t === "left" ? xMinC : z, hiX = t === "left" ? z : xMaxC;
+		const a0 = Math.max(xMinC, Math.min(loX, hiX)), a1 = Math.min(xMaxC, Math.max(loX, hiX));
+		const pts = [`${cx(a0).toFixed(1)},${cy(0).toFixed(1)}`];
+		for (let i = 0; i <= 60; i++) {
+			const v = a0 + i / 60 * (a1 - a0);
+			pts.push(`${cx(v).toFixed(1)},${cy(normalPdf(v)).toFixed(1)}`);
+		}
+		pts.push(`${cx(a1).toFixed(1)},${cy(0).toFixed(1)}`);
+		return `M${pts.join(" L")} Z`;
+	}, [z, t]);
+	const pickCell = (rz, cz) => {
+		const zz = (z < 0 ? -1 : 1) * (rz + cz);
+		setXv(Math.round((m + zz * sg) * 100) / 100);
+	};
+	const scrollBox = useRef(null);
+	const selRow = useRef(null);
+	useEffect(() => {
+		const box = scrollBox.current, row = selRow.current;
+		if (!box || !row) return;
+		const br = box.getBoundingClientRect(), rr = row.getBoundingClientRect();
+		box.scrollTop += rr.top - br.top - box.clientHeight / 2 + rr.height / 2;
+	}, [zLook]);
+	useControlSurface(controlId, {
+		x: {
+			type: "number",
+			label: "raw value x",
+			min: -1e4,
+			max: 1e4,
+			step: 1,
+			get: () => xv,
+			set: setXv
+		},
+		mu: {
+			type: "number",
+			label: "mean μ",
+			min: -1e4,
+			max: 1e4,
+			step: 1,
+			get: () => m,
+			set: setM
+		},
+		sigma: {
+			type: "number",
+			label: "std dev σ",
+			min: .1,
+			max: 1e4,
+			step: 1,
+			get: () => sg,
+			set: setSg
+		},
+		tail: {
+			type: "enum",
+			label: "tail",
+			options: ["left", "right"],
+			get: () => t,
+			set: (v) => setT(v)
+		}
+	});
+	const numIn = (val, set, w = 64) => /* @__PURE__ */ jsx("input", {
+		type: "number",
+		value: Number.isInteger(val) ? val : Number(val.toFixed(2)),
+		onChange: (e) => set(Number(e.target.value)),
+		style: {
+			width: w,
+			padding: "3px 6px",
+			borderRadius: 6,
+			border: "1px solid var(--stage-grid)",
+			background: "var(--stage-bg)",
+			color: "var(--stage-fg)",
+			fontWeight: 700,
+			fontVariantNumeric: "tabular-nums"
+		}
+	});
+	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				gap: 18,
+				flexWrap: "wrap",
+				alignItems: "center",
+				margin: "6px 0"
+			},
+			children: [/* @__PURE__ */ jsxs("div", {
+				style: {
+					display: "flex",
+					gap: 6,
+					alignItems: "center",
+					flexWrap: "wrap",
+					fontSize: 14
+				},
+				children: [
+					/* @__PURE__ */ jsxs("span", { children: ["x = ", numIn(xv, setXv)] }),
+					/* @__PURE__ */ jsxs("span", {
+						style: { color: "var(--stage-muted)" },
+						children: [
+							"from N(",
+							/* @__PURE__ */ jsx(Tex$1, { tex: "\\\\mu" }),
+							"=",
+							numIn(m, setM, 56),
+							", ",
+							/* @__PURE__ */ jsx(Tex$1, { tex: "\\\\sigma" }),
+							"=",
+							numIn(sg, setSg, 52),
+							")"
+						]
+					}),
+					/* @__PURE__ */ jsxs("span", {
+						style: { fontWeight: 800 },
+						children: [
+							/* @__PURE__ */ jsx(Tex$1, { tex: "\\\\to z =" }),
+							" ",
+							/* @__PURE__ */ jsx("span", {
+								style: { color: "var(--stage-accent)" },
+								children: f2(z)
+							})
+						]
+					})
+				]
+			}), /* @__PURE__ */ jsxs("div", {
+				style: {
+					flex: 1,
+					minWidth: 230,
+					display: "flex",
+					alignItems: "center",
+					gap: 12
+				},
+				children: [/* @__PURE__ */ jsxs("svg", {
+					viewBox: `0 0 ${CW} ${CH}`,
+					style: {
+						width: 230,
+						height: "auto"
+					},
+					role: "img",
+					"aria-label": `standard normal, ${t} tail at z ${f2(z)}, area ${f4(prob)}`,
+					children: [
+						/* @__PURE__ */ jsx("path", {
+							d: shade,
+							fill: "color-mix(in oklab, var(--stage-accent) 36%, transparent)"
+						}),
+						/* @__PURE__ */ jsx("line", {
+							x1: CPAD,
+							y1: cy(0),
+							x2: CW - CPAD,
+							y2: cy(0),
+							stroke: "var(--stage-fg)",
+							strokeWidth: 1.2
+						}),
+						/* @__PURE__ */ jsx("polyline", {
+							points: curve,
+							fill: "none",
+							stroke: "var(--stage-fg)",
+							strokeWidth: 2
+						}),
+						/* @__PURE__ */ jsx("line", {
+							x1: cx(z),
+							y1: cy(0),
+							x2: cx(z),
+							y2: 16,
+							stroke: "var(--stage-accent)",
+							strokeWidth: 1.5,
+							strokeDasharray: "4 3"
+						}),
+						/* @__PURE__ */ jsxs("text", {
+							x: cx(Math.max(-3.1, Math.min(xMaxC - .4, z))),
+							y: CH - 3,
+							textAnchor: "middle",
+							fontSize: 10,
+							fill: "var(--stage-accent)",
+							fontWeight: 700,
+							children: ["z=", f2(z)]
+						})
+					]
+				}), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("div", {
+					style: {
+						fontSize: 20,
+						fontWeight: 800,
+						color: "var(--stage-good)"
+					},
+					children: [(prob * 100).toFixed(2), "%"]
+				}), /* @__PURE__ */ jsx("div", {
+					style: {
+						fontSize: 12,
+						color: "var(--stage-muted)"
+					},
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `P(Z ${t === "left" ? "\\le" : "\\ge"} ${f2(z)})` })
+				})] })]
+			})]
+		}),
+		z < 0 && /* @__PURE__ */ jsxs("p", {
+			className: "lab-prompt",
+			style: { marginTop: 6 },
+			children: [
+				"z is negative — the table lists |z|; use symmetry ",
+				/* @__PURE__ */ jsx("b", { children: /* @__PURE__ */ jsx(Tex$1, { tex: `\\Phi(${f2(z)}) = 1 - \\Phi(${f2(-z)}) = ${f4(phi)}` }) }),
+				"."
+			]
+		}),
+		/* @__PURE__ */ jsx("div", {
+			ref: scrollBox,
+			style: {
+				overflow: "auto",
+				maxHeight: 300,
+				borderRadius: 10,
+				border: "1px solid var(--stage-grid)",
+				marginTop: 8
+			},
+			children: /* @__PURE__ */ jsxs("table", {
+				style: {
+					borderCollapse: "collapse",
+					fontVariantNumeric: "tabular-nums",
+					fontSize: 11
+				},
+				children: [/* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [/* @__PURE__ */ jsx("th", {
+					style: {
+						position: "sticky",
+						top: 0,
+						left: 0,
+						zIndex: 2,
+						background: "var(--stage-bg)",
+						padding: "4px 6px",
+						borderBottom: "2px solid var(--stage-grid)",
+						color: "var(--stage-accent)"
+					},
+					children: "z"
+				}), COLS.map((c) => /* @__PURE__ */ jsxs("th", {
+					style: {
+						position: "sticky",
+						top: 0,
+						background: Math.abs(zLook * 100 % 10 / 100 - c) < .005 ? "color-mix(in oklab, var(--stage-accent) 18%, var(--stage-bg))" : "var(--stage-bg)",
+						padding: "4px 6px",
+						borderBottom: "2px solid var(--stage-grid)",
+						color: "var(--stage-muted)"
+					},
+					children: [".", (c * 100).toFixed(0).padStart(2, "0")]
+				}, c))] }) }), /* @__PURE__ */ jsx("tbody", { children: ROWS.map((r) => {
+					const rowSel = Math.abs(Math.floor(zLook * 10) / 10 - r) < .005;
+					return /* @__PURE__ */ jsxs("tr", {
+						ref: rowSel ? selRow : void 0,
+						children: [/* @__PURE__ */ jsx("td", {
+							style: {
+								position: "sticky",
+								left: 0,
+								background: rowSel ? "color-mix(in oklab, var(--stage-accent) 18%, var(--stage-bg))" : "var(--stage-bg)",
+								padding: "3px 6px",
+								fontWeight: 700,
+								color: "var(--stage-accent)",
+								borderRight: "1px solid var(--stage-grid)"
+							},
+							children: r.toFixed(1)
+						}), COLS.map((c) => {
+							const cellZ = r + c;
+							const sel = Math.abs(cellZ - zLook) < .005;
+							return /* @__PURE__ */ jsx("td", {
+								onClick: () => pickCell(r, c),
+								style: {
+									padding: "3px 6px",
+									textAlign: "right",
+									cursor: "pointer",
+									borderBottom: "1px solid color-mix(in oklab, var(--stage-grid) 50%, transparent)",
+									background: sel ? "var(--stage-good)" : rowSel ? "color-mix(in oklab, var(--stage-accent) 7%, transparent)" : void 0,
+									color: sel ? "white" : "var(--stage-fg)",
+									fontWeight: sel ? 800 : 400
+								},
+								children: f4(normalCdf(cellZ))
+							}, c);
+						})]
+					}, r);
+				}) })]
+			})
+		})
+	] });
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [/* @__PURE__ */ jsx(Chip, {
+			selected: t === "left",
+			onClick: () => setT("left"),
+			children: "left tail Φ(z)"
+		}), /* @__PURE__ */ jsx(Chip, {
+			selected: t === "right",
+			onClick: () => setT("right"),
+			children: "right tail 1−Φ(z)"
+		})] }),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("p", {
+			style: {
+				fontSize: 12,
+				color: "var(--stage-muted)",
+				marginTop: 6
+			},
+			children: [
+				"The table gives ",
+				/* @__PURE__ */ jsx(Tex$1, { tex: "\\\\Phi(z) = P(Z \\\\le z)" }),
+				". Row = z to one decimal, column = the hundredths digit. Click a cell to jump there."
+			]
+		}), /* @__PURE__ */ jsx(HintLadder, { hints })] }),
+		children: figure
+	});
+}
+
+//#endregion
+export { ZTableLab };