@classytic/labs 0.1.0

package/dist/schemas/index.mjs

@@ -0,0 +1,145 @@
+import { z } from "zod";
+
+//#region src/schemas/index.ts
+/**
+* @classytic/labs/schemas — the validation contract for every authorable lab.
+*
+* Real zod schemas for the lab DATA shapes (decks, tiles, items, vectors) that the
+* language + physics blocks reuse to validate authored arrays (no `z.any()`). zod is
+* isolated to this subpath + `/blocks`.
+*
+* Per-lab PROP schemas are NOT here — each lives on its own `defineBlock({ schema })`
+* (the single source of truth), so there's no parallel registry to drift. A consuming
+* app builds LLM tools straight from the block schemas if it wants.
+*
+* Source-of-truth note: the TS interfaces live in the (zod-free) domain presets;
+* the `_check*` lines below assert each schema's output stays assignable to its
+* interface so the two can't silently drift.
+*/
+const posSchema = z.enum([
+	"noun",
+	"verb",
+	"article",
+	"adjective",
+	"preposition",
+	"pronoun",
+	"conjunction",
+	"adverb",
+	"other"
+]);
+const relationSchema = z.enum([
+	"in",
+	"on",
+	"over",
+	"above",
+	"under",
+	"below",
+	"beside",
+	"between",
+	"behind",
+	"infront",
+	"at"
+]);
+const articleAnswerSchema = z.enum([
+	"a",
+	"an",
+	"the",
+	"—"
+]);
+const vec2Schema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+/** A durable visual-asset reference (emoji / registered SVG id / image URL). */
+const iconRefSchema = z.object({
+	kind: z.enum([
+		"emoji",
+		"svg",
+		"image"
+	]),
+	id: z.string().optional().describe("emoji char, or a registered svg id"),
+	src: z.string().optional().describe("image URL (kind:image)"),
+	alt: z.string().describe("accessible label; \"\" = decorative")
+});
+/** Back-compat union: a plain string (emoji, or a scene backdrop key) OR an IconRef. */
+const iconValueSchema = z.union([z.string(), iconRefSchema]);
+const deckItemSchema = z.object({
+	term: z.string().describe("the target-language word/phrase"),
+	translation: z.string().describe("the learner's-language meaning"),
+	transliteration: z.string().optional(),
+	audioUrl: z.string().optional().describe("uploaded or external audio URL; none → browser TTS"),
+	icon: iconValueSchema.optional().describe("emoji string, or an IconRef for a registered SVG / image"),
+	example: z.string().optional(),
+	tags: z.array(z.string()).optional()
+});
+const deckSchema = z.object({
+	title: z.string().optional(),
+	termLang: z.string().describe("BCP-47, e.g. en-US / ar / bn-BD"),
+	transLang: z.string().describe("BCP-47 of the translation side"),
+	items: z.array(deckItemSchema)
+});
+const sentenceTileSchema = z.object({
+	text: z.string(),
+	pos: posSchema.optional(),
+	gloss: z.string().optional()
+});
+const transformTileSchema = sentenceTileSchema;
+const articleItemSchema = z.object({
+	before: z.string(),
+	noun: z.string(),
+	after: z.string().optional(),
+	answer: articleAnswerSchema,
+	why: z.string().optional()
+});
+const agreementItemSchema = z.object({
+	subject: z.string(),
+	options: z.array(z.string()),
+	correct: z.string(),
+	tail: z.string().optional(),
+	note: z.string().optional()
+});
+const prepItemSchema = z.object({
+	before: z.string(),
+	noun: z.string(),
+	answer: z.string(),
+	options: z.array(z.string()),
+	scene: relationSchema,
+	figure: iconValueSchema.optional().describe("emoji/IconRef for the placed thing"),
+	landmark: iconValueSchema.optional().describe("emoji/IconRef, or a backdrop key: 'sky'|'water'|'ground'|'room'"),
+	note: z.string().optional()
+});
+const boardVectorSchema = z.object({
+	id: z.string().optional(),
+	tail: vec2Schema.optional(),
+	comp: vec2Schema,
+	color: z.string().optional(),
+	label: z.string().optional(),
+	drag: z.boolean().optional()
+});
+/** Block-authoring shape (flat dx/dy; the view maps to {comp:{x,y}}). */
+const flatVecSchema = z.object({
+	label: z.string().optional(),
+	dx: z.union([z.number(), z.string()]).optional(),
+	dy: z.union([z.number(), z.string()]).optional(),
+	color: z.string().optional(),
+	drag: z.boolean().optional()
+});
+const typePanelSchema = z.object({
+	name: z.string(),
+	caption: z.string(),
+	vectors: z.array(z.object({
+		tail: vec2Schema.optional(),
+		comp: vec2Schema,
+		color: z.string().optional(),
+		label: z.string().optional()
+	})).optional(),
+	origin: z.boolean().optional()
+});
+/** Per-knob hide/lock policy a creator authors on any lab block. */
+const controlConfigSchema = z.object({
+	hide: z.array(z.string()).optional().describe("control names the learner cannot see or change"),
+	lock: z.array(z.string()).optional().describe("control names shown read-only, frozen at the authored value")
+});
+
+//#endregion
+export { agreementItemSchema, articleAnswerSchema, articleItemSchema, boardVectorSchema, controlConfigSchema, deckItemSchema, deckSchema, flatVecSchema, iconRefSchema, iconValueSchema, posSchema, prepItemSchema, relationSchema, sentenceTileSchema, transformTileSchema, typePanelSchema, vec2Schema };

