dsh-aha-tutor 1.4.0 → 1.6.0

package/lib/{runtime-DqCjJ0yL.js → runtime-B6zUpJjA.js}

@@ -20,6 +20,716 @@ function assertId(value, prefix) {
 	return value;
 }
 //#endregion
+//#region src/core/expr.js
+const EXPR_LIMITS = Object.freeze({
+	chars: 240,
+	nodes: 400,
+	depth: 40
+});
+var ExprError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExprError";
+	}
+};
+const FUNCTIONS = Object.freeze({
+	sin: [1, Math.sin],
+	cos: [1, Math.cos],
+	tan: [1, Math.tan],
+	cot: [1, (x) => 1 / Math.tan(x)],
+	sec: [1, (x) => 1 / Math.cos(x)],
+	csc: [1, (x) => 1 / Math.sin(x)],
+	asin: [1, Math.asin],
+	acos: [1, Math.acos],
+	atan: [1, Math.atan],
+	arcsin: [1, Math.asin],
+	arccos: [1, Math.acos],
+	arctan: [1, Math.atan],
+	atan2: [2, Math.atan2],
+	sinh: [1, Math.sinh],
+	cosh: [1, Math.cosh],
+	tanh: [1, Math.tanh],
+	asinh: [1, Math.asinh],
+	acosh: [1, Math.acosh],
+	atanh: [1, Math.atanh],
+	exp: [1, Math.exp],
+	ln: [1, Math.log],
+	log: [1, Math.log10],
+	lg: [1, Math.log10],
+	log10: [1, Math.log10],
+	log2: [1, Math.log2],
+	sqrt: [1, Math.sqrt],
+	cbrt: [1, Math.cbrt],
+	abs: [1, Math.abs],
+	sign: [1, Math.sign],
+	floor: [1, Math.floor],
+	ceil: [1, Math.ceil],
+	round: [1, Math.round],
+	min: [-2, Math.min],
+	max: [-2, Math.max],
+	pow: [2, Math.pow]
+});
+const CONSTANTS = Object.freeze({
+	pi: Math.PI,
+	π: Math.PI,
+	e: Math.E
+});
+const isFunctionName = (name) => Object.hasOwn(FUNCTIONS, name);
+const isConstantName = (name) => Object.hasOwn(CONSTANTS, name);
+const REPLACEMENTS = [
+	[/[−–—]/gu, "-"],
+	[/[×·⋅∙]/gu, "*"],
+	[/÷/gu, "/"],
+	[/\*\*/gu, "^"],
+	[/²/gu, "^2"],
+	[/³/gu, "^3"],
+	[/[（]/gu, "("],
+	[/[）]/gu, ")"],
+	[/[，]/gu, ","]
+];
+function tokenize$1(source) {
+	let input = String(source ?? "");
+	for (const [pattern, value] of REPLACEMENTS) input = input.replace(pattern, value);
+	const tokens = [];
+	let at = 0;
+	while (at < input.length) {
+		const char = input[at];
+		if (/\s/u.test(char)) {
+			at += 1;
+			continue;
+		}
+		const number = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/u.exec(input.slice(at));
+		if (number) {
+			tokens.push({
+				type: "num",
+				value: Number(number[0])
+			});
+			at += number[0].length;
+			continue;
+		}
+		const name = /^[\p{L}_][\p{L}\p{N}_]*/u.exec(input.slice(at));
+		if (name) {
+			tokens.push({
+				type: "name",
+				value: name[0]
+			});
+			at += name[0].length;
+			continue;
+		}
+		if ("+-*/^(),|√".includes(char)) {
+			tokens.push({ type: char });
+			at += 1;
+			continue;
+		}
+		throw new ExprError(`Unexpected "${char}"`);
+	}
+	return tokens;
+}
+function parseExpr(source, names = []) {
+	const text = String(source ?? "");
+	if (!text.trim()) throw new ExprError("Empty formula");
+	if (text.length > EXPR_LIMITS.chars) throw new ExprError("Formula too long");
+	const known = new Set(names);
+	const tokens = tokenize$1(text);
+	let index = 0;
+	let nodes = 0;
+	let depth = 0;
+	const peek = () => tokens[index];
+	const take = (type) => {
+		const token = tokens[index];
+		if (!token || type && token.type !== type) throw new ExprError(type ? `Expected "${type}"` : "Unexpected end");
+		index += 1;
+		return token;
+	};
+	const node = (value) => {
+		nodes += 1;
+		if (nodes > EXPR_LIMITS.nodes) throw new ExprError("Formula too long");
+		return value;
+	};
+	const nested = (parse) => {
+		depth += 1;
+		if (depth > EXPR_LIMITS.depth) throw new ExprError("Formula nested too deeply");
+		try {
+			return parse();
+		} finally {
+			depth -= 1;
+		}
+	};
+	const startsPrimary = (token) => token && (token.type === "num" || token.type === "name" || token.type === "(" || token.type === "√");
+	function sum() {
+		let left = product();
+		while (peek()?.type === "+" || peek()?.type === "-") {
+			const op = take().type;
+			left = node({
+				k: "bin",
+				op,
+				a: left,
+				b: product()
+			});
+		}
+		return left;
+	}
+	function product() {
+		let left = unary();
+		for (;;) {
+			const token = peek();
+			if (token?.type === "*" || token?.type === "/") {
+				take();
+				left = node({
+					k: "bin",
+					op: token.type,
+					a: left,
+					b: unary()
+				});
+			} else if (startsPrimary(token)) left = node({
+				k: "bin",
+				op: "*",
+				a: left,
+				b: power()
+			});
+			else return left;
+		}
+	}
+	function unary() {
+		const token = peek();
+		if (token?.type === "-") {
+			take();
+			return node({
+				k: "neg",
+				a: nested(unary)
+			});
+		}
+		if (token?.type === "+") {
+			take();
+			return nested(unary);
+		}
+		return power();
+	}
+	function power() {
+		const base = primary();
+		if (peek()?.type !== "^") return base;
+		take();
+		return node({
+			k: "bin",
+			op: "^",
+			a: base,
+			b: nested(unary)
+		});
+	}
+	function call(name) {
+		const [arity] = FUNCTIONS[name];
+		take("(");
+		const args = [nested(sum)];
+		while (peek()?.type === ",") {
+			take();
+			args.push(nested(sum));
+		}
+		take(")");
+		if (arity > 0 ? args.length !== arity : args.length < -arity) throw new ExprError(`${name} takes ${Math.abs(arity)} argument${Math.abs(arity) > 1 ? "s" : ""}`);
+		return node({
+			k: "call",
+			f: name,
+			args
+		});
+	}
+	function named(value) {
+		if (known.has(value)) return node({
+			k: "var",
+			n: value
+		});
+		if (isConstantName(value)) return node({
+			k: "num",
+			v: CONSTANTS[value]
+		});
+		if (isFunctionName(value)) {
+			if (peek()?.type !== "(") throw new ExprError(`Write ${value}(…) with parentheses`);
+			return call(value);
+		}
+		const parts = splitName(value);
+		if (!parts) throw new ExprError(`Unknown name "${value}"`);
+		let result = null;
+		for (const [partIndex, part] of parts.entries()) {
+			let factor;
+			if (isFunctionName(part)) {
+				if (partIndex !== parts.length - 1 || peek()?.type !== "(") throw new ExprError(`Unknown name "${value}"`);
+				factor = call(part);
+			} else factor = node(known.has(part) ? {
+				k: "var",
+				n: part
+			} : {
+				k: "num",
+				v: CONSTANTS[part]
+			});
+			result = result ? node({
+				k: "bin",
+				op: "*",
+				a: result,
+				b: factor
+			}) : factor;
+		}
+		return result;
+	}
+	function splitName(value) {
+		const candidates = [
+			...known,
+			...Object.keys(CONSTANTS),
+			...Object.keys(FUNCTIONS)
+		].sort((a, b) => b.length - a.length);
+		const parts = [];
+		let rest = value;
+		while (rest) {
+			const found = candidates.find((candidate) => rest.startsWith(candidate));
+			if (!found) return null;
+			parts.push(found);
+			rest = rest.slice(found.length);
+		}
+		return parts.length > 1 ? parts : null;
+	}
+	function primary() {
+		const token = take();
+		if (token.type === "num") return node({
+			k: "num",
+			v: token.value
+		});
+		if (token.type === "name") return named(token.value);
+		if (token.type === "(") {
+			const inner = nested(sum);
+			take(")");
+			return inner;
+		}
+		if (token.type === "|") {
+			const inner = nested(sum);
+			take("|");
+			return node({
+				k: "call",
+				f: "abs",
+				args: [inner]
+			});
+		}
+		if (token.type === "√") return node({
+			k: "call",
+			f: "sqrt",
+			args: [nested(power)]
+		});
+		throw new ExprError(`Unexpected "${token.type}"`);
+	}
+	const tree = sum();
+	if (index < tokens.length) throw new ExprError(`Unexpected "${tokens[index].type === "name" || tokens[index].type === "num" ? tokens[index].value : tokens[index].type}"`);
+	return tree;
+}
+function compileExpr(tree, names = []) {
+	const slot = new Map(names.map((name, position) => [name, position]));
+	const build = (item) => {
+		switch (item.k) {
+			case "num": {
+				const value = item.v;
+				return () => value;
+			}
+			case "var": {
+				const position = slot.get(item.n);
+				if (position === void 0) throw new ExprError(`Unknown name "${item.n}"`);
+				return (values) => values[position];
+			}
+			case "neg": {
+				const a = build(item.a);
+				return (values) => -a(values);
+			}
+			case "bin": {
+				const a = build(item.a);
+				const b = build(item.b);
+				if (item.op === "+") return (values) => a(values) + b(values);
+				if (item.op === "-") return (values) => a(values) - b(values);
+				if (item.op === "*") return (values) => a(values) * b(values);
+				if (item.op === "/") return (values) => a(values) / b(values);
+				return (values) => power(a(values), b(values));
+			}
+			case "call": {
+				const implementation = FUNCTIONS[item.f][1];
+				const args = item.args.map(build);
+				if (args.length === 1) {
+					const [a] = args;
+					return (values) => implementation(a(values));
+				}
+				return (values) => implementation(...args.map((arg) => arg(values)));
+			}
+			default: throw new ExprError("Bad formula");
+		}
+	};
+	return build(tree);
+}
+function power(base, exponent) {
+	const value = base ** exponent;
+	if (!Number.isNaN(value) || base >= 0 || !Number.isFinite(exponent)) return value;
+	for (const denominator of [
+		3,
+		5,
+		7,
+		9
+	]) {
+		const numerator = Math.round(exponent * denominator);
+		if (Math.abs(numerator / denominator - exponent) < 1e-9) return (-((-base) ** (1 / denominator))) ** numerator;
+	}
+	return value;
+}
+function constantValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value !== "string" || !value.trim()) return null;
+	try {
+		const result = compileExpr(parseExpr(value))([]);
+		return Number.isFinite(result) ? result : null;
+	} catch {
+		return null;
+	}
+}
+const SUPERSCRIPT = {
+	0: "⁰",
+	1: "¹",
+	2: "²",
+	3: "³",
+	4: "⁴",
+	5: "⁵",
+	6: "⁶",
+	7: "⁷",
+	8: "⁸",
+	9: "⁹",
+	"-": "⁻"
+};
+const DISPLAY_NAMES = {
+	pi: "π",
+	theta: "θ",
+	omega: "ω",
+	phi: "φ",
+	alpha: "α",
+	beta: "β",
+	lambda: "λ",
+	mu: "μ",
+	sigma: "σ",
+	tau: "τ"
+};
+const PRECEDENCE = {
+	"+": 1,
+	"-": 1,
+	"*": 2,
+	"/": 2,
+	"^": 4
+};
+function formatNumber(value) {
+	if (Math.abs(value - Math.PI) < 1e-12) return "π";
+	if (Math.abs(value - Math.E) < 1e-12) return "e";
+	return Number(value.toPrecision(6)).toString();
+}
+const superscript = (value) => [...String(value)].map((char) => SUPERSCRIPT[char]).join("");
+const symbol = (value) => [...value].length === 1 && /\p{L}/u.test(value);
+function exprToText(tree, display = DISPLAY_NAMES) {
+	const show = (name) => display[name] ?? name;
+	const write = (item, parent = 0) => {
+		switch (item.k) {
+			case "num": return formatNumber(item.v);
+			case "var": return show(item.n);
+			case "neg": {
+				const inner = write(item.a, 3);
+				return parent > 2 ? `(−${inner})` : `−${inner}`;
+			}
+			case "call":
+				if (item.f === "abs") return `|${write(item.args[0])}|`;
+				if (item.f === "sqrt") return `√(${write(item.args[0])})`;
+				return `${item.f}(${item.args.map((arg) => write(arg)).join(", ")})`;
+			case "bin": {
+				const own = PRECEDENCE[item.op];
+				let out;
+				if (item.op === "^") {
+					const base = write(item.a, 5);
+					const integer = (value) => value.k === "num" && Number.isInteger(value.v) && Math.abs(value.v) < 100;
+					const top = write(item.b);
+					out = `${base}${integer(item.b) ? superscript(item.b.v) : item.b.k === "neg" && integer(item.b.a) ? `⁻${superscript(item.b.a.v)}` : symbol(top) ? `^${top}` : `^(${top})`}`;
+				} else if (item.op === "*") {
+					const a = write(item.a, own);
+					const b = write(item.b, own);
+					out = item.a.k === "num" && /\d$/u.test(a) && /^[\p{L}(√|]/u.test(b) || symbol(a) && (symbol(b) || b.startsWith("(")) || item.a.k !== "call" && /^[\d\p{L}]+$/u.test(a) && /\p{L}$/u.test(a) && symbol(b) || item.a.k !== "call" && a.endsWith(")") && b.startsWith("(") ? `${a}${b}` : `${a}·${b}`;
+				} else {
+					const a = write(item.a, own);
+					const b = write(item.b, item.op === "+" ? own : own + .5);
+					out = `${a} ${item.op === "-" ? "−" : item.op} ${b}`;
+				}
+				return own < parent ? `(${out})` : out;
+			}
+			default: return "";
+		}
+	};
+	return write(tree);
+}
+//#endregion
+//#region src/core/plot.js
+const PLOT_LIMITS = Object.freeze({
+	fns: 4,
+	params: 4,
+	points: 8,
+	lines: 6,
+	shades: 3,
+	tangents: 3,
+	samples: 480
+});
+const clip = (value, max) => value === null || value === void 0 ? "" : String(value).replace(/\u0000/gu, "").trim().slice(0, max);
+const list$1 = (value, max) => (Array.isArray(value) ? value : value && typeof value === "object" ? [value] : []).slice(0, max);
+const clamp$1 = (value, min, max) => Math.min(max, Math.max(min, value));
+const mentionsPi = (value) => /pi|π/iu.test(String(value ?? ""));
+const VARIABLES = Object.freeze({
+	fx: ["x", "t"],
+	param: [
+		"t",
+		"θ",
+		"theta"
+	],
+	polar: [
+		"θ",
+		"theta",
+		"t"
+	]
+});
+const RESERVED = /* @__PURE__ */ new Set([
+	"x",
+	"y",
+	"r",
+	"θ",
+	"theta"
+]);
+function curveVariables(kind, paramNames) {
+	return VARIABLES[kind].filter((name) => !paramNames.includes(name));
+}
+function niceStep(raw) {
+	const power = 10 ** Math.floor(Math.log10(raw));
+	const unit = raw / power;
+	return (unit >= 5 ? 5 : unit >= 2 ? 2 : 1) * power;
+}
+function readRange(value) {
+	const pair = Array.isArray(value) ? value : value && typeof value === "object" ? Array.isArray(value.range) ? value.range : [value.min, value.max] : null;
+	if (!pair || pair.length < 2) return null;
+	const a = constantValue(pair[0]);
+	const b = constantValue(pair[1]);
+	return a !== null && b !== null && b > a ? [a, b] : null;
+}
+function normalizeParams(raw) {
+	const seen = /* @__PURE__ */ new Set();
+	const params = [];
+	for (const param of list$1(raw, PLOT_LIMITS.params)) {
+		const name = clip(param?.name ?? param?.symbol ?? param?.id, 12);
+		if (!/^\p{L}[\p{L}\p{N}_]{0,11}$/u.test(name) || isFunctionName(name) || isConstantName(name) || RESERVED.has(name) || seen.has(name)) continue;
+		const min = constantValue(param.min);
+		const max = constantValue(param.max);
+		if (min === null || max === null || !(max > min)) continue;
+		const start = constantValue(param.value ?? param.default ?? param.initial);
+		let step = constantValue(param.step);
+		if (!(step > 0) || step > max - min) step = niceStep((max - min) / 100);
+		seen.add(name);
+		params.push({
+			name,
+			value: clamp$1(start ?? (min + max) / 2, min, max),
+			min,
+			max,
+			step,
+			label: clip(param.label ?? param.title, 30)
+		});
+	}
+	return params;
+}
+const formulaText = (value) => clip(value, 240).replace(/^[\p{L}](?:\s*\(\s*[\p{L}]+\s*\))?\s*=(?!=)/u, "").trim();
+function checks(source, names) {
+	try {
+		parseExpr(source, names);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeCurve(raw, paramNames) {
+	const curve = typeof raw === "string" ? { y: raw } : raw;
+	if (!curve || typeof curve !== "object") return null;
+	const name = clip(curve.name ?? curve.label, 40);
+	const known = (kind) => [...curveVariables(kind, paramNames), ...paramNames];
+	if (curve.r !== void 0) {
+		const r = formulaText(curve.r);
+		if (!checks(r, known("polar"))) return null;
+		return {
+			kind: "polar",
+			r,
+			t: readRange(curve.t ?? curve.theta ?? curve.θ ?? curve.range) ?? [0, 2 * Math.PI],
+			name
+		};
+	}
+	if (typeof curve.x === "string" && typeof curve.y === "string") {
+		const x = formulaText(curve.x);
+		const y = formulaText(curve.y);
+		if (!checks(x, known("param")) || !checks(y, known("param"))) return null;
+		return {
+			kind: "param",
+			x,
+			y,
+			t: readRange(curve.t ?? curve.range) ?? [0, 2 * Math.PI],
+			name
+		};
+	}
+	const y = formulaText(curve.y ?? curve.fn ?? curve.f ?? curve.expr ?? curve.formula);
+	if (!y || !checks(y, known("fx"))) return null;
+	const domain = readRange(curve.domain ?? (Array.isArray(curve.x) ? curve.x : null));
+	return {
+		kind: "fx",
+		y,
+		...domain ? { domain } : {},
+		name
+	};
+}
+function fxIndex(value, fns, fallback = true) {
+	const index = Number(value);
+	if (Number.isInteger(index) && fns[index]?.kind === "fx") return index;
+	if (value !== void 0 && value !== null && value !== "") return null;
+	if (!fallback) return null;
+	const first = fns.findIndex((fn) => fn.kind === "fx");
+	return first >= 0 ? first : null;
+}
+function normalizePlot(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const params = normalizeParams(raw.params ?? raw.parameters ?? raw.sliders);
+	const paramNames = params.map((param) => param.name);
+	const single = typeof raw.y === "string" || raw.fn !== void 0 || raw.expr !== void 0 || raw.f !== void 0 || raw.formula !== void 0 ? [{
+		...raw,
+		x: void 0,
+		name: raw.name ?? raw.label
+	}] : [];
+	const fns = list$1(raw.fns ?? raw.functions ?? raw.curves ?? single, PLOT_LIMITS.fns * 2).map((curve) => normalizeCurve(curve, paramNames)).filter(Boolean).slice(0, PLOT_LIMITS.fns);
+	if (!fns.length) return null;
+	const xSource = raw.x !== void 0 && typeof raw.x !== "string" ? raw.x : raw.xRange ?? raw.domain ?? (raw.xMin !== void 0 ? [raw.xMin, raw.xMax] : void 0);
+	const ySource = raw.y !== void 0 && typeof raw.y !== "string" ? raw.y : raw.yRange ?? (raw.yMin !== void 0 ? [raw.yMin, raw.yMax] : void 0);
+	const x = readRange(xSource) ?? (fns.some((fn) => fn.kind === "fx") ? [-5, 5] : null);
+	const y = readRange(ySource);
+	const points = [];
+	for (const point of list$1(raw.points ?? raw.marks, PLOT_LIMITS.points)) {
+		const px = constantValue(point?.x);
+		if (px === null) continue;
+		const py = constantValue(point?.y);
+		const fn = py === null ? fxIndex(point?.fn, fns) : null;
+		if (py === null && fn === null) continue;
+		points.push({
+			x: px,
+			...py === null ? { fn } : { y: py },
+			label: clip(point?.label ?? point?.name, 30)
+		});
+	}
+	const lines = [];
+	for (const line of list$1(raw.lines ?? raw.guides, PLOT_LIMITS.lines)) {
+		const lx = constantValue(line?.x);
+		const ly = lx === null ? constantValue(line?.y) : null;
+		if (lx === null && ly === null) continue;
+		lines.push({
+			...lx === null ? { y: ly } : { x: lx },
+			label: clip(line?.label, 30)
+		});
+	}
+	const shades = [];
+	for (const shade of list$1(raw.shade ?? raw.shades ?? raw.areas, PLOT_LIMITS.shades)) {
+		const fn = fxIndex(shade?.fn, fns);
+		const from = constantValue(shade?.from ?? shade?.a);
+		const to = constantValue(shade?.to ?? shade?.b);
+		if (fn === null || from === null || to === null || !(to > from)) continue;
+		const fn2 = fxIndex(shade?.fn2 ?? shade?.to_fn ?? shade?.below, fns, false);
+		shades.push({
+			fn,
+			from,
+			to,
+			...fn2 !== null && fn2 !== fn ? { fn2 } : {},
+			label: clip(shade?.label, 30)
+		});
+	}
+	const tangents = [];
+	for (const tangent of list$1(raw.tangents ?? raw.tangent, PLOT_LIMITS.tangents)) {
+		const fn = fxIndex(tangent?.fn, fns);
+		const at = constantValue(tangent?.x ?? tangent?.at);
+		if (fn === null || at === null) continue;
+		tangents.push({
+			fn,
+			x: at,
+			label: clip(tangent?.label, 30)
+		});
+	}
+	return {
+		title: clip(raw.title, 120),
+		caption: clip(raw.caption, 200),
+		x: x ? {
+			min: x[0],
+			max: x[1]
+		} : null,
+		y: y ? {
+			min: y[0],
+			max: y[1]
+		} : null,
+		xLabel: clip(raw.xLabel ?? raw.x?.label, 40),
+		yLabel: clip(raw.yLabel ?? raw.y?.label, 40),
+		xPi: mentionsPi(JSON.stringify(xSource ?? "")) || x !== null && isPiMultiple(x[0]) && isPiMultiple(x[1]) && !(Number.isInteger(x[0]) && Number.isInteger(x[1])),
+		equal: raw.equal === true || raw.aspect === "equal",
+		fns,
+		params,
+		points,
+		lines,
+		shades,
+		tangents
+	};
+}
+const isPiMultiple = (value) => Math.abs(value / (Math.PI / 4) - Math.round(value / (Math.PI / 4))) < .001;
+function readable(source, plot) {
+	try {
+		return exprToText(parseExpr(source, [.../* @__PURE__ */ new Set([...Object.values(VARIABLES).flat(), ...plot.params.map((param) => param.name)])]));
+	} catch {
+		return source;
+	}
+}
+const number = (value) => {
+	if (!Number.isFinite(value)) return String(value);
+	const ratio = value / Math.PI;
+	if (value !== 0 && Math.abs(ratio * 4 - Math.round(ratio * 4)) < 1e-6) {
+		const quarters = Math.round(ratio * 4);
+		const [top, bottom] = quarters % 4 === 0 ? [quarters / 4, 1] : quarters % 2 === 0 ? [quarters / 2, 2] : [quarters, 4];
+		const head = top === 1 ? "π" : top === -1 ? "−π" : `${top}π`.replace("-", "−");
+		return bottom === 1 ? head : `${head}/${bottom}`;
+	}
+	return Number(value.toPrecision(4)).toString().replace("-", "−");
+};
+function plotCurveLabels(plot) {
+	return plot.fns.map((fn) => {
+		if (fn.kind === "polar") return `r = ${readable(fn.r, plot)}`;
+		if (fn.kind === "param") return `x = ${readable(fn.x, plot)}, y = ${readable(fn.y, plot)}`;
+		return `y = ${readable(fn.y, plot)}`;
+	});
+}
+function plotToText(plot) {
+	const parts = [plot.title || plot.caption].filter(Boolean);
+	const curves = plotCurveLabels(plot).map((label, index) => {
+		const fn = plot.fns[index];
+		const range = fn.kind === "fx" ? plot.x ? `, x ${number(fn.domain?.[0] ?? plot.x.min)} … ${number(fn.domain?.[1] ?? plot.x.max)}` : "" : `, ${fn.kind === "polar" ? "θ" : "t"} ${number(fn.t[0])} … ${number(fn.t[1])}`;
+		return `${fn.name ? `${fn.name}: ` : ""}${label}${range}`;
+	});
+	parts.push(...curves);
+	if (plot.params.length) parts.push(plot.params.map((param) => `${param.label || param.name} = ${number(param.value)} (${number(param.min)} … ${number(param.max)})`).join("; "));
+	return parts.join("\n");
+}
+function plotToSource(plot) {
+	return JSON.stringify({
+		fns: plot.fns.map((fn) => Object.fromEntries(Object.entries(fn).filter(([, value]) => value !== "" && value !== void 0))),
+		...plot.params.length ? { params: plot.params.map(({ name, value, min, max, label }) => ({
+			name,
+			value,
+			min,
+			max,
+			...label ? { label } : {}
+		})) } : {},
+		...plot.x ? { x: [plot.x.min, plot.x.max] } : {},
+		...plot.y ? { y: [plot.y.min, plot.y.max] } : {},
+		...plot.points.length ? { points: plot.points } : {},
+		...plot.lines.length ? { lines: plot.lines } : {},
+		...plot.shades.length ? { shade: plot.shades } : {},
+		...plot.tangents.length ? { tangents: plot.tangents } : {},
+		...plot.title ? { title: plot.title } : {}
+	});
+}
+//#endregion
 //#region src/core/course-model.js
 const LIMITS = Object.freeze({
 	questions: 6,
@@ -285,6 +995,10 @@ function normalizeItem(raw, index = 0, conceptIds = []) {
 	};
 	const figure = text(raw?.svg ?? raw?.figure, 16e3);
 	if (/^<svg[\s>]/iu.test(figure)) item.svg = figure;
+	else if (raw?.plot && typeof raw.plot === "object") {
+		const plot = normalizePlot(raw.plot);
+		if (plot) item.plot = plot;
+	}
 	if (kind === "choice" || kind === "multi" || kind === "order") {
 		item.options = list(raw?.options, LIMITS.options4, (option, optionIndex) => {
 			const label = text(typeof option === "string" ? option : option?.text ?? option?.label, 400);
@@ -492,6 +1206,7 @@ const OP_TYPES = Object.freeze([
 	"list",
 	"svg",
 	"chart",
+	"plot",
 	"table",
 	"code",
 	"note",
@@ -516,7 +1231,8 @@ const OP_ALIASES = Object.freeze({
 	drawing: "svg",
 	figure: "svg",
 	graph: "chart",
-	plot: "chart",
+	function: "plot",
+	curve: "plot",
 	callout: "note",
 	highlight: "mark",
 	underline: "mark",
@@ -612,13 +1328,22 @@ function normalizeOp(raw, index) {
 				wide: raw?.wide === true
 			};
 		}
-		case "chart": {
+		case "chart":
+		case "plot": {
+			if (raw?.fns ?? raw?.functions ?? raw?.curves ?? (typeof raw?.y === "string" || raw?.fn !== void 0 || raw?.expr !== void 0 ? raw : null)) {
+				const plot = normalizePlot(raw);
+				if (plot) return {
+					id,
+					t: "plot",
+					...plot
+				};
+			}
 			const kind = CHART_KINDS.includes(raw?.kind) ? raw.kind : "line";
 			const { series, data } = chartSeries(raw);
 			if (!series.length && !data.length) return null;
 			return {
 				id,
-				t,
+				t: "chart",
 				kind,
 				title: text(raw?.title, 120),
 				xLabel: text(raw?.xLabel ?? raw?.x?.label, 60),
@@ -754,6 +1479,14 @@ function normalizeBoard(raw, { conceptIds = [] } = {}) {
 		steps
 	};
 }
+const CJK = /[぀-ヿ㐀-䶿一-鿿가-힯]/gu;
+function estimateSpeechMs(value, rate = 1) {
+	const content = String(value ?? "");
+	const cjk = (content.match(CJK) ?? []).length;
+	const words = content.replace(CJK, " ").split(/\s+/u).filter(Boolean).length;
+	const seconds = cjk / 4.4 + words / 2.6;
+	return Math.round(seconds * 1e3 / Math.max(.5, Math.min(2, rate || 1)));
+}
 function boardToPlainText(board, { maxChars = 8e3, uptoStep } = {}) {
 	const lines = [];
 	for (const [index, step] of board.steps.entries()) {
@@ -763,6 +1496,7 @@ function boardToPlainText(board, { maxChars = 8e3, uptoStep } = {}) {
 		else if (op.t === "list") lines.push(...op.items.map((item) => `  • ${item}`));
 		else if (op.t === "table") lines.push(`  | ${op.head.join(" | ")} |`, ...op.rows.map((row) => `  | ${row.join(" | ")} |`));
 		else if (op.t === "code") lines.push(`  \`\`\`${op.lang}\n${op.code}\n  \`\`\``);
+		else if (op.t === "plot") lines.push(`  (plot: ${plotToSource(op)})`);
 		else if (op.text) lines.push(`  ${op.text}`);
 		else if (op.caption) lines.push(`  (${op.t}: ${op.caption})`);
 	}
@@ -1381,9 +2115,10 @@ var TutorError = class extends Error {
 	}
 };
 const REPAIR = "Your previous reply could not be parsed as JSON. Reply again with the complete answer as valid JSON only — no code fences, no commentary.";
-async function generateJson(llm, { purpose = "teach", prompt, maxTokens = 8e3, images, signal, normalize = (value) => value, onText }) {
+async function generateJson(llm, { purpose = "teach", effort, prompt, maxTokens = 8e3, images, signal, normalize = (value) => value, onText }) {
 	const request = {
 		purpose,
+		...effort ? { effort } : {},
 		system: prompt.system,
 		user: prompt.user,
 		images,
@@ -1400,12 +2135,8 @@ async function generateJson(llm, { purpose = "teach", prompt, maxTokens = 8e3, i
 		if (signal?.aborted) throw signal.reason ?? error;
 		const retryUser = `${prompt.user}\n\n<previous_reply>\n${String(first).slice(0, 12e3)}\n</previous_reply>\n\n${REPAIR}${error instanceof JsonExtractError ? "" : `\nProblem: ${error.message}`}`;
 		const second = await llm.complete({
-			purpose,
-			system: prompt.system,
-			user: retryUser,
-			images,
-			maxTokens,
-			signal
+			...request,
+			user: retryUser
 		});
 		try {
 			return normalize(extractJson(second));
@@ -1614,7 +2345,8 @@ Board operations (each is a JSON object with field "t"; give an op an "id" only
 - {"t":"math","tex":"…","text":"…"}  one display formula in KaTeX-compatible LaTeX; "text" is a plain-Unicode reading of it (e.g. "θ(t) = θ₀·cos(ωt + φ)")
 - {"t":"list","items":["…","…"],"ordered":false}
 - {"t":"svg","svg":"<svg viewBox=\\"0 0 480 300\\" xmlns=\\"http://www.w3.org/2000/svg\\">…</svg>","caption":"…"}  a clean hand-drawn-style diagram: viewBox at most 640×420, strokes and simple shapes, <text> labels (font-size 14–18), colors only from ink #2b2b2b, blue #2f6fde, red #d64545, green #2f9e6e, orange #e08a1e, purple #7a4fd6; no scripts, no images, no foreignObject, no external links
-- {"t":"chart","kind":"line|bar|scatter|pie|area","title":"…","xLabel":"…","yLabel":"…","series":[{"name":"…","points":[[x,y],…]}]}  or "data":[{"label":"…","value":n}] for bar/pie; use real, computed numbers
+- {"t":"chart","kind":"line|bar|scatter|pie|area","title":"…","xLabel":"…","yLabel":"…","series":[{"name":"…","points":[[x,y],…]}]}  or "data":[{"label":"…","value":n}] for bar/pie; for data that was measured or counted, with real numbers (a curve given by a formula is a plot)
+- {"t":"plot","fns":[{"y":"A*sin(w*x)","name":"…"}],"x":[-6.28,6.28],"y":[-2,2],"params":[{"name":"A","value":1,"min":0.5,"max":2,"label":"振幅 A"}],"points":[{"x":"pi/2","label":"…"}],"lines":[{"x":0,"label":"…"}],"shade":[{"fn":0,"from":0,"to":"pi"}],"tangents":[{"fn":0,"x":0}],"xLabel":"…","yLabel":"…","caption":"…"}  an exact graph the app computes from formulas: use it for every curve given by a formula. A curve in "fns" is {"y":"f(x)"}, parametric {"x":"…","y":"…","t":[a,b]} or polar {"r":"f(θ)","t":[a,b]}, written in calculator syntax: x (t, θ), numbers, + - * / ^ ( ), pi, e, sin cos tan asin acos atan sinh cosh tanh exp ln log10 sqrt abs min max, always with parentheses as in sin(2*x). "params" (at most 4, used in the formulas) become sliders the learner can drag: mention them in "say" and suggest what to try. Optional: "points" (only an "x" puts the point on curve "fn"), "lines" (dashed guides such as asymptotes), "shade" (the area under curve "fn" from "from" to "to", or between "fn" and "fn2"), "tangents", "equal":true (the same scale on both axes, so circles stay round). Ranges and coordinates may be formulas such as "2*pi".
 - {"t":"table","head":["…"],"rows":[["…","…"]]}
 - {"t":"code","lang":"python","code":"…"}
 - {"t":"note","tone":"key|tip|warn|example","text":"…"}  boxed takeaway or warning
@@ -1694,7 +2426,7 @@ function revisePrompt({ blueprint, instruction, language }) {
 		user: join(block("current_blueprint", blueprint), block("change_request", instruction), "Apply the change request and return the complete revised blueprint in the same JSON shape. Keep the \"id\" field of every unit, lecture, lesson and concept you do not substantially change; new items get no id.")
 	};
 }
-const ITEM_FIGURE = "When a figure makes a question clearer (a shape to measure, a graph to read, a circuit, a diagram to label), give the item \"svg\": a small diagram following the same rules as the board's svg op (viewBox at most 480×320). Most items need no figure.";
+const ITEM_FIGURE = "When a figure makes a question clearer (a shape to measure, a graph to read, a circuit, a diagram to label), give the item \"svg\": a small diagram following the same rules as the board's svg op (viewBox at most 480×320). For the graph of a formula give \"plot\" instead: an object shaped like the board's plot op, without \"params\". Most items need no figure.";
 function reworkPrompt({ outline, unitTitle, lectureTitle, lesson, mode, language }) {
 	return {
 		system: join(PERSONA, `You design personal courses with the care of an experienced curriculum designer: clear prerequisites first, one new idea per lesson. ${languageRule(language)}`, JSON_ONLY),
@@ -1735,7 +2467,7 @@ function lessonPrompt({ course, unit, lecture, lesson, language, learner, passag
 		user: join(block("course", `${course.title} (${course.level || "mixed level"}) — ${course.summary ?? ""}`), block("position", `Unit: ${unit.title}\nLecture: ${lecture.title}\nLesson: ${lesson.title}\nObjectives: ${lesson.objectives.join("; ")}\nConcepts (id=name): ${lesson.concepts.map((concept) => `${concept.id}=${concept.name}`).join(", ")}`), block("previous_lesson", previous), learnerBlock(learner), block("source_passages", passages), style ? block("style_request", style) : "", DIRECTIVES[directive] ?? "", `Teach this lesson in about ${steps} steps (~${lesson.estMinutes || 15} minutes).
 - Open with a hook: a question, a surprising fact, or a concrete situation the idea explains. Connect to the previous lesson when there is one.
 - Build intuition before formalism; then make it precise; then work at least one example fully on the board.
-- Draw a diagram or chart whenever a picture makes the idea click.
+- Draw a diagram, chart or plot whenever a picture makes the idea click; a plot with a slider is often the clearest way to show how a formula behaves.
 - Put 2–4 checks after the key ideas, plus one at the end; every check must name its conceptIds.
 - If the lesson works through a calculation or a derivation, make exactly one check a "work" check, right after the key worked example: a similar problem the learner solves alone, writing every step. A lesson without a calculation or derivation gets no "work" check.
 - If source passages are given, stay consistent with them and mention the page when you lean on one.
@@ -1752,7 +2484,7 @@ function askPrompt({ course, lesson, language, boardSoFar, question, learner })
 }
 const REEXPLAIN_STYLES = Object.freeze({
 	analogy: "with an everyday analogy that maps closely onto the idea",
-	visual: "mainly with a diagram or chart, explaining what each part of the picture means",
+	visual: "mainly with a diagram, chart or plot, explaining what each part of the picture means",
 	example: "through a concrete worked example with real numbers, step by step",
 	simpler: "more simply, with shorter sentences, no jargon, and smaller steps",
 	deeper: "more rigorously, showing why it is true and where it breaks down"
@@ -1783,6 +2515,41 @@ function correctionPrompt({ course, lesson, language, boardSoFar, item, response
 		user: join(block("course", course ? course.title : ""), block("lesson", lesson ? `${lesson.title}: ${lesson.objectives?.join("; ") ?? ""}` : ""), block("board_so_far", boardSoFar), block("problem", item.prompt), block("model_working", item.answer), block("learner_working", response), block("grader_notes", notes), "The learner just wrote out their working for this problem and went wrong somewhere. Correct it at the board in 2–3 steps, continuing on the current board: (1) write the learner's wrong line as they wrote it, in an op with an \"id\", then {\"t\":\"mark\",\"ref\":\"<that id>\",\"style\":\"box\"}, and say kindly what went wrong there and why; (2) write the corrected line and carry the working on to the right answer; (3) end with a short {\"t\":\"note\",\"tone\":\"key\",\"text\":\"…\"} holding the rule to remember. Speak to the learner directly and keep it brief. Add no check, and do not continue the lesson itself.")
 	};
 }
+function verifyStepPrompt({ course, lesson, language, board, step, stepId, note }) {
+	return {
+		system: join(PERSONA, `The learner thinks a step of your lesson is wrong. Check it the way a careful examiner would: recompute every number, re-derive every formula, and check every fact, unit, sign, label, graph and answer key. Never defend a mistake and never invent one; a different but valid method or notation is not a mistake. ${languageRule(language)}`, JSON_ONLY),
+		user: join(block("course", course ? course.title : ""), block("lesson", lesson ? `${lesson.title}: ${lesson.objectives?.join("; ") ?? ""}` : ""), block("board", board), block("challenged_step", step), block("learner_says", note || "(no reason given)"), `Decide whether step ${stepId} is right, and check the steps it relies on too: a mistake may have started earlier.
+- "wrong": something on the board is wrong. List every fix: an op replaced by its corrected version {"step":"s3","op":"o7","replace":{…the whole op, in the same JSON shape…}}, corrected narration {"step":"s3","say":"…"}, or a corrected check {"step":"s3","check":{…the whole check…}}. Also fix later steps that carried the same mistake forward. Change only what is wrong.
+- "right": the step is correct; "summary" says why in one sentence, answering the learner.
+- "unclear": it depends on a convention or on something the board does not say; "summary" says what.
+Return {"verdict":"wrong|right|unclear","summary":"one sentence for the learner","fixes":[…]}`)
+	};
+}
+function verifyItemPrompt({ scope, language, item, kind, response, grading, note }) {
+	const graded = kind === "short" || kind === "work";
+	const verdicts = graded ? "wrong|unclear|misgraded|right" : "wrong|unclear|right";
+	const regrade = graded ? `Unless the verdict is "right" (or "credit" is true), grade the learner's answer again against the corrected question in "grade": {${GRADE_FIELDS}${kind === "work" ? ",\"wrongStep\":\"the first wrong line of the learner's working, copied exactly, or empty\",\"why\":\"one sentence\",\"fix\":\"that line written correctly, with inline math $…$\"" : ""}}.\n` : "";
+	return {
+		system: join(PERSONA, `The learner thinks a practice question, its answer key or the grading of their answer is wrong. Check it the way a careful examiner would: solve the question yourself first, then recompute every number and check every fact, unit, option, the answer key, the explanation and the grading. Never defend a mistake and never invent one; an equivalent answer in another valid form is right. ${languageRule(language)}`, JSON_ONLY),
+		user: join(block("scope", scope), block("question", item), block("learner_answer", response || "(no answer)"), block("grading", grading), block("learner_says", note || "(no reason given)"), `Decide which is true:
+- "wrong": the question has a mistake: its answer key, an option, the prompt, the explanation or a hint${graded ? ", its model answer or its rubric" : "; a key that rejects a right answer written another valid way is a mistake too"}. Put the whole corrected question in "item", in the same JSON shape, with the same "kind" and the same number of options, and change only what is wrong. Leave out "svg" and "plot" to keep the figure as it is.
+- "unclear": whether an answer is right depends on a convention or an assumption the question does not state. Put the question in "item" with that convention written into the prompt, and the key and explanation under it. Set "credit": true when the learner's answer is right under another reasonable reading.
+${graded ? "- \"misgraded\": the question is right, but the learner's answer was graded wrongly.\n" : ""}- "right": the question, its answer and the grading are all right.
+${regrade}"summary": one sentence for the learner. "explanation": 2–5 sentences that answer the learner's doubt: what was wrong and the right reasoning, or why it is right (inline math $…$). Speak to the learner in plain words: never quote scores, grading labels or field names.
+Return {"verdict":"${verdicts}","summary":"…","explanation":"…","item":{…the corrected question, for wrong or unclear…},"credit":false${graded ? ",\"grade\":{…}" : ""}}`)
+	};
+}
+const CHALLENGE_REPLIES = Object.freeze({
+	wrong: "The learner was right: this step had a mistake, and the board has now been corrected (see fixes_made). Answer at the board in 1–3 steps, continuing on the current board. Thank the learner in a few words. Write the mistaken part as it was, in an op with an \"id\", then {\"t\":\"mark\",\"ref\":\"<that id>\",\"style\":\"box\"}, and say plainly what was wrong. Then write the corrected version and why it is right. If later steps were corrected too, say so in one sentence. End with a short {\"t\":\"note\",\"tone\":\"key\",\"text\":\"…\"} only if there is a rule worth remembering.",
+	right: "The step is correct. Answer the learner's doubt at the board in 1–3 steps, continuing on the current board: say kindly that it is right, then show why (recompute or re-derive the part in question, or use a tiny example), and name what most likely made it look wrong.",
+	unclear: "Whether the step is right depends on a convention or an assumption (see check_result). In 1–2 steps at the board, continuing on the current board, say which one the lesson uses, what changes under the other, and which one the learner will usually meet."
+});
+function challengePrompt({ course, lesson, language, boardSoFar, step, note, verdict, summary, fixes }) {
+	return {
+		system: join(PERSONA, BOARD_SPEC, STEP_SPEC, languageRule(language), JSONL_ONLY),
+		user: join(block("course", course ? course.title : ""), block("lesson", lesson ? `${lesson.title}: ${lesson.objectives?.join("; ") ?? ""}` : ""), block("board_so_far", boardSoFar), block("challenged_step", step), block("learner_says", note), block("check_result", `${verdict}: ${summary}`), block("fixes_made", fixes), `${CHALLENGE_REPLIES[verdict] ?? CHALLENGE_REPLIES.unclear} Speak to the learner directly and keep it brief. Add no check, and do not continue the lesson itself.`)
+	};
+}
 function projectReviewPrompt({ project, submission, language }) {
 	return {
 		system: join(PERSONA, `You review learner projects like a supportive senior mentor: specific, honest, and actionable. ${languageRule(language)}`, JSON_ONLY),
@@ -1839,7 +2606,7 @@ function digestPartPrompt({ title, part, parts, range, passages, language }) {
 const ASSIST_MODES = Object.freeze({
 	explain: "Explain the concept the learner asked about, at their level, intuition first, then precise, with one worked example. 5–9 steps, 1–2 checks.",
 	solve: "Solve the problem WITH the learner: restate it, identify the method, then work it step by step on the board, explaining why each move is made. Show the final answer clearly in a key note and add one similar practice check at the end. 4–10 steps.",
-	visualize: "Make the idea visible: lead with charts, diagrams or an animation built from correct numbers, and narrate what to notice in each picture. 3–7 steps."
+	visualize: "Make the idea visible: lead with plots of formulas, charts of data, diagrams or an animation built from correct numbers, and narrate what to notice in each picture. 3–7 steps."
 });
 function assistPrompt({ mode, request, language, passages, history, learner }) {
 	return {
@@ -1880,4 +2647,4 @@ function getRuntime() {
 	return runtime;
 }
 //#endregion
-export { conceptIndex as $, generateText as A, readProgress as B, revisePrompt as C, TutorError as D, summaryPrompt as E, materialImages as F, applyEvidence as G, formatPassages as H, materialsSummary as I, recommendNext as J, createConceptState as K, passagesFor as L, EMPTY_PROFILE as M, emptyProgress as N, generateJson as O, masteryFor as P, blueprintOutline as Q, readMaterials as R, researchQueriesPrompt as S, shortPrompt as T, passageRange as U, documentParts as V, spreadPassages as W, boardToPlainText as X, extractJson as Y, normalizeBoard as Z, projectReviewPrompt as _, assertId as _t, blueprintPrompt as a, lessonAfter as at, quizPrompt as b, detectLanguage as c, normalizeCards as ct, flashcardsPrompt as d, normalizePractice as dt, courseProgress as et, gradePrompt as f, normalizeProject as ft, profilePrompt as g, text as gt, practicePrompt as h, safeRelativePath as ht, assistPrompt as i, intakeSummary as it, streamCounter as j, generateSteps as k, digestPartPrompt as l, normalizeCheatsheet as lt, materialBriefPrompt as m, outlineForPrompt as mt, publishRuntime as n, flattenLessons as nt, cheatsheetPrompt as o, nextLesson as ot, lessonPrompt as p, normalizeQuestionnaire as pt, masteryPercent as q, askPrompt as r, insertLesson as rt, correctionPrompt as s, normalizeBlueprint as st, getRuntime as t, findLesson as tt, digestPrompt as u, normalizeLesson as ut, projectsPrompt as v, newId as vt, reworkPrompt as w, reexplainPrompt as x, questionnairePrompt as y, readProfile as z };
+export { BOARD_LIMITS as $, TutorError as A, passagesFor as B, researchQueriesPrompt as C, text as Ct, summaryPrompt as D, shortPrompt as E, newId as Et, EMPTY_PROFILE as F, formatPassages as G, readProfile as H, emptyProgress as I, applyEvidence as J, passageRange as K, masteryFor as L, generateSteps as M, generateText as N, verifyItemPrompt as O, streamCounter as P, extractJson as Q, materialImages as R, reexplainPrompt as S, safeRelativePath as St, reworkPrompt as T, assertId as Tt, readProgress as U, readMaterials as V, documentParts as W, masteryPercent as X, createConceptState as Y, recommendNext as Z, profilePrompt as _, normalizeLesson as _t, blueprintPrompt as a, conceptIndex as at, questionnairePrompt as b, normalizeQuestionnaire as bt, correctionPrompt as c, flattenLessons as ct, digestPrompt as d, lessonAfter as dt, boardToPlainText as et, flashcardsPrompt as f, nextLesson as ft, practicePrompt as g, normalizeItem as gt, materialBriefPrompt as h, normalizeCheatsheet as ht, assistPrompt as i, blueprintOutline as it, generateJson as j, verifyStepPrompt as k, detectLanguage as l, insertLesson as lt, lessonPrompt as m, normalizeCards as mt, publishRuntime as n, normalizeBoard as nt, challengePrompt as o, courseProgress as ot, gradePrompt as p, normalizeBlueprint as pt, spreadPassages as q, askPrompt as r, normalizeOp as rt, cheatsheetPrompt as s, findLesson as st, getRuntime as t, estimateSpeechMs as tt, digestPartPrompt as u, intakeSummary as ut, projectReviewPrompt as v, normalizePractice as vt, revisePrompt as w, plotToText as wt, quizPrompt as x, outlineForPrompt as xt, projectsPrompt as y, normalizeProject as yt, materialsSummary as z };