@danielsimonjr/mathts-workbook 0.4.13 → 0.5.0

package/README.md

@@ -20,6 +20,7 @@ mtsw run example.mtsw -v        # also print the execution event stream
 mtsw run example.mtsw --json    # machine-readable envelope on stdout
 mtsw run example.mtsw -c gauss  # run one cell + its transitive deps (stateless)
 mtsw run example.mtsw --timeout 5000   # run in a worker; killed (exit 1) if it exceeds 5s
+mtsw run example.mtsw --expect-hash <sha256>  # refuse unless file SHA-256 matches
 
 # Describe the structured document model (cells, outputs, dependency graph).
 mtsw describe example.mtsw --json
@@ -30,6 +31,7 @@ mtsw validate example.mtsw [--json]
 # Print the dependency graph (human only; use `describe --json` for structured data).
 mtsw graph example.mtsw                 # text adjacency
 mtsw graph example.mtsw -f mermaid      # Mermaid `graph TD`
+mtsw graph example.mtsw -f dot          # Graphviz `digraph deps { ... }`
 
 # Engine introspection (for tooling / GUIs).
 mtsw capabilities --json                # version, supported cell types, feature flags
@@ -72,6 +74,7 @@ mtsw import doc.json --json               # validates (ids/deps/cycles); stdout
 # Render to a self-contained HTML document (runs first, then renders).
 mtsw export example.mtsw -o example.html     # one offline file; stdout if no -o
 mtsw export example.mtsw --no-run            # render cached outputs without executing
+mtsw export example.mtsw --format tex --fragment -o body.tex  # TeX body only (no preamble)
 mtsw export example.mtsw --json              # envelope: { data: { path, bytes } }
 
 # Other export formats: --format tex|pdf|json|ipynb (html is the default).
@@ -79,20 +82,40 @@ mtsw export example.mtsw --format ipynb -o example.ipynb   # Jupyter notebook (n
 
 # Persistent session for a GUI/tooling: JSON-RPC 2.0 over stdio (NDJSON).
 mtsw serve
+# then JSON-RPC method "open" with params.path — the CLI ignores a file operand
 #   -> {"jsonrpc":"2.0","id":1,"method":"open","params":{"path":"example.mtsw"}}
 #   <- {"jsonrpc":"2.0","id":1,"result":{...describe doc...}}
 #   -> {"jsonrpc":"2.0","id":2,"method":"run"}              # streams cell/event notifications
 #   methods: open/describe/validate/graph/run/cell.*/meta.*/save/capabilities/functions/shutdown
 ```
 
+**`export --format tex` (programmatic).** The same `RenderDoc` the CLI builds for TeX
+export is available as `toTeX` from the package entry (with `RenderDoc`, `RenderCell`,
+and `ToTexOptions`). A fragment omits the LaTeX preamble — the same shape as
+`mtsw export … --format tex --fragment`:
+
+```typescript
+import { toTeX } from '@danielsimonjr/mathts-workbook';
+
+const body = toTeX(
+  { title: 'Notes', cells: [{ type: 'markdown', content: 'Energy $E=mc^2$' }] },
+  { fragment: true }
+);
+// → markdown cell text only; no \\documentclass
+```
+
+Use `buildDependencyGraph` + `toDOT` when you need Graphviz DOT instead of Mermaid
+(`mtsw graph -f dot`).
+
 **`export` (self-contained HTML).** `mtsw export <file> --format html` renders a
 notebook to a single offline `.html` with **no external requests**: markdown prose,
 **equations typeset as MathML** (rendered natively by modern browsers — Chromium ≥109,
 Firefox, Safari), code cells with their embedded outputs, ✓/✗ test badges, and (as of
-the chart slice) inline SVG plots. All rendering is MathTS-native — the generators
-(`toMathML`/`toHTML`/`toCSS`, plus `markdownToHtml`) live in the `expression` package
-alongside the node `.toTex()`/`.toHTML()` serializers, with **zero external
-dependencies**. Equation cells contain MathTS expression syntax (e.g.
+the chart slice) inline SVG plots. Per-node `.toMathML()` / `.toTex()` / `.toHTML()`
+and `mathMLDocument` come from `@danielsimonjr/mathts-expression`; the workbook
+runtime assembles full HTML with `toHTML` / `toCSS` / `markdownToHtml` / `renderChart`
+(workbook modules used by the CLI — not on the workbook package entry except
+`mathMLToSVG`). Equation cells contain MathTS expression syntax (e.g.
 `c = 1 / sqrt(eps0 * mu0)`), not raw LaTeX; they are display-only and rendered via
 `toMathML`. By default `export` runs the workbook first (use `--no-run` for cached
 outputs); a whole-run failure such as a dependency cycle fails loudly rather than
@@ -121,7 +144,7 @@ matrices, …) don't survive the worker's `postMessage`.
 
 **`serve` (persistent session).** One long-lived process holds the workbook in memory with a per-cell result cache and a **stale set**: a `cell.*` edit marks that cell and its transitive dependents stale, and a `run` re-executes **only** the stale cells (reusing cached outputs for the rest) — the incremental latency win a GUI needs. Requests are processed strictly in order; `run` streams `cell/event` notifications (flushed before that run's response in v1, not mid-run). Edits stay in memory until `save`. Single-document per process; concurrent writers are last-write-wins.
 
-**Editing notes.** Cell edits are validity-preserving: an op that would create a duplicate/invalid id, a missing dependency, or a **dependency cycle** is rejected and the file is left byte-for-byte unchanged. Editing a cell clears its (now-stale) persisted output; `--at N` is the cell's final 0-based index; `--force` detaches dependents (clearing their outputs) but does not rewrite cell _content_, so a dependent that still references the removed id by name will error at run. Concurrent editors are last-write-wins (an optimistic-lock guard arrives with the `serve` session).
+**Editing notes.** Cell edits are validity-preserving: an op that would create a duplicate/invalid id, a missing dependency, or a **dependency cycle** is rejected and the file is left byte-for-byte unchanged. Editing a cell clears its (now-stale) persisted output; `--at N` is the cell's final 0-based index; `--force` detaches dependents (clearing their outputs) but does not rewrite cell _content_, so a dependent that still references the removed id by name will error at run. Concurrent editors are last-write-wins in `serve` (last accepted `cell.*` op wins; use `save` to persist).
 
 Diagnostics and errors are written to stderr; results (including `--json`) go to stdout, so the exit code can be used in scripts independently of the output.
 
@@ -133,8 +156,8 @@ should read `ok` and treat a missing/unparseable envelope as the only transport
 error. Compatibility rule: ignore unknown fields when `major` matches; refuse on
 a `major` mismatch. `run --cell <id>` is stateless (it recomputes the target's
 transitive deps each call; `run --cell --write` persists only the executed
-cells). This is the contract a GUI binds to; a persistent `serve` mode (streaming
-events, incremental re-execution) is planned.
+cells). Stateful editing and incremental re-execution live in `mtsw serve` (see
+above); one-shot commands use this envelope only.
 
 **Saving / round-trip.** `serializeWorkbook` (and the write commands above) round-trips a workbook through the parser: structure is preserved exactly, and persisted `output` values round-trip best-effort (plain numbers/strings/arrays/objects exactly; exotic types to their plain shape). All writes are **atomic** (temp file + rename). Note that any write path is parse→serialize and therefore **drops YAML comments and re-orders keys** — a CST-preserving in-place rewrite is a future enhancement.
 
@@ -224,19 +247,23 @@ A `test` cell's expression must evaluate to a **boolean**: `true` passes, `false
 
 ## Cell types (v1)
 