package/dist/statistics/center-spread/preset.d.mts

@@ -0,0 +1,34 @@
+import { ReactNode } from "react";
+
+//#region src/statistics/center-spread/preset.d.ts
+interface CenterSpreadProps {
+  data?: number[];
+  min?: number;
+  max?: number;
+  step?: number;
+  showSigma?: boolean;
+  challenge?: {
+    stat: 'mean' | 'median';
+    target: number;
+  };
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  hints?: string[];
+  controlId?: string;
+}
+declare function CenterSpreadLab({
+  data,
+  min,
+  max,
+  step,
+  showSigma,
+  challenge,
+  title,
+  prompt,
+  objectives,
+  hints: hintList,
+  controlId
+}: CenterSpreadProps): ReactNode;
+//#endregion
+export { CenterSpreadLab, CenterSpreadProps };

package/dist/statistics/center-spread/preset.mjs

@@ -0,0 +1,323 @@
+'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, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
+import { frequencies, mean, median, mode, range, stddev, variance } from "../core/descriptive.mjs";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useControlSurface } from "@classytic/stage";
+
+//#region src/statistics/center-spread/preset.tsx
+/**
+* CenterSpreadLab — centre & spread you can FEEL. Data points sit on a number
+* line; drag them and the mean rides under the line as a BALANCE-POINT fulcrum
+* (the mean is literally where the data balances), the median holds its ground,
+* the mode stack lights up, and a shaded mean ± σ band breathes wider as the data
+* spreads. The punchline lives in the dragging: yank one point far out and the
+* mean chases it while the median barely moves — why we report the median for
+* skewed data. Optional `challenge` turns it into "drag until the mean is 5".
+*
+* All numbers come from the descriptive-stats kernel; the lab only POINTS at them.
+*/
+const W = 500, H = 210, M = 34, AXIS = 150;
+function CenterSpreadLab({ data = [
+	2,
+	3,
+	3,
+	5,
+	8
+], min = 0, max = 10, step = 1, showSigma = true, challenge, title = "Centre & spread", prompt, objectives, hints: hintList, controlId }) {
+	const [vals, setVals] = useState(data);
+	const hints = useHints(hintList);
+	const svgRef = useRef(null);
+	const drag = useRef(null);
+	const lo = min, hi = max;
+	const xOf = (v) => M + (v - lo) / (hi - lo) * (W - 2 * M);
+	const vOf = (px) => {
+		const v = lo + (px - M) / (W - 2 * M) * (hi - lo);
+		return Math.max(lo, Math.min(hi, Math.round(v / step) * step));
+	};
+	const mu = mean(vals), md = median(vals), mo = mode(vals), rg = range(vals), sd = stddev(vals);
+	const freqs = frequencies(vals);
+	Math.max(1, ...freqs.map((f) => f.count));
+	const stacked = useMemo(() => {
+		const seen = /* @__PURE__ */ new Map();
+		return vals.map((v, i) => {
+			const k = seen.get(v) ?? 0;
+			seen.set(v, k + 1);
+			return {
+				v,
+				i,
+				level: k
+			};
+		});
+	}, [vals]);
+	const pointerVal = (e) => {
+		const r = svgRef.current.getBoundingClientRect();
+		return vOf((e.clientX - r.left) / r.width * W);
+	};
+	const onDown = (i) => (e) => {
+		drag.current = i;
+		e.target.setPointerCapture(e.pointerId);
+	};
+	const onMove = (e) => {
+		if (drag.current == null) return;
+		const nv = pointerVal(e);
+		setVals((arr) => arr.map((x, k) => k === drag.current ? nv : x));
+	};
+	const onUp = () => {
+		drag.current = null;
+	};
+	const reset = useCallback(() => setVals(data), [data]);
+	const addPoint = useCallback(() => setVals((a) => [...a, Math.round((lo + hi) / 2 / step) * step]), [
+		lo,
+		hi,
+		step
+	]);
+	const removePoint = useCallback(() => setVals((a) => a.length > 1 ? a.slice(0, -1) : a), []);
+	const addOutlier = useCallback(() => setVals((a) => [...a, hi]), [hi]);
+	const solved = challenge ? Math.abs((challenge.stat === "mean" ? mu : md) - challenge.target) < 1e-6 : false;
+	useCheckpoint({
+		solved,
+		activity: `center-spread:${title}`,
+		hintsUsed: hints.count
+	});
+	useControlSurface(controlId, {
+		add: {
+			type: "action",
+			label: "add a point",
+			invoke: addPoint
+		},
+		remove: {
+			type: "action",
+			label: "remove a point",
+			invoke: removePoint
+		},
+		outlier: {
+			type: "action",
+			label: "add an outlier",
+			invoke: addOutlier
+		},
+		reset: {
+			type: "action",
+			label: "reset data",
+			invoke: reset
+		}
+	});
+	const sigmaL = Math.max(lo, mu - sd), sigmaR = Math.min(hi, mu + sd);
+	const ticks = Array.from({ length: Math.floor((hi - lo) / step) + 1 }, (_, i) => lo + i * step).filter((_, i, a) => a.length <= 12 || i % Math.ceil(a.length / 12) === 0);
+	const stat = (label, value, color = "var(--stage-fg)") => /* @__PURE__ */ jsxs("span", {
+		style: {
+			display: "inline-flex",
+			flexDirection: "column",
+			alignItems: "center",
+			minWidth: 64
+		},
+		children: [/* @__PURE__ */ jsx("span", {
+			style: {
+				fontSize: 11,
+				color: "var(--stage-muted)",
+				fontWeight: 600
+			},
+			children: label
+		}), /* @__PURE__ */ jsx("span", {
+			style: {
+				fontSize: 17,
+				fontWeight: 800,
+				color,
+				fontVariantNumeric: "tabular-nums"
+			},
+			children: value
+		})]
+	});
+	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		challenge && /* @__PURE__ */ jsxs("p", {
+			style: {
+				fontWeight: 600,
+				color: solved ? "var(--stage-good)" : "var(--stage-fg)"
+			},
+			children: [
+				solved ? "✓ " : "🎯 ",
+				"Drag the points until the ",
+				/* @__PURE__ */ jsx("b", { children: challenge.stat }),
+				" = ",
+				challenge.target,
+				"."
+			]
+		}),
+		/* @__PURE__ */ jsx("div", {
+			style: {
+				borderRadius: 14,
+				background: "var(--stage-bg)",
+				border: "1px solid var(--stage-grid)",
+				padding: 8,
+				touchAction: "none"
+			},
+			children: /* @__PURE__ */ jsxs("svg", {
+				ref: svgRef,
+				viewBox: `0 0 ${W} ${H}`,
+				style: {
+					width: "100%",
+					maxWidth: W,
+					height: "auto",
+					display: "block",
+					margin: "0 auto"
+				},
+				onPointerMove: onMove,
+				onPointerUp: onUp,
+				onPointerLeave: onUp,
+				role: "img",
+				"aria-label": `number line; mean ${mu.toFixed(2)}, median ${md}`,
+				children: [
+					showSigma && sd > 0 && /* @__PURE__ */ jsx("rect", {
+						x: xOf(sigmaL),
+						y: AXIS - 96,
+						width: xOf(sigmaR) - xOf(sigmaL),
+						height: 96,
+						fill: "color-mix(in oklab, var(--stage-accent) 12%, transparent)"
+					}),
+					/* @__PURE__ */ jsx("line", {
+						x1: M,
+						y1: AXIS,
+						x2: W - M,
+						y2: AXIS,
+						stroke: "var(--stage-fg)",
+						strokeWidth: 2
+					}),
+					ticks.map((t) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("line", {
+						x1: xOf(t),
+						y1: AXIS,
+						x2: xOf(t),
+						y2: 155,
+						stroke: "var(--stage-muted)",
+						strokeWidth: 1.5
+					}), /* @__PURE__ */ jsx("text", {
+						x: xOf(t),
+						y: 168,
+						textAnchor: "middle",
+						fontSize: 11,
+						fill: "var(--stage-muted)",
+						style: { fontVariantNumeric: "tabular-nums" },
+						children: t
+					})] }, t)),
+					/* @__PURE__ */ jsx("line", {
+						x1: xOf(md),
+						y1: AXIS - 104,
+						x2: xOf(md),
+						y2: AXIS,
+						stroke: "var(--stage-accent-2, #d6336c)",
+						strokeWidth: 2,
+						strokeDasharray: "5 4"
+					}),
+					/* @__PURE__ */ jsxs("text", {
+						x: xOf(md),
+						y: AXIS - 110,
+						textAnchor: "middle",
+						fontSize: 11,
+						fontWeight: 700,
+						fill: "var(--stage-accent-2, #d6336c)",
+						children: ["median ", md]
+					}),
+					stacked.map(({ v, i, level }) => {
+						const cy = AXIS - 14 - level * 19;
+						const isMode = mo.includes(v) && mo.length > 0;
+						return /* @__PURE__ */ jsx("circle", {
+							cx: xOf(v),
+							cy,
+							r: 9,
+							fill: isMode ? "var(--stage-warn)" : "var(--stage-accent)",
+							stroke: "var(--stage-bg)",
+							strokeWidth: 2,
+							onPointerDown: onDown(i),
+							style: {
+								cursor: "grab",
+								transition: drag.current === i ? "none" : "cx .08s, cy .08s"
+							}
+						}, i);
+					}),
+					/* @__PURE__ */ jsxs("g", {
+						style: {
+							transition: drag.current == null ? "transform .1s" : "none",
+							transform: `translateX(${xOf(mu) - W / 2}px)`
+						},
+						children: [/* @__PURE__ */ jsx("path", {
+							d: `M${W / 2},151 l-9,16 h18 Z`,
+							fill: "var(--stage-good)"
+						}), /* @__PURE__ */ jsxs("text", {
+							x: W / 2,
+							y: 180,
+							textAnchor: "middle",
+							fontSize: 11,
+							fontWeight: 800,
+							fill: "var(--stage-good)",
+							children: ["mean ", mu.toFixed(2)]
+						})]
+					})
+				]
+			})
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				gap: 8,
+				flexWrap: "wrap",
+				justifyContent: "center",
+				margin: "12px 0",
+				padding: "8px 0",
+				borderTop: "1px solid var(--stage-grid)",
+				borderBottom: "1px solid var(--stage-grid)"
+			},
+			children: [
+				stat("mean", mu.toFixed(2), "var(--stage-good)"),
+				stat("median", String(md), "var(--stage-accent-2, #d6336c)"),
+				stat("mode", mo.length ? mo.join(", ") : "—", "var(--stage-warn)"),
+				stat("range", String(rg)),
+				stat("variance", variance(vals).toFixed(2)),
+				stat(/* @__PURE__ */ jsx(Tex$1, { tex: "\\\\sigma" }), sd.toFixed(2), "var(--stage-accent)"),
+				stat("n", String(vals.length))
+			]
+		})
+	] });
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Chip, {
+				selected: false,
+				onClick: addPoint,
+				children: "+ point"
+			}),
+			/* @__PURE__ */ jsx(Chip, {
+				selected: false,
+				onClick: removePoint,
+				children: "− point"
+			}),
+			/* @__PURE__ */ jsx(Chip, {
+				selected: false,
+				onClick: addOutlier,
+				children: "add outlier"
+			}),
+			/* @__PURE__ */ jsx(Chip, {
+				selected: false,
+				onClick: reset,
+				children: "reset"
+			}),
+			/* @__PURE__ */ jsx("span", {
+				style: {
+					fontSize: 12,
+					color: "var(--stage-muted)",
+					alignSelf: "center"
+				},
+				children: "drag the dots ↔"
+			})
+		] }),
+		footer: /* @__PURE__ */ jsx(HintLadder, { hints }),
+		children: figure
+	});
+}
+
+//#endregion
+export { CenterSpreadLab };

