@danielsimonjr/mathts-workbook 0.4.10 → 0.4.11

package/dist/formatter-8ja3r-YP.js

@@ -0,0 +1,609 @@
+import { parse, stringify } from "yaml";
+import { evaluate } from "@danielsimonjr/mathts-functions";
+//#region src/yaml-safe.ts
+const POLLUTION_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function parseYamlHardened(content) {
+	return parse(content, {
+		schema: "core",
+		merge: false,
+		logLevel: "silent"
+	});
+}
+function parseYamlSafe(content) {
+	const value = parseYamlHardened(content);
+	assertNoPollution(value);
+	return value;
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findPollutionKeys(value, seen = /* @__PURE__ */ new WeakSet(), found = []) {
+	if (!isPlainObject$1(value) && !Array.isArray(value)) return found;
+	if (seen.has(value)) return found;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		for (const item of value) findPollutionKeys(item, seen, found);
+		return found;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) found.push("__proto__");
+	for (const key of Object.getOwnPropertyNames(value)) {
+		if (POLLUTION_KEYS.has(key)) {
+			found.push(key);
+			continue;
+		}
+		findPollutionKeys(value[key], seen, found);
+	}
+	return found;
+}
+function assertNoPollution(value) {
+	const keys = findPollutionKeys(value);
+	if (keys.length > 0) throw new Error(`Disallowed key "${keys[0]}" (prototype pollution)`);
+}
+//#endregion
+//#region src/graph.ts
+function buildDependencyGraph(cells) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const cell of cells) nodes.set(cell.id, {
+		id: cell.id,
+		dependencies: cell.dependsOn ?? [],
+		dependents: []
+	});
+	for (const cell of cells) for (const depId of cell.dependsOn ?? []) {
+		const depNode = nodes.get(depId);
+		if (depNode) depNode.dependents.push(cell.id);
+	}
+	return {
+		nodes,
+		executionOrder: topologicalSort(nodes)
+	};
+}
+function topologicalSort(nodes) {
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	function visit(id) {
+		if (visited.has(id)) return;
+		visited.add(id);
+		const node = nodes.get(id);
+		if (node) for (const depId of node.dependencies) visit(depId);
+		result.push(id);
+	}
+	for (const id of nodes.keys()) visit(id);
+	return result;
+}
+function getDependents(graph, cellId) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	function collect(id) {
+		const node = graph.nodes.get(id);
+		if (!node) return;
+		for (const depId of node.dependents) if (!visited.has(depId)) {
+			visited.add(depId);
+			result.push(depId);
+			collect(depId);
+		}
+	}
+	collect(cellId);
+	return result;
+}
+function getAncestors(graph, id) {
+	const result = /* @__PURE__ */ new Set();
+	function visit(nodeId) {
+		if (result.has(nodeId)) return;
+		const node = graph.nodes.get(nodeId);
+		if (!node) return;
+		result.add(nodeId);
+		for (const dep of node.dependencies) visit(dep);
+	}
+	visit(id);
+	return graph.executionOrder.filter((nodeId) => result.has(nodeId));
+}
+function toMermaid(graph) {
+	const lines = ["graph TD"];
+	for (const id of graph.nodes.keys()) lines.push(`  ${id}["${id}"]`);
+	for (const [id, node] of graph.nodes) for (const dep of node.dependencies) lines.push(`  ${dep} --> ${id}`);
+	return lines.join("\n");
+}
+function toDOT(graph) {
+	const lines = ["digraph deps {"];
+	for (const id of graph.nodes.keys()) lines.push(`  ${id} [label="${id}"];`);
+	for (const [id, node] of graph.nodes) for (const dep of node.dependencies) lines.push(`  ${dep} -> ${id};`);
+	lines.push("}");
+	return lines.join("\n");
+}
+function detectCycles(graph) {
+	const cycles = [];
+	const visited = /* @__PURE__ */ new Set();
+	const stack = /* @__PURE__ */ new Set();
+	function dfs(id, path) {
+		if (stack.has(id)) {
+			const cycleStart = path.indexOf(id);
+			cycles.push(path.slice(cycleStart));
+			return true;
+		}
+		if (visited.has(id)) return false;
+		visited.add(id);
+		stack.add(id);
+		const node = graph.nodes.get(id);
+		if (node) for (const depId of node.dependencies) dfs(depId, [...path, id]);
+		stack.delete(id);
+		return false;
+	}
+	for (const id of graph.nodes.keys()) if (!visited.has(id)) dfs(id, []);
+	return cycles;
+}
+//#endregion
+//#region src/parser.ts
+const CELL_TYPE_KEYS = [
+	"markdown",
+	"code",
+	"tensor",
+	"equation",
+	"visualization",
+	"data",
+	"test",
+	"export"
+];
+const RESERVED_CELL_KEYS = [
+	"id",
+	"depends_on",
+	"language",
+	"format",
+	"output",
+	"error"
+];
+const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isValidIdentifier(id) {
+	return typeof id === "string" && IDENTIFIER_RE.test(id);
+}
+const SUPPORTED_CELL_TYPES = [
+	"code",
+	"markdown",
+	"data",
+	"test",
+	"equation",
+	"visualization"
+];
+const EXECUTION_MODES = [
+	"reactive",
+	"sequential",
+	"manual"
+];
+function detectCellType(cell) {
+	for (const key of CELL_TYPE_KEYS) if (key in cell) return key;
+	return "code";
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toContent(raw) {
+	if (raw === null || raw === void 0) return "";
+	if (typeof raw === "string") return raw;
+	return stringify(raw).trim();
+}
+function normalizeRuntime(raw) {
+	const rt = isPlainObject(raw) ? raw : {};
+	const runtime = {
+		engine: rt.engine === "custom" ? "custom" : "mathts",
+		execution: typeof rt.execution === "string" && EXECUTION_MODES.includes(rt.execution) ? rt.execution : "reactive"
+	};
+	if (typeof rt.timeout === "number") runtime.timeout = rt.timeout;
+	return runtime;
+}
+function mapCell(raw, index, errors) {
+	if (!isPlainObject(raw)) {
+		errors.push(`Cell at index ${index}: must be a mapping`);
+		return {
+			id: `#${index}`,
+			type: "code",
+			content: ""
+		};
+	}
+	const rawId = raw.id;
+	let id;
+	if (rawId === void 0 || rawId === null) {
+		errors.push(`Cell at index ${index}: missing "id"`);
+		id = `#${index}`;
+	} else if (typeof rawId !== "string" || !IDENTIFIER_RE.test(rawId)) {
+		errors.push(`Cell "${String(rawId)}": id must be a valid identifier ([A-Za-z_][A-Za-z0-9_]*)`);
+		id = String(rawId);
+	} else id = rawId;
+	const presentTypeKeys = CELL_TYPE_KEYS.filter((k) => Object.prototype.hasOwnProperty.call(raw, k));
+	if (presentTypeKeys.length === 0) errors.push(`Cell "${id}": no recognized type key (expected one of ${CELL_TYPE_KEYS.join(", ")})`);
+	else if (presentTypeKeys.length > 1) errors.push(`Cell "${id}": multiple type keys (${presentTypeKeys.join(", ")})`);
+	const type = presentTypeKeys[0] ?? "code";
+	const content = presentTypeKeys[0] ? toContent(raw[presentTypeKeys[0]]) : "";
+	if (presentTypeKeys[0] && !SUPPORTED_CELL_TYPES.includes(type)) errors.push(`Cell "${id}": type '${type}' is reserved but not yet supported (supported: ${SUPPORTED_CELL_TYPES.join(", ")})`);
+	let dependsOn;
+	if (raw.depends_on !== void 0) {
+		if (!Array.isArray(raw.depends_on)) errors.push(`Cell "${id}": depends_on must be a list`);
+		else dependsOn = raw.depends_on.map((d) => String(d));
+	}
+	const metadata = {};
+	for (const key of Object.keys(raw)) {
+		if (RESERVED_CELL_KEYS.includes(key) || CELL_TYPE_KEYS.includes(key)) continue;
+		metadata[key] = raw[key];
+	}
+	const cell = {
+		id,
+		type,
+		content
+	};
+	if (dependsOn) cell.dependsOn = dependsOn;
+	if (Object.keys(metadata).length > 0) cell.metadata = metadata;
+	if (raw.output !== void 0) cell.output = raw.output;
+	if (raw.error !== void 0) cell.error = String(raw.error);
+	return cell;
+}
+function parseWorkbook(content) {
+	try {
+		if (!content.trim()) return {
+			success: false,
+			errors: ["Empty workbook content"]
+		};
+		const errors = [];
+		const warnings = [];
+		const doc = parseYamlHardened(content);
+		if (!isPlainObject(doc)) return {
+			success: false,
+			errors: ["Workbook must be a YAML mapping"]
+		};
+		for (const key of findPollutionKeys(doc)) errors.push(`Disallowed key "${key}" (prototype pollution)`);
+		const metadata = isPlainObject(doc.metadata) ? doc.metadata : {};
+		const workbook = {
+			version: doc.version != null ? String(doc.version) : "1.0",
+			metadata,
+			runtime: normalizeRuntime(doc.runtime),
+			cells: []
+		};
+		if (doc.cells === void 0) warnings.push("Workbook has no cells");
+		else if (!Array.isArray(doc.cells)) errors.push("Workbook \"cells\" must be a list");
+		else {
+			const idSet = /* @__PURE__ */ new Set();
+			const cells = doc.cells.map((raw, i) => {
+				const cell = mapCell(raw, i, errors);
+				if (IDENTIFIER_RE.test(cell.id)) {
+					if (idSet.has(cell.id)) errors.push(`Duplicate cell id: "${cell.id}"`);
+					else idSet.add(cell.id);
+				}
+				return cell;
+			});
+			for (const cell of cells) for (const dep of cell.dependsOn ?? []) if (!idSet.has(dep)) errors.push(`Cell "${cell.id}": depends_on references unknown cell "${dep}"`);
+			workbook.cells = cells;
+		}
+		const success = errors.length === 0;
+		return {
+			success,
+			workbook: success ? workbook : void 0,
+			errors: errors.length > 0 ? errors : void 0,
+			warnings: warnings.length > 0 ? warnings : void 0
+		};
+	} catch (error) {
+		return {
+			success: false,
+			errors: [`Parse error: ${error instanceof Error ? error.message : String(error)}`]
+		};
+	}
+}
+function serializeCell(cell) {
+	const out = {
+		[cell.type]: cell.content,
+		id: cell.id
+	};
+	if (cell.dependsOn && cell.dependsOn.length > 0) out.depends_on = cell.dependsOn;
+	if (cell.metadata) for (const [key, value] of Object.entries(cell.metadata)) {
+		if (CELL_TYPE_KEYS.includes(key) || RESERVED_CELL_KEYS.includes(key)) continue;
+		out[key] = value;
+	}
+	if (cell.output !== void 0) out.output = cell.output;
+	if (cell.error !== void 0) out.error = String(cell.error);
+	return out;
+}
+function serializeWorkbook(workbook) {
+	if (!workbook || !Array.isArray(workbook.cells)) throw new Error("serializeWorkbook: invalid workbook (missing \"cells\" array)");
+	const runtime = {
+		engine: workbook.runtime?.engine ?? "mathts",
+		execution: workbook.runtime?.execution ?? "reactive"
+	};
+	if (workbook.runtime?.timeout !== void 0) runtime.timeout = workbook.runtime.timeout;
+	const doc = {
+		version: String(workbook.version ?? "1.0"),
+		metadata: workbook.metadata ?? {},
+		runtime,
+		cells: workbook.cells.map(serializeCell)
+	};
+	return stringify(doc, { lineWidth: 0 });
+}
+function stripOutputs(workbook) {
+	return {
+		...workbook,
+		cells: workbook.cells.map((cell) => ({
+			...cell,
+			output: void 0,
+			error: void 0
+		}))
+	};
+}
+function importWorkbook(input) {
+	let obj;
+	try {
+		obj = parseYamlHardened(input);
+	} catch (error) {
+		return {
+			success: false,
+			errors: [`Invalid JSON/YAML: ${error instanceof Error ? error.message : String(error)}`]
+		};
+	}
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return {
+		success: false,
+		errors: ["Input must be an object with a \"cells\" array"]
+	};
+	const pollution = findPollutionKeys(obj);
+	if (pollution.length > 0) return {
+		success: false,
+		errors: [`Disallowed key "${pollution[0]}" (prototype pollution)`]
+	};
+	const root = obj;
+	if (!Array.isArray(root.cells)) return {
+		success: false,
+		errors: ["Input must have a \"cells\" array"]
+	};
+	const errors = [];
+	const cells = [];
+	root.cells.forEach((raw, index) => {
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+			errors.push(`Cell at index ${index}: must be an object`);
+			return;
+		}
+		const c = raw;
+		const id = typeof c.id === "string" ? c.id : "";
+		const type = typeof c.type === "string" ? c.type : "";
+		const content = typeof c.content === "string" ? c.content : c.content == null ? "" : String(c.content);
+		const dependsOn = (Array.isArray(c.dependsOn) ? c.dependsOn : Array.isArray(c.depends_on) ? c.depends_on : void 0)?.map((d) => String(d));
+		const cell = {
+			id,
+			type,
+			content
+		};
+		if (dependsOn && dependsOn.length > 0) cell.dependsOn = dependsOn;
+		cells.push(cell);
+	});
+	if (errors.length > 0) return {
+		success: false,
+		errors
+	};
+	const metadata = root.metadata && typeof root.metadata === "object" && !Array.isArray(root.metadata) ? root.metadata : {};
+	const runtime = root.runtime && typeof root.runtime === "object" && !Array.isArray(root.runtime) ? root.runtime : {
+		engine: "mathts",
+		execution: "reactive"
+	};
+	const parsed = parseWorkbook(serializeWorkbook({
+		version: typeof root.version === "string" ? root.version : "1.0",
+		metadata,
+		runtime,
+		cells
+	}));
+	if (!parsed.success || !parsed.workbook) return parsed;
+	const cycles = detectCycles(buildDependencyGraph(parsed.workbook.cells));
+	if (cycles.length > 0) return {
+		success: false,
+		errors: cycles.map((c) => `Dependency cycle: ${c.join(" -> ")}`)
+	};
+	return parsed;
+}
+//#endregion
+//#region src/executor.ts
+var WorkbookExecutor = class {
+	workbook;
+	graph;
+	outputs = /* @__PURE__ */ new Map();
+	handlers = [];
+	constructor(workbook) {
+		this.workbook = workbook;
+		this.graph = buildDependencyGraph(workbook.cells);
+	}
+	on(handler) {
+		this.handlers.push(handler);
+		return () => {
+			const index = this.handlers.indexOf(handler);
+			if (index >= 0) this.handlers.splice(index, 1);
+		};
+	}
+	emit(event) {
+		for (const handler of this.handlers) handler(event);
+	}
+	async runAll() {
+		for (const cellId of this.graph.executionOrder) await this.runCell(cellId);
+		this.emit({
+			type: "workbook:complete",
+			timestamp: Date.now()
+		});
+	}
+	async runCell(cellId) {
+		const cell = this.workbook.cells.find((c) => c.id === cellId);
+		if (!cell) throw new Error(`Cell not found: ${cellId}`);
+		this.emit({
+			type: "cell:start",
+			cellId,
+			timestamp: Date.now()
+		});
+		try {
+			const output = await this.executeCell(cell);
+			this.outputs.set(cellId, output);
+			this.emit({
+				type: "cell:success",
+				cellId,
+				output,
+				timestamp: Date.now()
+			});
+			if (this.workbook.runtime.execution === "reactive") {
+				const dependents = getDependents(this.graph, cellId);
+				for (const depId of dependents) this.emit({
+					type: "cell:stale",
+					cellId: depId,
+					timestamp: Date.now()
+				});
+			}
+			return output;
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.emit({
+				type: "cell:error",
+				cellId,
+				error: errorMessage,
+				timestamp: Date.now()
+			});
+			throw error;
+		}
+	}
+	async executeCell(cell) {
+		switch (cell.type) {
+			case "code": return this.executeCode(cell);
+			case "test": return this.executeTest(cell);
+			case "markdown":
+			case "equation":
+			case "visualization": return cell.content;
+			case "data": return this.executeData(cell);
+			default: throw new Error(`Unsupported cell type: ${cell.type}`);
+		}
+	}
+	buildScope(cell) {
+		const scope = {};
+		if (cell.dependsOn) {
+			for (const depId of cell.dependsOn) if (this.outputs.has(depId)) scope[depId] = this.outputs.get(depId);
+		}
+		return scope;
+	}
+	async executeCode(cell) {
+		return evaluate(cell.content, this.buildScope(cell));
+	}
+	async executeTest(cell) {
+		const result = evaluate(cell.content, this.buildScope(cell));
+		if (typeof result !== "boolean") throw new Error(`test cell must evaluate to a boolean, got ${typeof result}`);
+		return result;
+	}
+	async executeData(cell) {
+		return parseYamlSafe(cell.content);
+	}
+	seedOutputs(entries) {
+		this.outputs = new Map(entries);
+	}
+	async runReport(options = {}) {
+		const cells = [];
+		const cycles = detectCycles(this.graph);
+		if (cycles.length > 0) {
+			const description = cycles.map((cycle) => cycle.join(" -> ")).join("; ");
+			cells.push({
+				id: "(workbook)",
+				type: "code",
+				status: "error",
+				error: `Dependency cycle detected: ${description}`
+			});
+			return {
+				cells,
+				ok: false
+			};
+		}
+		let order = this.graph.executionOrder;
+		if (options.only !== void 0) {
+			const allowed = new Set(getAncestors(this.graph, options.only));
+			order = order.filter((id) => allowed.has(id));
+		}
+		for (const cellId of order) {
+			if (options.runIds && !options.runIds.has(cellId)) continue;
+			const cell = this.workbook.cells.find((c) => c.id === cellId);
+			if (!cell) continue;
+			try {
+				const output = await this.runCell(cellId);
+				if (cell.type === "test") {
+					const passed = output === true;
+					cells.push({
+						id: cell.id,
+						type: cell.type,
+						status: passed ? "pass" : "fail",
+						output,
+						error: passed ? void 0 : `Assertion failed in cell '${cell.id}'`
+					});
+				} else cells.push({
+					id: cell.id,
+					type: cell.type,
+					status: "success",
+					output
+				});
+			} catch (error) {
+				cells.push({
+					id: cell.id,
+					type: cell.type,
+					status: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		return {
+			cells,
+			ok: cells.every((c) => c.status === "success" || c.status === "pass")
+		};
+	}
+	getOutput(cellId) {
+		return this.outputs.get(cellId);
+	}
+};
+function createExecutor(workbook) {
+	return new WorkbookExecutor(workbook);
+}
+//#endregion
+//#region src/formatter.ts
+function bigintReplacer(_key, val) {
+	return typeof val === "bigint" ? `${val}n` : val;
+}
+function safeStringify(value) {
+	try {
+		const json = JSON.stringify(value, bigintReplacer);
+		if (json !== void 0) return json;
+	} catch {}
+	try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		return JSON.stringify(value, (_key, val) => {
+			if (typeof val === "bigint") return `${val}n`;
+			if (val !== null && typeof val === "object") {
+				if (seen.has(val)) return "[Circular]";
+				seen.add(val);
+			}
+			return val;
+		}) ?? "(no result)";
+	} catch {
+		try {
+			return String(value);
+		} catch {
+			return "[unserializable]";
+		}
+	}
+}
+function hasCustomToString(value) {
+	const toString = value.toString;
+	return typeof toString === "function" && toString !== Object.prototype.toString && toString !== Array.prototype.toString;
+}
+function formatResult(value) {
+	if (value === null || value === void 0) return "(no result)";
+	switch (typeof value) {
+		case "string": return value;
+		case "number":
+		case "boolean": return String(value);
+		case "bigint": return `${value}n`;
+		case "function": return "(function)";
+		case "symbol": return value.toString();
+		case "object":
+			if (!Array.isArray(value) && hasCustomToString(value)) try {
+				const text = value.toString();
+				if (text && text !== "[object Object]") return text;
+			} catch {}
+			return safeStringify(value);
+		default: return safeStringify(value);
+	}
+}
+//#endregion
+export { topologicalSort as _, detectCellType as a, parseWorkbook as c, buildDependencyGraph as d, detectCycles as f, toMermaid as g, toDOT as h, SUPPORTED_CELL_TYPES as i, serializeWorkbook as l, getDependents as m, WorkbookExecutor as n, importWorkbook as o, getAncestors as p, createExecutor as r, isValidIdentifier as s, formatResult as t, stripOutputs as u, parseYamlSafe as v };

package/dist/fs-atomic.d.ts

@@ -1,11 +1,19 @@
 /**
  * Atomic file write shared by the CLI write commands and the serve session.
  */
+import { renameSync } from 'node:fs';
+/** Options for tests: the rename to use and how to wait between attempts. */
+export interface AtomicWriteOptions {
+    rename?: typeof renameSync;
+    sleepMs?: (ms: number) => void;
+}
 /**
  * Write `content` to `file` atomically: write a uniquely-named sibling temp
  * file (exclusive create, so a pre-planted symlink can't be hijacked), then
  * rename over the target (atomic on the same filesystem; replaces a symlink
- * rather than writing through it). On any failure the temp file is removed.
+ * rather than writing through it). A rename that fails because another process
+ * holds the target open is retried a few times with a growing wait; any other
+ * error is thrown at once. On any failure the temp file is removed.
  */
-export declare function writeFileAtomic(file: string, content: string): void;
+export declare function writeFileAtomic(file: string, content: string, options?: AtomicWriteOptions): void;
 //# sourceMappingURL=fs-atomic.d.ts.map

package/dist/fs-atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-atomic.d.ts","sourceRoot":"","sources":["../src/fs-atomic.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAanE"}
+{"version":3,"file":"fs-atomic.d.ts","sourceRoot":"","sources":["../src/fs-atomic.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAiB,UAAU,EAAc,MAAM,SAAS,CAAC;AAchE,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,UAAU,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAMD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,kBAAuB,GAC/B,IAAI,CAwBN"}