-| Type                                               | Status | Description                                            |
-| -------------------------------------------------- | ------ | ------------------------------------------------------ |
-| `markdown`                                         | ✅     | Documentation (passed through verbatim)                |
-| `code`                                             | ✅     | MathTS expression script; last value is the result     |
-| `data`                                             | ✅     | Structured YAML, parsed (hardened) into a value        |
-| `test`                                             | ✅     | Boolean assertion (`true` = pass)                      |
-| `tensor` / `equation` / `visualization` / `export` | ⏳     | Reserved; not executed in v1 (reported as unsupported) |
+| Type            | Status | Description                                                                                                                                |
+| --------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `markdown`      | ✅     | Documentation (passed through verbatim)                                                                                                    |
+| `code`          | ✅     | MathTS expression script; last value is the result                                                                                         |
+| `data`          | ✅     | Structured YAML, parsed (hardened) into a value                                                                                            |
+| `test`          | ✅     | Boolean assertion (`true` = pass)                                                                                                          |
+| `equation`      | ✅     | MathTS expression syntax; display-only (content echoed, not evaluated)                                                                     |
+| `visualization` | ✅     | Chart/visual spec; display-only (content echoed, not evaluated)                                                                            |
+| `tensor`        | ⏳     | Deferred — parse fails: `type 'tensor' is reserved but not yet supported (supported: code, markdown, data, test, equation, visualization)` |
+| `export`        | ⏳     | Same as `tensor` (`export` is reserved; not in the supported list)                                                                         |
 
 ## Execution modes
 