package/dist/statistics/core/descriptive.d.mts

@@ -0,0 +1,35 @@
+//#region src/statistics/core/descriptive.d.ts
+/**
+ * Descriptive statistics — the pure kernel the statistics labs trust as the
+ * source of truth (centre, spread, position). No dependencies; every lab POINTS
+ * to these numbers rather than recomputing them, so the figure and the readout
+ * can never disagree. Median uses the standard average-of-middle-two for even n;
+ * variance/σ default to the POPULATION form (divide by n) with a `sample` flag
+ * for the n−1 (Bessel) form.
+ */
+declare const sum: (xs: number[]) => number;
+declare const mean: (xs: number[]) => number;
+declare function median(xs: number[]): number;
+/** Every value tied for the highest frequency (multimodal-aware), sorted. */
+declare function mode(xs: number[]): number[];
+declare const range: (xs: number[]) => number;
+declare function variance(xs: number[], sample?: boolean): number;
+declare const stddev: (xs: number[], sample?: boolean) => number;
+/** Linear-interpolated quantile (q in [0,1]) — the inclusive "p = (n−1)q" method. */
+declare function quantile(xs: number[], q: number): number;
+interface FiveNumber {
+  min: number;
+  q1: number;
+  median: number;
+  q3: number;
+  max: number;
+  iqr: number;
+}
+declare function fiveNumber(xs: number[]): FiveNumber;
+/** Counts per value (for histograms / mode bars), sorted by value. */
+declare function frequencies(xs: number[]): {
+  value: number;
+  count: number;
+}[];
+//#endregion
+export { FiveNumber, fiveNumber, frequencies, mean, median, mode, quantile, range, stddev, sum, variance };