-- **reactive** — emits stale events for dependents when a cell re-runs
-- **sequential** — top-to-bottom (dependency) order
-- **manual** — explicit trigger only
+All modes execute cells in dependency order (`graph.executionOrder`). The only
+runtime difference is **reactive**, which emits `cell:stale` for dependents when a
+cell is edited or re-run. **Sequential** and **manual** use the same execution order
+without stale events (both still run the full graph on `run` / `runReport`).
 
 ## Security
 

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AAsCH;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAwOD;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAqHvE;AAqDD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAoC7D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA+C7D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAYjE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAa9D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAU9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA2DzD;AAoFD;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CA8H1E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,OAAO,CAAC,IAAI,CAAC,CAuEf;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC,CAG3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAsC1D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA0B1D;AAuDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAqFxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAiD3D;AAyED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA4HzD;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAuDrE"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AAsCH;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AA8OD;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAqHvE;AAqDD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAoC7D;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA+C7D;AAkBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CASjE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAO9D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAO9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA2DzD;AAoFD;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CA8H1E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,GAC7C,OAAO,CAAC,IAAI,CAAC,CAuEf;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC,CAG3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAsC1D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA0B1D;AAuDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAqFxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAiD3D;AAyED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CA4HzD;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAuDrE"}

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, g as toMermaid, h as toDOT, l as serializeWorkbook, o as importWorkbook, r as createExecutor, t as formatResult, u as stripOutputs, v as parseYamlSafe } from "./formatter-8ja3r-YP.js";
-import { a as capabilitiesInfo, c as writeFileAtomic, d as addCell, f as editCell, g as setMetadata, h as renameCell, i as describeData, l as SCHEMA_VERSION, m as removeCell, n as runWorkbookWithTimeout, o as listFunctions, p as moveCell, r as handleRequest, s as Session, u as VERSION } from "./timeout-runner-5b5WJXJi.js";
+import { c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, g as toMermaid, h as toDOT, l as serializeWorkbook, o as importWorkbook, r as createExecutor, t as formatResult, u as stripOutputs, v as parseYamlSafe } from "./formatter-Dwrza-un.js";
+import { _ as toTeX, a as capabilitiesInfo, c as writeFileAtomic, d as addCell, f as editCell, g as setMetadata, h as renameCell, i as describeData, l as SCHEMA_VERSION, m as removeCell, n as runWorkbookWithTimeout, o as listFunctions, p as moveCell, r as handleRequest, s as Session, u as VERSION, v as markdownToHtml, y as renderChart } from "./timeout-runner-C249B3OS.js";
 import * as mathFunctions from "@danielsimonjr/mathts-functions";
 import { lstatSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
@@ -8,253 +8,7 @@ import { pathToFileURL } from "node:url";
 import { basename } from "node:path";
 import { createInterface } from "node:readline";
 import { mathMLDocument, mathMLError } from "@danielsimonjr/mathts-expression";
-import { bar, line, scatter } from "@danielsimonjr/mathts-plot";
 import { latexToPdf } from "@danielsimonjr/mathts-plot/render";
-//#region src/markdown.ts
-function esc$1(s) {
-	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function sanitizeHrefRaw(href) {
-	const h = href.trim();
-	let probe = h.replace(/&amp;/g, "&");
-	try {
-		probe = decodeURIComponent(probe);
-	} catch {}
-	if (probe.startsWith("//")) return null;
-	try {
-		const url = new URL(probe);
-		if (url.protocol === "http:" || url.protocol === "https:" || url.protocol === "mailto:") return h;
-		return null;
-	} catch {
-		if (probe.startsWith("/") || probe.startsWith("./") || probe.startsWith("../") || probe.startsWith("#")) return h;
-		return null;
-	}
-}
-function sanitizeHref(href) {
-	const raw = sanitizeHrefRaw(href);
-	return raw === null ? null : raw.replace(/"/g, "&quot;");
-}
-function inline(escaped) {
-	let s = escaped.replace(/`([^`]+)`/g, (_m, code) => `<code>${code}</code>`);
-	s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
-	s = s.replace(/\*([^*]+)\*/g, "<em>$1</em>");
-	s = s.replace(/\[([^\]]*)\]\(([^)\s]+)\)/g, (_m, text, href) => {
-		const safe = sanitizeHref(href);
-		return safe ? `<a href="${safe}">${text}</a>` : text;
-	});
-	return s;
-}
-const HR = /^ {0,3}(-{3,}|\*{3,}|_{3,})\s*$/;
-const HEADING = /^(#{1,6})\s+(.*)$/;
-const UL = /^\s*[-*+]\s+/;
-const OL = /^\s*\d+\.\s+/;
-function isBlockStart(line) {
-	return line.trim() === "" || /^```/.test(line.trim()) || HEADING.test(line) || UL.test(line) || OL.test(line) || HR.test(line);
-}
-function markdownToHtml(src) {
-	if (!src) return "";
-	const lines = src.replace(/\r\n?/g, "\n").split("\n");
-	const out = [];
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i];
-		if (/^```/.test(line.trim())) {
-			const buf = [];
-			i++;
-			while (i < lines.length && !/^```/.test(lines[i].trim())) {
-				buf.push(lines[i]);
-				i++;
-			}
-			i++;
-			out.push(`<pre><code>${esc$1(buf.join("\n"))}</code></pre>`);
-			continue;
-		}
-		if (line.trim() === "") {
-			i++;
-			continue;
-		}
-		if (HR.test(line)) {
-			out.push("<hr>");
-			i++;
-			continue;
-		}
-		const h = HEADING.exec(line);
-		if (h) {
-			const lvl = h[1].length;
-			out.push(`<h${lvl}>${inline(esc$1(h[2].trim()))}</h${lvl}>`);
-			i++;
-			continue;
-		}
-		if (UL.test(line)) {
-			const items = [];
-			while (i < lines.length && UL.test(lines[i])) {
-				items.push(`<li>${inline(esc$1(lines[i].replace(UL, "")))}</li>`);
-				i++;
-			}
-			out.push(`<ul>${items.join("")}</ul>`);
-			continue;
-		}
-		if (OL.test(line)) {
-			const items = [];
-			while (i < lines.length && OL.test(lines[i])) {
-				items.push(`<li>${inline(esc$1(lines[i].replace(OL, "")))}</li>`);
-				i++;
-			}
-			out.push(`<ol>${items.join("")}</ol>`);
-			continue;
-		}
-		const para = [];
-		while (i < lines.length && !isBlockStart(lines[i])) {
-			para.push(lines[i]);
-			i++;
-		}
-		out.push(`<p>${inline(esc$1(para.join(" ")))}</p>`);
-	}
-	return out.join("\n");
-}
-function texEscape(s) {
-	return s.replace(/[\\&%$#_{}~^]/g, (c) => {
-		switch (c) {
-			case "\\": return "\\textbackslash{}";
-			case "~": return "\\textasciitilde{}";
-			case "^": return "\\textasciicircum{}";
-			default: return `\\${c}`;
-		}
-	});
-}
-function verbatimBody(body, env) {
-	return body.split(`\\end{${env}}`).join(`\\end {${env}}`);
-}
-function escapeInlineNonLink(text) {
-	let s = texEscape(text);
-	s = s.replace(/`([^`]+)`/g, (_m, code) => `\\texttt{${code}}`);
-	s = s.replace(/\*\*([^*]+)\*\*/g, "\\textbf{$1}");
-	s = s.replace(/\*([^*]+)\*/g, "\\emph{$1}");
-	return s;
-}
-function inlineTex(text) {
-	const linkRe = /\[([^\]]*)\]\(([^)\s]+)\)/g;
-	let out = "";
-	let last = 0;
-	let m;
-	while ((m = linkRe.exec(text)) !== null) {
-		out += escapeInlineNonLink(text.slice(last, m.index));
-		const raw = sanitizeHrefRaw(m[2]);
-		out += raw ? `\\href{${texEscape(raw)}}{${escapeInlineNonLink(m[1])}}` : escapeInlineNonLink(m[1]);
-		last = linkRe.lastIndex;
-	}
-	out += escapeInlineNonLink(text.slice(last));
-	return out;
-}
-function markdownToTex(src) {
-	if (!src) return "";
-	const lines = src.replace(/\r\n?/g, "\n").split("\n");
-	const out = [];
-	let i = 0;
-	const SEC = [
-		"\\section*",
-		"\\subsection*",
-		"\\subsubsection*",
-		"\\paragraph"
-	];
-	while (i < lines.length) {
-		const line = lines[i];
-		if (/^```/.test(line.trim())) {
-			const buf = [];
-			i++;
-			while (i < lines.length && !/^```/.test(lines[i].trim())) {
-				buf.push(lines[i]);
-				i++;
-			}
-			i++;
-			out.push(`\\begin{lstlisting}\n${verbatimBody(buf.join("\n"), "lstlisting")}\n\\end{lstlisting}`);
-			continue;
-		}
-		if (line.trim() === "") {
-			i++;
-			continue;
-		}
-		if (HR.test(line)) {
-			out.push("\\par\\noindent\\rule{\\linewidth}{0.4pt}\\par");
-			i++;
-			continue;
-		}
-		const h = HEADING.exec(line);
-		if (h) {
-			const lvl = Math.min(h[1].length, 4);
-			out.push(`${SEC[lvl - 1]}{${inlineTex(h[2].trim())}}`);
-			i++;
-			continue;
-		}
-		if (UL.test(line)) {
-			const items = [];
-			while (i < lines.length && UL.test(lines[i])) {
-				items.push(`  \\item ${inlineTex(lines[i].replace(UL, ""))}`);
-				i++;
-			}
-			out.push(`\\begin{itemize}\n${items.join("\n")}\n\\end{itemize}`);
-			continue;
-		}
-		if (OL.test(line)) {
-			const items = [];
-			while (i < lines.length && OL.test(lines[i])) {
-				items.push(`  \\item ${inlineTex(lines[i].replace(OL, ""))}`);
-				i++;
-			}
-			out.push(`\\begin{enumerate}\n${items.join("\n")}\n\\end{enumerate}`);
-			continue;
-		}
-		const para = [];
-		while (i < lines.length && !isBlockStart(lines[i])) {
-			para.push(lines[i]);
-			i++;
-		}
-		out.push(inlineTex(para.join(" ")));
-	}
-	return out.join("\n\n");
-}
-//#endregion
-//#region src/svg.ts
-function coerce(v) {
-	if (typeof v === "number") return v;
-	if (typeof v === "bigint") return Number(v);
-	const u = v;
-	if (u && typeof u.toNumeric === "function") try {
-		return Number(u.toNumeric());
-	} catch {
-		return NaN;
-	}
-	return Number(v);
-}
-function toNums(raw) {
-	let arr = raw;
-	const m = raw;
-	if (m && typeof m.toArray === "function") try {
-		arr = m.toArray();
-	} catch {
-		arr = raw;
-	}
-	return Array.isArray(arr) ? arr.flat(Infinity).map(coerce) : [];
-}
-function renderChart(spec, xRaw, yRaw, format = "svg") {
-	const xs = toNums(xRaw);
-	const ys = toNums(yRaw);
-	const opts = format === "tikz" ? {
-		title: spec.title,
-		xLabel: spec.xLabel,
-		yLabel: spec.yLabel,
-		format: "tikz",
-		tikz: { standalone: false }
-	} : {
-		title: spec.title,
-		xLabel: spec.xLabel,
-		yLabel: spec.yLabel
-	};
-	if (spec.type === "scatter") return scatter(xs, ys, opts);
-	if (spec.type === "bar") return bar(xs, ys, opts);
-	return line(xs, ys, opts);
-}
-//#endregion
 //#region src/html.ts
 function esc(s) {
 	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -366,65 +120,6 @@ function toHTML(doc, options = {}) {
 	].join("\n");
 }
 //#endregion
-//#region src/tex.ts
-const PREAMBLE = [
-	"\\documentclass{article}",
-	"\\usepackage{amsmath}",
-	"\\usepackage{tikz}",
-	"\\usepackage{listings}",
-	"\\usepackage{xcolor}",
-	"\\usepackage[margin=1in]{geometry}",
-	"\\usepackage{hyperref}"
-].join("\n");
-function renderEquationTex(content, parse) {
-	if (parse) try {
-		return `\\[ ${parse(content).toTex()} \\]`;
-	} catch {}
-	return `\\texttt{${texEscape(content)}}`;
-}
-function renderCellTex(cell, parse) {
-	switch (cell.type) {
-		case "markdown": return markdownToTex(cell.content);
-		case "equation": return renderEquationTex(cell.content, parse);
-		case "code": {
-			const cap = cell.id ? `\\textit{${texEscape(cell.id)}}\\\\\n` : "";
-			const src = `\\begin{lstlisting}\n${verbatimBody(cell.content, "lstlisting")}\n\\end{lstlisting}`;
-			let res = "";
-			if (cell.error !== void 0) res = `\n\n\\textcolor{red}{\\texttt{${texEscape(cell.error)}}}`;
-			else if (cell.output !== void 0) res = `\n\n\\begin{verbatim}\n${verbatimBody(cell.output, "verbatim")}\n\\end{verbatim}`;
-			return `${cap}${src}${res}`;
-		}
-		case "test": {
-			const label = `\\texttt{${texEscape(cell.content)}}`;
-			if (cell.error !== void 0) return `\\textcolor{orange}{[ERROR]} ${label} --- ${texEscape(cell.error)}`;
-			if (cell.passed === true) return `\\textcolor{green!60!black}{[PASS]} ${label}`;
-			if (cell.passed === false) return `\\textcolor{red}{[FAIL]} ${label}`;
-			return `\\textcolor{gray}{[NOT RUN]} ${label}`;
-		}
-		case "data": {
-			const val = cell.error !== void 0 ? cell.error : cell.output ?? "";
-			return `${cell.id ? `\\textit{${texEscape(cell.id)}}\\\\\n` : ""}\\begin{verbatim}\n${verbatimBody(val, "verbatim")}\n\\end{verbatim}`;
-		}
-		case "chart": return `\\begin{center}\n${cell.chart ? renderChart(cell.chart.spec, cell.chart.x, cell.chart.y, "tikz") : "% no chart"}\n\\end{center}${cell.note ? `\n\n\\textit{${texEscape(cell.note)}}` : ""}`;
-		default: return `\\begin{verbatim}\n${verbatimBody(cell.content, "verbatim")}\n\\end{verbatim}`;
-	}
-}
-function toTeX(doc, options = {}) {
-	const body = doc.cells.map((c) => renderCellTex(c, options.parse)).join("\n\n");
-	if (options.fragment) return body;
-	const meta = [];
-	if (doc.title) meta.push(`\\title{${texEscape(doc.title)}}`);
-	if (doc.author) meta.push(`\\author{${texEscape(doc.author)}}`);
-	const maketitle = doc.title ? "\\maketitle\n" : "";
-	return [
-		PREAMBLE,
-		...meta,
-		"\\begin{document}",
-		`${maketitle}${body}`,
-		"\\end{document}"
-	].join("\n");
-}
-//#endregion
 //#region src/pdf.ts
 function toPDF(doc, outPath, options = {}) {
 	const { parse, ...renderOpts } = options;
@@ -595,7 +290,10 @@ function jsonEnvelope(command, ok, data, problems = []) {
 		return value;
 	};
 	return JSON.stringify({
-		schemaVersion: SCHEMA_VERSION,
+		schemaVersion: {
+			major: SCHEMA_VERSION.major,
+			minor: SCHEMA_VERSION.minor
+		},
 		command,
 		ok,
 		data,
@@ -934,52 +632,38 @@ function describeCommand(args) {
 		exitCode: ok ? 0 : 1
 	};
 }
-function capabilitiesCommand(args) {
-	const data = capabilitiesInfo();
+function renderInfoCommand(args, command, data, lines) {
 	if (args.includes("--json")) return {
-		stdout: jsonEnvelope("capabilities", true, data, []),
+		stdout: jsonEnvelope(command, true, data, []),
 		stderr: "",
 		exitCode: 0
 	};
 	return {
-		stdout: [
-			`mtsw ${data.version} (schema ${SCHEMA_VERSION.major}.${SCHEMA_VERSION.minor})`,
-			`supported cells: ${data.cellTypes.supported.join(", ")}`,
-			`deferred cells: ${data.cellTypes.deferred.join(", ")}`,
-			`commands: ${data.commands.join(", ")}`
-		].join("\n"),
+		stdout: lines.join("\n"),
 		stderr: "",
 		exitCode: 0
 	};
 }
+function capabilitiesCommand(args) {
+	const data = capabilitiesInfo();
+	return renderInfoCommand(args, "capabilities", data, [
+		`mtsw ${data.version} (schema ${SCHEMA_VERSION.major}.${SCHEMA_VERSION.minor})`,
+		`supported cells: ${data.cellTypes.supported.join(", ")}`,
+		`deferred cells: ${data.cellTypes.deferred.join(", ")}`,
+		`commands: ${data.commands.join(", ")}`
+	]);
+}
 function templatesCommand(args) {
 	const templates = Object.entries(TEMPLATES).map(([name, t]) => ({
 		name,
 		description: t.description
 	}));
-	if (args.includes("--json")) return {
-		stdout: jsonEnvelope("templates", true, { templates }, []),
-		stderr: "",
-		exitCode: 0
-	};
-	return {
-		stdout: templates.map((t) => `${t.name} - ${t.description}`).join("\n"),
-		stderr: "",
-		exitCode: 0
-	};
+	const lines = templates.map((t) => `${t.name} - ${t.description}`);
+	return renderInfoCommand(args, "templates", { templates }, lines);
 }
 function functionsCommand(args) {
 	const data = listFunctions();
-	if (args.includes("--json")) return {
-		stdout: jsonEnvelope("functions", true, data, []),
-		stderr: "",
-		exitCode: 0
-	};
-	return {
-		stdout: [`functions (${data.functions.length}): ${data.functions.join(", ")}`, `constants (${data.constants.length}): ${data.constants.join(", ")}`].join("\n"),
-		stderr: "",
-		exitCode: 0
-	};
+	return renderInfoCommand(args, "functions", data, [`functions (${data.functions.length}): ${data.functions.join(", ")}`, `constants (${data.constants.length}): ${data.constants.join(", ")}`]);
 }
 function metaCommand(args) {
 	const json = args.includes("--json");

package/dist/{formatter-8ja3r-YP.js → formatter-Dwrza-un.js}

@@ -102,18 +102,27 @@ function getAncestors(graph, id) {
 	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}`);
+function renderDependencyGraph(graph, format) {
+	const lines = [format.header];
+	for (const id of graph.nodes.keys()) lines.push(format.node(id));
+	for (const [id, node] of graph.nodes) for (const dep of node.dependencies) lines.push(format.edge(dep, id));
+	if (format.footer !== void 0) lines.push(format.footer);
 	return lines.join("\n");
 }
+function toMermaid(graph) {
+	return renderDependencyGraph(graph, {
+		header: "graph TD",
+		node: (id) => `  ${id}["${id}"]`,
+		edge: (dep, id) => `  ${dep} --> ${id}`
+	});
+}
 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");
+	return renderDependencyGraph(graph, {
+		header: "digraph deps {",
+		node: (id) => `  ${id} [label="${id}"];`,
+		edge: (dep, id) => `  ${dep} -> ${id};`,
+		footer: "}"
+	});
 }
 function detectCycles(graph) {
 	const cycles = [];

package/dist/graph.d.ts

@@ -32,6 +32,12 @@ export declare function toMermaid(graph: DependencyGraph): string;
  * Render the dependency graph as Graphviz DOT (the DOT analog of toMermaid).
  * Cell ids are validated identifiers ([A-Za-z_][A-Za-z0-9_]*), safe verbatim as
  * both node id and quoted label; no cell content appears in the output.
+ *
+ * @example
+ * ```ts
+ * import { buildDependencyGraph, toDOT } from '@danielsimonjr/mathts-workbook';
+ * toDOT(buildDependencyGraph(cells)); // digraph deps { … }
+ * ```
  */
 export declare function toDOT(graph: DependencyGraph): string;
 /**

package/dist/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,eAAe,CA0BnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,EAAE,CAuB5E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB9E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAezE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAcxD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAepD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,EAAE,EAAE,CAoC/D"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExE;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,eAAe,CA0BnE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,MAAM,EAAE,CAuB5E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB9E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAezE;AAkCD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAMxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAOpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,EAAE,EAAE,CAoC/D"}

package/dist/index.d.ts

@@ -2,11 +2,14 @@
  * @danielsimonjr/mathts-workbook - Scientific workbook runtime
  * @packageDocumentation
  */
-export type { Workbook, Cell, CellType, ExecutionMode, WorkbookMetadata, RuntimeConfig, ParseResult, WorkbookEvent, CellResult, RunResult, } from './types.js';
+export type { Workbook, Cell, CellType, ExecutionMode, WorkbookMetadata, RuntimeConfig, ParseResult, WorkbookEvent, CellResult, RunResult, DependencyNode, DependencyGraph, } from './types.js';
 export { parseWorkbook, serializeWorkbook, stripOutputs, detectCellType } from './parser.js';
-export { buildDependencyGraph, topologicalSort, getDependents, detectCycles, getAncestors, toMermaid, } from './graph.js';
+export { buildDependencyGraph, topologicalSort, getDependents, detectCycles, getAncestors, toMermaid, toDOT, } from './graph.js';
 export { WorkbookExecutor, createExecutor } from './executor.js';
 export { formatResult } from './formatter.js';
+export { toTeX } from './tex.js';
+export type { ToTexOptions } from './tex.js';
+export type { RenderDoc, RenderCell } from './html.js';
 export { addCell, editCell, removeCell, moveCell, renameCell, setMetadata } from './edit.js';
 export type { CellPosition, RemoveResult } from './edit.js';
 export { SCHEMA_VERSION, VERSION } from './contract.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,aAAa,EACb,UAAU,EACV,SAAS,GACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7F,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AACnF,YAAY,EACV,6BAA6B,EAC7B,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,aAAa,EACb,UAAU,EACV,SAAS,EACT,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,KAAK,GACN,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7F,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG5D,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AACnF,YAAY,EACV,6BAA6B,EAC7B,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,5 +1,5 @@
-import { _ as topologicalSort, a as detectCellType, c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, g as toMermaid, l as serializeWorkbook, m as getDependents, n as WorkbookExecutor, p as getAncestors, r as createExecutor, t as formatResult, u as stripOutputs } from "./formatter-8ja3r-YP.js";
-import { d as addCell, f as editCell, g as setMetadata, h as renameCell, l as SCHEMA_VERSION, m as removeCell, n as runWorkbookWithTimeout, p as moveCell, r as handleRequest, s as Session, t as WorkbookTimeoutError, u as VERSION } from "./timeout-runner-5b5WJXJi.js";
+import { _ as topologicalSort, a as detectCellType, c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, g as toMermaid, h as toDOT, l as serializeWorkbook, m as getDependents, n as WorkbookExecutor, p as getAncestors, r as createExecutor, t as formatResult, u as stripOutputs } from "./formatter-Dwrza-un.js";
+import { _ as toTeX, d as addCell, f as editCell, g as setMetadata, h as renameCell, l as SCHEMA_VERSION, m as removeCell, n as runWorkbookWithTimeout, p as moveCell, r as handleRequest, s as Session, t as WorkbookTimeoutError, u as VERSION } from "./timeout-runner-C249B3OS.js";
 //#region src/svg-math.ts
 function mathMLToSVG(mathml, options = {}) {
 	const display = options.display ?? "block";
@@ -17,4 +17,4 @@ function mathMLToSVG(mathml, options = {}) {
 	].join("");
 }
 //#endregion
-export { SCHEMA_VERSION, Session, VERSION, WorkbookExecutor, WorkbookTimeoutError, addCell, buildDependencyGraph, createExecutor, detectCellType, detectCycles, editCell, formatResult, getAncestors, getDependents, handleRequest, mathMLToSVG, moveCell, parseWorkbook, removeCell, renameCell, runWorkbookWithTimeout, serializeWorkbook, setMetadata, stripOutputs, toMermaid, topologicalSort };
+export { SCHEMA_VERSION, Session, VERSION, WorkbookExecutor, WorkbookTimeoutError, addCell, buildDependencyGraph, createExecutor, detectCellType, detectCycles, editCell, formatResult, getAncestors, getDependents, handleRequest, mathMLToSVG, moveCell, parseWorkbook, removeCell, renameCell, runWorkbookWithTimeout, serializeWorkbook, setMetadata, stripOutputs, toDOT, toMermaid, toTeX, topologicalSort };

package/dist/run-worker.js

@@ -1,4 +1,4 @@
-import { c as parseWorkbook, r as createExecutor, t as formatResult } from "./formatter-8ja3r-YP.js";
+import { c as parseWorkbook, r as createExecutor, t as formatResult } from "./formatter-Dwrza-un.js";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/run-worker.ts
 async function main() {

package/dist/tex.d.ts

@@ -15,6 +15,14 @@ export interface ToTexOptions {
     /** Emit only the cell bodies (for \input) instead of a standalone document. */
     fragment?: boolean;
 }
-/** Render a document structure to a standalone (or fragment) LaTeX string. Never throws. */
+/**
+ * Render a document structure to a standalone (or fragment) LaTeX string. Never throws.
+ *
+ * @example Fragment body for `\input` (no preamble):
+ * ```ts
+ * import { toTeX } from '@danielsimonjr/mathts-workbook';
+ * toTeX({ cells: [{ type: 'markdown', content: 'hi' }] }, { fragment: true });
+ * ```
+ */
 export declare function toTeX(doc: RenderDoc, options?: ToTexOptions): string;
 //# sourceMappingURL=tex.d.ts.map

package/dist/tex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tex.d.ts","sourceRoot":"","sources":["../src/tex.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,WAAW,CAAC;AAIvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiED,4FAA4F;AAC5F,wBAAgB,KAAK,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAUxE"}
+{"version":3,"file":"tex.d.ts","sourceRoot":"","sources":["../src/tex.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,WAAW,CAAC;AAIvD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAUxE"}

package/dist/{timeout-runner-5b5WJXJi.js → timeout-runner-C249B3OS.js}

@@ -1,7 +1,312 @@
-import { c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, i as SUPPORTED_CELL_TYPES, l as serializeWorkbook, m as getDependents, n as WorkbookExecutor, p as getAncestors, s as isValidIdentifier } from "./formatter-8ja3r-YP.js";
+import { c as parseWorkbook, d as buildDependencyGraph, f as detectCycles, i as SUPPORTED_CELL_TYPES, l as serializeWorkbook, m as getDependents, n as WorkbookExecutor, p as getAncestors, s as isValidIdentifier } from "./formatter-Dwrza-un.js";
 import * as mathFunctions from "@danielsimonjr/mathts-functions";
+import { bar, line, scatter } from "@danielsimonjr/mathts-plot";
 import { readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { Worker } from "node:worker_threads";
+//#region src/svg.ts
+function coerce(v) {
+	if (typeof v === "number") return v;
+	if (typeof v === "bigint") return Number(v);
+	const u = v;
+	if (u && typeof u.toNumeric === "function") try {
+		return Number(u.toNumeric());
+	} catch {
+		return NaN;
+	}
+	return Number(v);
+}
+function toNums(raw) {
+	let arr = raw;
+	const m = raw;
+	if (m && typeof m.toArray === "function") try {
+		arr = m.toArray();
+	} catch {
+		arr = raw;
+	}
+	return Array.isArray(arr) ? arr.flat(Infinity).map(coerce) : [];
+}
+function renderChart(spec, xRaw, yRaw, format = "svg") {
+	const xs = toNums(xRaw);
+	const ys = toNums(yRaw);
+	const opts = format === "tikz" ? {
+		title: spec.title,
+		xLabel: spec.xLabel,
+		yLabel: spec.yLabel,
+		format: "tikz",
+		tikz: { standalone: false }
+	} : {
+		title: spec.title,
+		xLabel: spec.xLabel,
+		yLabel: spec.yLabel
+	};
+	if (spec.type === "scatter") return scatter(xs, ys, opts);
+	if (spec.type === "bar") return bar(xs, ys, opts);
+	return line(xs, ys, opts);
+}
+//#endregion
+//#region src/markdown.ts
+function esc(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function sanitizeHrefRaw(href) {
+	const h = href.trim();
+	let probe = h.replace(/&amp;/g, "&");
+	try {
+		probe = decodeURIComponent(probe);
+	} catch {}
+	if (probe.startsWith("//")) return null;
+	try {
+		const url = new URL(probe);
+		if (url.protocol === "http:" || url.protocol === "https:" || url.protocol === "mailto:") return h;
+		return null;
+	} catch {
+		if (probe.startsWith("/") || probe.startsWith("./") || probe.startsWith("../") || probe.startsWith("#")) return h;
+		return null;
+	}
+}
+function sanitizeHref(href) {
+	const raw = sanitizeHrefRaw(href);
+	return raw === null ? null : raw.replace(/"/g, "&quot;");
+}
+function inline(escaped) {
+	let s = escaped.replace(/`([^`]+)`/g, (_m, code) => `<code>${code}</code>`);
+	s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+	s = s.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+	s = s.replace(/\[([^\]]*)\]\(([^)\s]+)\)/g, (_m, text, href) => {
+		const safe = sanitizeHref(href);
+		return safe ? `<a href="${safe}">${text}</a>` : text;
+	});
+	return s;
+}
+const HR = /^ {0,3}(-{3,}|\*{3,}|_{3,})\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const UL = /^\s*[-*+]\s+/;
+const OL = /^\s*\d+\.\s+/;
+function isBlockStart(line) {
+	return line.trim() === "" || /^```/.test(line.trim()) || HEADING.test(line) || UL.test(line) || OL.test(line) || HR.test(line);
+}
+function markdownToHtml(src) {
+	if (!src) return "";
+	const lines = src.replace(/\r\n?/g, "\n").split("\n");
+	const out = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (/^```/.test(line.trim())) {
+			const buf = [];
+			i++;
+			while (i < lines.length && !/^```/.test(lines[i].trim())) {
+				buf.push(lines[i]);
+				i++;
+			}
+			i++;
+			out.push(`<pre><code>${esc(buf.join("\n"))}</code></pre>`);
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		if (HR.test(line)) {
+			out.push("<hr>");
+			i++;
+			continue;
+		}
+		const h = HEADING.exec(line);
+		if (h) {
+			const lvl = h[1].length;
+			out.push(`<h${lvl}>${inline(esc(h[2].trim()))}</h${lvl}>`);
+			i++;
+			continue;
+		}
+		if (UL.test(line)) {
+			const items = [];
+			while (i < lines.length && UL.test(lines[i])) {
+				items.push(`<li>${inline(esc(lines[i].replace(UL, "")))}</li>`);
+				i++;
+			}
+			out.push(`<ul>${items.join("")}</ul>`);
+			continue;
+		}
+		if (OL.test(line)) {
+			const items = [];
+			while (i < lines.length && OL.test(lines[i])) {
+				items.push(`<li>${inline(esc(lines[i].replace(OL, "")))}</li>`);
+				i++;
+			}
+			out.push(`<ol>${items.join("")}</ol>`);
+			continue;
+		}
+		const para = [];
+		while (i < lines.length && !isBlockStart(lines[i])) {
+			para.push(lines[i]);
+			i++;
+		}
+		out.push(`<p>${inline(esc(para.join(" ")))}</p>`);
+	}
+	return out.join("\n");
+}
+function texEscape(s) {
+	return s.replace(/[\\&%$#_{}~^]/g, (c) => {
+		switch (c) {
+			case "\\": return "\\textbackslash{}";
+			case "~": return "\\textasciitilde{}";
+			case "^": return "\\textasciicircum{}";
+			default: return `\\${c}`;
+		}
+	});
+}
+function verbatimBody(body, env) {
+	return body.split(`\\end{${env}}`).join(`\\end {${env}}`);
+}
+function escapeInlineNonLink(text) {
+	let s = texEscape(text);
+	s = s.replace(/`([^`]+)`/g, (_m, code) => `\\texttt{${code}}`);
+	s = s.replace(/\*\*([^*]+)\*\*/g, "\\textbf{$1}");
+	s = s.replace(/\*([^*]+)\*/g, "\\emph{$1}");
+	return s;
+}
+function inlineTex(text) {
+	const linkRe = /\[([^\]]*)\]\(([^)\s]+)\)/g;
+	let out = "";
+	let last = 0;
+	let m;
+	while ((m = linkRe.exec(text)) !== null) {
+		out += escapeInlineNonLink(text.slice(last, m.index));
+		const raw = sanitizeHrefRaw(m[2]);
+		out += raw ? `\\href{${texEscape(raw)}}{${escapeInlineNonLink(m[1])}}` : escapeInlineNonLink(m[1]);
+		last = linkRe.lastIndex;
+	}
+	out += escapeInlineNonLink(text.slice(last));
+	return out;
+}
+function markdownToTex(src) {
+	if (!src) return "";
+	const lines = src.replace(/\r\n?/g, "\n").split("\n");
+	const out = [];
+	let i = 0;
+	const SEC = [
+		"\\section*",
+		"\\subsection*",
+		"\\subsubsection*",
+		"\\paragraph"
+	];
+	while (i < lines.length) {
+		const line = lines[i];
+		if (/^```/.test(line.trim())) {
+			const buf = [];
+			i++;
+			while (i < lines.length && !/^```/.test(lines[i].trim())) {
+				buf.push(lines[i]);
+				i++;
+			}
+			i++;
+			out.push(`\\begin{lstlisting}\n${verbatimBody(buf.join("\n"), "lstlisting")}\n\\end{lstlisting}`);
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		if (HR.test(line)) {
+			out.push("\\par\\noindent\\rule{\\linewidth}{0.4pt}\\par");
+			i++;
+			continue;
+		}
+		const h = HEADING.exec(line);
+		if (h) {
+			const lvl = Math.min(h[1].length, 4);
+			out.push(`${SEC[lvl - 1]}{${inlineTex(h[2].trim())}}`);
+			i++;
+			continue;
+		}
+		if (UL.test(line)) {
+			const items = [];
+			while (i < lines.length && UL.test(lines[i])) {
+				items.push(`  \\item ${inlineTex(lines[i].replace(UL, ""))}`);
+				i++;
+			}
+			out.push(`\\begin{itemize}\n${items.join("\n")}\n\\end{itemize}`);
+			continue;
+		}
+		if (OL.test(line)) {
+			const items = [];
+			while (i < lines.length && OL.test(lines[i])) {
+				items.push(`  \\item ${inlineTex(lines[i].replace(OL, ""))}`);
+				i++;
+			}
+			out.push(`\\begin{enumerate}\n${items.join("\n")}\n\\end{enumerate}`);
+			continue;
+		}
+		const para = [];
+		while (i < lines.length && !isBlockStart(lines[i])) {
+			para.push(lines[i]);
+			i++;
+		}
+		out.push(inlineTex(para.join(" ")));
+	}
+	return out.join("\n\n");
+}
+//#endregion
+//#region src/tex.ts
+const PREAMBLE = [
+	"\\documentclass{article}",
+	"\\usepackage{amsmath}",
+	"\\usepackage{tikz}",
+	"\\usepackage{listings}",
+	"\\usepackage{xcolor}",
+	"\\usepackage[margin=1in]{geometry}",
+	"\\usepackage{hyperref}"
+].join("\n");
+function renderEquationTex(content, parse) {
+	if (parse) try {
+		return `\\[ ${parse(content).toTex()} \\]`;
+	} catch {}
+	return `\\texttt{${texEscape(content)}}`;
+}
+function renderCellTex(cell, parse) {
+	switch (cell.type) {
+		case "markdown": return markdownToTex(cell.content);
+		case "equation": return renderEquationTex(cell.content, parse);
+		case "code": {
+			const cap = cell.id ? `\\textit{${texEscape(cell.id)}}\\\\\n` : "";
+			const src = `\\begin{lstlisting}\n${verbatimBody(cell.content, "lstlisting")}\n\\end{lstlisting}`;
+			let res = "";
+			if (cell.error !== void 0) res = `\n\n\\textcolor{red}{\\texttt{${texEscape(cell.error)}}}`;
+			else if (cell.output !== void 0) res = `\n\n\\begin{verbatim}\n${verbatimBody(cell.output, "verbatim")}\n\\end{verbatim}`;
+			return `${cap}${src}${res}`;
+		}
+		case "test": {
+			const label = `\\texttt{${texEscape(cell.content)}}`;
+			if (cell.error !== void 0) return `\\textcolor{orange}{[ERROR]} ${label} --- ${texEscape(cell.error)}`;
+			if (cell.passed === true) return `\\textcolor{green!60!black}{[PASS]} ${label}`;
+			if (cell.passed === false) return `\\textcolor{red}{[FAIL]} ${label}`;
+			return `\\textcolor{gray}{[NOT RUN]} ${label}`;
+		}
+		case "data": {
+			const val = cell.error !== void 0 ? cell.error : cell.output ?? "";
+			return `${cell.id ? `\\textit{${texEscape(cell.id)}}\\\\\n` : ""}\\begin{verbatim}\n${verbatimBody(val, "verbatim")}\n\\end{verbatim}`;
+		}
+		case "chart": return `\\begin{center}\n${cell.chart ? renderChart(cell.chart.spec, cell.chart.x, cell.chart.y, "tikz") : "% no chart"}\n\\end{center}${cell.note ? `\n\n\\textit{${texEscape(cell.note)}}` : ""}`;
+		default: return `\\begin{verbatim}\n${verbatimBody(cell.content, "verbatim")}\n\\end{verbatim}`;
+	}
+}
+function toTeX(doc, options = {}) {
+	const body = doc.cells.map((c) => renderCellTex(c, options.parse)).join("\n\n");
+	if (options.fragment) return body;
+	const meta = [];
+	if (doc.title) meta.push(`\\title{${texEscape(doc.title)}}`);
+	if (doc.author) meta.push(`\\author{${texEscape(doc.author)}}`);
+	const maketitle = doc.title ? "\\maketitle\n" : "";
+	return [
+		PREAMBLE,
+		...meta,
+		"\\begin{document}",
+		`${maketitle}${body}`,
+		"\\end{document}"
+	].join("\n");
+}
+//#endregion
 //#region src/edit.ts
 function cloneWorkbook(wb) {
 	return {
@@ -151,7 +456,7 @@ const SCHEMA_VERSION = {
 	major: 1,
 	minor: 0
 };
-const VERSION = "0.4.13";
+const VERSION = "0.5.0";
 const COMMAND_NAMES = [
 	"run",
 	"describe",
@@ -564,4 +869,4 @@ function runWorkbookWithTimeout(source, options) {
 	});
 }
 //#endregion
-export { capabilitiesInfo as a, writeFileAtomic as c, addCell as d, editCell as f, setMetadata as g, renameCell as h, describeData as i, SCHEMA_VERSION as l, removeCell as m, runWorkbookWithTimeout as n, listFunctions as o, moveCell as p, handleRequest as r, Session as s, WorkbookTimeoutError as t, VERSION as u };
+export { toTeX as _, capabilitiesInfo as a, writeFileAtomic as c, addCell as d, editCell as f, setMetadata as g, renameCell as h, describeData as i, SCHEMA_VERSION as l, removeCell as m, runWorkbookWithTimeout as n, listFunctions as o, moveCell as p, handleRequest as r, Session as s, WorkbookTimeoutError as t, VERSION as u, markdownToHtml as v, renderChart as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-workbook",
-  "version": "0.4.13",
+  "version": "0.5.0",
   "description": "Scientific workbook runtime for MathTS (.mtsw format)",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -34,10 +34,10 @@
     "build:prod": "tsdown --minify && tsc -p tsconfig.dts.json"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.19.0",
-    "@danielsimonjr/mathts-expression": "^0.10.3",
-    "@danielsimonjr/mathts-functions": "^0.69.1",
-    "@danielsimonjr/mathts-plot": "^0.4.13",
+    "@danielsimonjr/mathts-core": "^0.20.0",
+    "@danielsimonjr/mathts-expression": "^0.11.0",
+    "@danielsimonjr/mathts-functions": "^0.70.0",
+    "@danielsimonjr/mathts-plot": "^0.4.14",
     "yaml": "^2.3.0"
   },
   "devDependencies": {