package/dist/statistics/core/descriptive.mjs

@@ -0,0 +1,64 @@
+//#region src/statistics/core/descriptive.ts
+/**
+* Descriptive statistics — the pure kernel the statistics labs trust as the
+* source of truth (centre, spread, position). No dependencies; every lab POINTS
+* to these numbers rather than recomputing them, so the figure and the readout
+* can never disagree. Median uses the standard average-of-middle-two for even n;
+* variance/σ default to the POPULATION form (divide by n) with a `sample` flag
+* for the n−1 (Bessel) form.
+*/
+const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+const mean = (xs) => xs.length ? sum(xs) / xs.length : 0;
+function median(xs) {
+	if (!xs.length) return 0;
+	const s = [...xs].sort((a, b) => a - b);
+	const m = s.length >> 1;
+	return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+/** Every value tied for the highest frequency (multimodal-aware), sorted. */
+function mode(xs) {
+	if (!xs.length) return [];
+	const freq = /* @__PURE__ */ new Map();
+	for (const x of xs) freq.set(x, (freq.get(x) ?? 0) + 1);
+	const max = Math.max(...freq.values());
+	if (max === 1) return [];
+	return [...freq.entries()].filter(([, c]) => c === max).map(([v]) => v).sort((a, b) => a - b);
+}
+const range = (xs) => xs.length ? Math.max(...xs) - Math.min(...xs) : 0;
+function variance(xs, sample = false) {
+	if (xs.length < (sample ? 2 : 1)) return 0;
+	const m = mean(xs);
+	return sum(xs.map((x) => (x - m) ** 2)) / (xs.length - (sample ? 1 : 0));
+}
+const stddev = (xs, sample = false) => Math.sqrt(variance(xs, sample));
+/** Linear-interpolated quantile (q in [0,1]) — the inclusive "p = (n−1)q" method. */
+function quantile(xs, q) {
+	if (!xs.length) return 0;
+	const s = [...xs].sort((a, b) => a - b);
+	const pos = (s.length - 1) * q;
+	const lo = Math.floor(pos), hi = Math.ceil(pos);
+	return lo === hi ? s[lo] : s[lo] + (pos - lo) * (s[hi] - s[lo]);
+}
+function fiveNumber(xs) {
+	const q1 = quantile(xs, .25), q3 = quantile(xs, .75);
+	return {
+		min: xs.length ? Math.min(...xs) : 0,
+		q1,
+		median: median(xs),
+		q3,
+		max: xs.length ? Math.max(...xs) : 0,
+		iqr: q3 - q1
+	};
+}
+/** Counts per value (for histograms / mode bars), sorted by value. */
+function frequencies(xs) {
+	const f = /* @__PURE__ */ new Map();
+	for (const x of xs) f.set(x, (f.get(x) ?? 0) + 1);
+	return [...f.entries()].map(([value, count]) => ({
+		value,
+		count
+	})).sort((a, b) => a.value - b.value);
+}
+
+//#endregion
+export { fiveNumber, frequencies, mean, median, mode, quantile, range, stddev, sum, variance };

package/dist/statistics/core/normal.d.mts

@@ -0,0 +1,21 @@
+//#region src/statistics/core/normal.d.ts
+/**
+ * Normal-distribution kernel — the bell curve's pdf/cdf, the z-score, and the
+ * area between two points (the probability a value lands in a range). The cdf uses
+ * the Abramowitz–Stegun erf approximation (max error ~1.5e-7 — far tighter than
+ * any teaching needs). The labs render these; they never re-derive them.
+ */
+/** Gauss error function (A&S 7.1.26). */
+declare function erf(x: number): number;
+/** Normal probability density at x. */
+declare function normalPdf(x: number, mu?: number, sigma?: number): number;
+/** Cumulative probability P(X ≤ x). */
+declare function normalCdf(x: number, mu?: number, sigma?: number): number;
+/** P(a ≤ X ≤ b). */
+declare function normalBetween(a: number, b: number, mu?: number, sigma?: number): number;
+/** The standard score: how many σ a value sits from the mean. */
+declare function zScore(x: number, mu?: number, sigma?: number): number;
+/** The 68–95–99.7 rule — P(within k·σ of the mean). */
+declare function withinSigma(k: number): number;
+//#endregion
+export { erf, normalBetween, normalCdf, normalPdf, withinSigma, zScore };

package/dist/statistics/core/normal.mjs

@@ -0,0 +1,37 @@
+//#region src/statistics/core/normal.ts
+/**
+* Normal-distribution kernel — the bell curve's pdf/cdf, the z-score, and the
+* area between two points (the probability a value lands in a range). The cdf uses
+* the Abramowitz–Stegun erf approximation (max error ~1.5e-7 — far tighter than
+* any teaching needs). The labs render these; they never re-derive them.
+*/
+/** Gauss error function (A&S 7.1.26). */
+function erf(x) {
+	const t = 1 / (1 + .3275911 * Math.abs(x));
+	const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - .284496736) * t + .254829592) * t * Math.exp(-x * x);
+	return x >= 0 ? y : -y;
+}
+/** Normal probability density at x. */
+function normalPdf(x, mu = 0, sigma = 1) {
+	const z = (x - mu) / sigma;
+	return Math.exp(-.5 * z * z) / (sigma * Math.sqrt(2 * Math.PI));
+}
+/** Cumulative probability P(X ≤ x). */
+function normalCdf(x, mu = 0, sigma = 1) {
+	return .5 * (1 + erf((x - mu) / (sigma * Math.SQRT2)));
+}
+/** P(a ≤ X ≤ b). */
+function normalBetween(a, b, mu = 0, sigma = 1) {
+	return Math.abs(normalCdf(b, mu, sigma) - normalCdf(a, mu, sigma));
+}
+/** The standard score: how many σ a value sits from the mean. */
+function zScore(x, mu = 0, sigma = 1) {
+	return (x - mu) / sigma;
+}
+/** The 68–95–99.7 rule — P(within k·σ of the mean). */
+function withinSigma(k) {
+	return normalBetween(-k, k, 0, 1);
+}
+
+//#endregion
+export { erf, normalBetween, normalCdf, normalPdf, withinSigma, zScore };

package/dist/statistics/core/sequences.d.mts

@@ -0,0 +1,27 @@
+//#region src/statistics/core/sequences.d.ts
+/**
+ * Sequences & series kernel — arithmetic and geometric, the two patterns every
+ * series lesson rests on. Pure functions: the nth term, the first n terms, and
+ * the partial sum (closed form), plus the geometric infinite-sum (|r|<1). The
+ * lab draws bars/areas from `terms()` and proves the closed form against the
+ * brute sum, so the visual and the formula stay in lockstep.
+ */
+type SeqKind = 'arithmetic' | 'geometric';
+interface SeqSpec {
+  kind: SeqKind;
+  first: number;
+  step: number;
+}
+/** The nth term (1-indexed): aₙ = a₁+(n−1)d  |  aₙ = a₁·r^(n−1). */
+declare function nthTerm(spec: SeqSpec, n: number): number;
+/** The first `count` terms (1-indexed). */
+declare function terms(spec: SeqSpec, count: number): number[];
+/** Partial sum of the first n terms, closed form.
+ *  arithmetic: n/2·(2a₁+(n−1)d).  geometric: a₁·(1−rⁿ)/(1−r)  (n·a₁ when r=1). */
+declare function partialSum(spec: SeqSpec, n: number): number;
+/** Running partial sums S₁…S_count (for the convergence/area visual). */
+declare function partialSums(spec: SeqSpec, count: number): number[];
+/** Sum to infinity of a geometric series, or null if it diverges (|r| ≥ 1). */
+declare function infiniteSum(spec: SeqSpec): number | null;
+//#endregion
+export { SeqKind, SeqSpec, infiniteSum, nthTerm, partialSum, partialSums, terms };