@danielsimonjr/mathts-workbook 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -1,502 +1,19 @@
 /**
- * Workbook type definitions
- */
-/**
- * Supported cell types
- */
-type CellType = 'markdown' | 'code' | 'tensor' | 'equation' | 'visualization' | 'data' | 'test' | 'export';
-/**
- * Execution modes
- */
-type ExecutionMode = 'reactive' | 'sequential' | 'manual';
-/**
- * Workbook metadata
- */
-interface WorkbookMetadata {
-    title?: string;
-    author?: string;
-    description?: string;
-    tags?: string[];
-    created?: string;
-    modified?: string;
-}
-/**
- * Runtime configuration
- */
-interface RuntimeConfig {
-    engine: 'mathts' | 'custom';
-    execution: ExecutionMode;
-    timeout?: number;
-}
-/**
- * Individual cell in a workbook
- */
-interface Cell {
-    id: string;
-    type: CellType;
-    content: string;
-    dependsOn?: string[];
-    output?: unknown;
-    error?: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Complete workbook structure
- */
-interface Workbook {
-    version: string;
-    metadata: WorkbookMetadata;
-    runtime: RuntimeConfig;
-    cells: Cell[];
-}
-/**
- * Parse result with validation
- */
-interface ParseResult {
-    success: boolean;
-    workbook?: Workbook;
-    errors?: string[];
-    warnings?: string[];
-}
-/**
- * Workbook execution events
- */
-interface WorkbookEvent {
-    type: 'cell:start' | 'cell:success' | 'cell:error' | 'cell:stale' | 'workbook:complete';
-    cellId?: string;
-    output?: unknown;
-    error?: string;
-    timestamp: number;
-}
-/**
- * Result of executing a single cell in a run report.
- */
-interface CellResult {
-    id: string;
-    type: CellType;
-    status: 'success' | 'error' | 'pass' | 'fail';
-    output?: unknown;
-    error?: string;
-}
-/**
- * Aggregated result of running an entire workbook (continue-on-error).
- */
-interface RunResult {
-    cells: CellResult[];
-    ok: boolean;
-}
-/**
- * Dependency graph node
- */
-interface DependencyNode {
-    id: string;
-    dependencies: string[];
-    dependents: string[];
-}
-/**
- * Dependency graph
- */
-interface DependencyGraph {
-    nodes: Map<string, DependencyNode>;
-    executionOrder: string[];
-}
-
-/**
- * Workbook YAML parser
- */
-
-/**
- * Detect cell type from YAML keys (first match by precedence).
- */
-declare function detectCellType(cell: Record<string, unknown>): CellType;
-/**
- * Parse a workbook from YAML content.
- */
-declare function parseWorkbook(content: string): ParseResult;
-/**
- * Serialize a workbook to YAML that round-trips through {@link parseWorkbook}.
- *
- * Structural fidelity (version/metadata/runtime/cells: id/type/content/dependsOn/
- * metadata) is exact. Persisted `output` values are best-effort: plain
- * primitives/arrays/objects round-trip exactly (the YAML serializer quotes
- * scalars that would otherwise re-type); exotic class instances serialize to
- * their plain shape. Throws only on a structurally invalid workbook.
- */
-declare function serializeWorkbook(workbook: Workbook): string;
-/**
- * Strip outputs from workbook (for git)
- */
-declare function stripOutputs(workbook: Workbook): Workbook;
-
-/**
- * Dependency graph management
- */
-
-/**
- * Build dependency graph from cells
- */
-declare function buildDependencyGraph(cells: Cell[]): DependencyGraph;
-/**
- * Topological sort for execution order
- */
-declare function topologicalSort(nodes: Map<string, DependencyNode>): string[];
-/**
- * Get all cells that depend on a given cell
- */
-declare function getDependents(graph: DependencyGraph, cellId: string): string[];
-/**
- * All transitive dependencies of `id` plus `id` itself (its ancestor closure).
- * Used to run a single cell together with everything it needs. Cycle-safe via
- * a visited set; returns `[]` if `id` is not in the graph.
- */
-declare function getAncestors(graph: DependencyGraph, id: string): string[];
-/**
- * Render the dependency graph as a Mermaid `graph TD` diagram.
- *
- * Cell ids are validated identifiers (`[A-Za-z_][A-Za-z0-9_]*`), so they are
- * safe to use verbatim as both the node id and its quoted label — Mermaid
- * syntax injection is impossible and no cell content appears in the output.
- */
-declare function toMermaid(graph: DependencyGraph): string;
-/**
- * Detect circular dependencies
- */
-declare function detectCycles(graph: DependencyGraph): string[][];
-
-/**
- * Workbook executor
- */
-
-/**
- * Event handler type
- */
-type EventHandler = (event: WorkbookEvent) => void;
-/**
- * Workbook executor with reactive execution support
- */
-declare class WorkbookExecutor {
-    private workbook;
-    private graph;
-    private outputs;
-    private handlers;
-    constructor(workbook: Workbook);
-    /**
-     * Subscribe to execution events
-     */
-    on(handler: EventHandler): () => void;
-    /**
-     * Emit an event to all handlers
-     */
-    private emit;
-    /**
-     * Run all cells in order
-     */
-    runAll(): Promise<void>;
-    /**
-     * Run a specific cell
-     */
-    runCell(cellId: string): Promise<unknown>;
-    /**
-     * Execute a single cell
-     */
-    private executeCell;
-    /**
-     * Build the evaluation scope from a cell's DIRECT dependency outputs.
-     *
-     * Dependency outputs are injected as named variables keyed by the
-     * dependency's cell id, so a cell can reference an earlier cell's result by
-     * that id. Injection is non-transitive: only ids in `cell.dependsOn` are
-     * injected (a dependency's own dependencies are not). An output of
-     * `undefined` (cell never ran) is skipped, so the reference fails loudly.
-     */
-    private buildScope;
-    /**
-     * Execute a code cell by evaluating its content as a MathTS expression.
-     *
-     * Evaluation goes through the MathTS expression engine — property and
-     * method access route through the expression sandbox, so this does not
-     * have the arbitrary-code-execution exposure of the `Function` constructor.
-     */
-    private executeCode;
-    /**
-     * Execute a test cell: evaluate its assertion expression in the dependency
-     * scope. The result must be a boolean — `runReport` classifies `true` as a
-     * pass and `false` as a fail. A non-boolean result is a usage error (a test
-     * that doesn't assert), surfaced via throw like any other evaluation error.
-     */
-    private executeTest;
-    /**
-     * Execute a data cell — parse its content as YAML (a superset of JSON) using
-     * the same hardened options + prototype-pollution guard as the document
-     * parser, so both YAML entry points are consistent.
-     */
-    private executeData;
-    /**
-     * Run every cell in dependency order and return a structured report.
-     *
-     * Unlike {@link runAll} (the event-stream API, which throws on the first cell
-     * error), `runReport` is the headless/report API: it is **continue-on-error**
-     * (one failing cell does not abort the rest) and never throws on a cell
-     * failure. A dependency cycle is refused up front. Test cells are classified
-     * as `pass`/`fail`/`error`; all other cells as `success`/`error`.
-     */
-    /**
-     * Seed the output cache (for incremental session runs): non-stale cells'
-     * outputs are provided so downstream cells can read them as scope without
-     * re-execution. Replaces any existing cached outputs.
-     */
-    seedOutputs(entries: Map<string, unknown>): void;
-    runReport(options?: {
-        only?: string;
-        runIds?: Set<string>;
-    }): Promise<RunResult>;
-    /**
-     * Get output from a previous cell
-     */
-    getOutput(cellId: string): unknown;
-}
-/**
- * Create an executor for a workbook
- */
-declare function createExecutor(workbook: Workbook): WorkbookExecutor;
-
-/**
- * Human-readable rendering of cell results for terminal output.
- *
- * `formatResult` is called inside the executor's continue-on-error loop, so it
- * MUST NOT throw — circular references, BigInt, and unserializable values all
- * fall back to safe markers rather than crashing the run.
- */
-declare function formatResult(value: unknown): string;
-
-/**
- * Pure, immutable cell-mutation operations on a Workbook.
- *
- * Every op returns a NEW workbook (the input is never mutated) and enforces the
- * runnable-valid invariants — unique + identifier-safe ids, supported cell
- * types, existing `depends_on` references, no self-dependency, and no dependency
- * cycle. An op that would break an invariant throws; callers must not write the
- * file on a throw.
- */
-
-interface CellPosition {
-    before?: string;
-    after?: string;
-    at?: number;
-}
-interface RemoveResult {
-    workbook: Workbook;
-    /** Cells whose `depends_on` was edited to detach the removed cell (force). */
-    changedCells: string[];
-}
-declare function addCell(wb: Workbook, spec: {
-    id: string;
-    type: CellType;
-    content?: string;
-    dependsOn?: string[];
-}, position?: CellPosition): Workbook;
-declare function editCell(wb: Workbook, id: string, changes: {
-    content?: string;
-    type?: CellType;
-    dependsOn?: string[];
-}): Workbook;
-declare function removeCell(wb: Workbook, id: string, options?: {
-    force?: boolean;
-}): RemoveResult;
-declare function moveCell(wb: Workbook, id: string, position: CellPosition): Workbook;
-declare function renameCell(wb: Workbook, oldId: string, newId: string): Workbook;
-/** Update workbook-level metadata fields (only the provided ones). */
-declare function setMetadata(wb: Workbook, changes: {
-    title?: string;
-    author?: string;
-    description?: string;
-    tags?: string[];
-}): Workbook;
-
-/**
- * Machine-contract constants shared by the CLI and the public API.
- *
- * `SCHEMA_VERSION` is the version of the `--json` envelope shape. Clients
- * negotiate with the rule: ignore unknown fields when `major` matches; refuse
- * on a `major` mismatch. Additive fields bump `minor`; breaking changes bump
- * `major`.
- */
-declare const SCHEMA_VERSION: {
-    readonly major: 1;
-    readonly minor: 0;
-};
-declare const VERSION: string;
-
-/**
- * In-memory editing/execution session for a single workbook — the stateful
- * core behind `mtsw serve`. Holds the workbook, a per-cell result cache, and a
- * stale set so a `run` only re-executes what an edit invalidated.
- *
- * File I/O is limited to `open`/`save`; everything else is in-memory. Edits are
- * not persisted until `save`.
- */
-
-declare class Session {
-    workbook: Workbook | null;
-    path: string | null;
-    dirty: boolean;
-    private cache;
-    private stale;
-    private require;
-    /** A cell has a usable, up-to-date result (the basis for "not stale"). */
-    private hasValidResult;
-    /** Load a workbook file into the session. Refuses to discard unsaved edits. */
-    open(path: string, options?: {
-        force?: boolean;
-    }): void;
-    /** Replace the workbook and recompute the stale set by diffing old vs new. */
-    private commit;
-    addCell(spec: {
-        id: string;
-        type: CellType;
-        content?: string;
-        dependsOn?: string[];
-    }, position?: CellPosition): void;
-    editCell(id: string, changes: {
-        content?: string;
-        type?: CellType;
-        dependsOn?: string[];
-    }): void;
-    removeCell(id: string, options?: {
-        force?: boolean;
-    }): string[];
-    moveCell(id: string, position: CellPosition): void;
-    renameCell(oldId: string, newId: string): void;
-    setMetadata(changes: {
-        title?: string;
-        author?: string;
-        description?: string;
-        tags?: string[];
-    }): void;
-    /**
-     * Incremental run: execute only stale cells in the target set (`only` + its
-     * ancestors, or the whole workbook), reusing cached outputs for the rest.
-     * Returns the merged report over the target plus the streamed events.
-     */
-    run(only?: string): Promise<{
-        result: RunResult;
-        events: WorkbookEventLite[];
-    }>;
-    /** The set of cells awaiting (re-)execution. */
-    staleIds(): string[];
-    /** Serialize the current workbook and write it atomically. */
-    save(path?: string): string;
-}
-/** Slimmed event for streaming (avoids leaking timestamps / handler internals). */
-interface WorkbookEventLite {
-    type: string;
-    cellId?: string;
-    error?: string;
-}
-
-/**
- * Pure JSON-RPC 2.0 router for `mtsw serve`. `handleRequest(session, request)`
- * maps a request to a Session call and returns the response plus any streamed
- * `cell/event` notifications — no stdio, so the protocol logic is unit-testable.
- */
-
-interface JsonRpcRequest {
-    jsonrpc?: string;
-    id?: string | number | null;
-    method?: string;
-    params?: Record<string, unknown>;
-}
-interface JsonRpcResponse {
-    jsonrpc: '2.0';
-    id: string | number | null;
-    result?: unknown;
-    error?: {
-        code: number;
-        message: string;
-    };
-}
-interface JsonRpcEvent {
-    jsonrpc: '2.0';
-    method: 'cell/event';
-    params: {
-        type: string;
-        cellId?: string;
-        error?: string;
-    };
-}
-interface HandleResult {
-    response: JsonRpcResponse;
-    events: JsonRpcEvent[];
-    shutdown: boolean;
-}
-declare function handleRequest(session: Session, request: JsonRpcRequest): Promise<HandleResult>;
-
-/**
- * MathML → SVG typesetting. Wraps a MathML fragment in an SVG document so
- * rendered workbooks can emit SVG (browsers, rsvg, inkscape) instead of raw
- * MathML. The glyph metrics are a conservative estimate — consumers that need
- * pixel-perfect layout should typeset with a real engine; this is the
- * no-dependency path the CLI/export uses.
- */
-interface MathSvgOptions {
-    /** Display (`block`) or inline. Default `block`. */
-    display?: 'block' | 'inline';
-    /** Extra padding in CSS pixels. Default 4. */
-    padding?: number;
-}
-/**
- * Wrap a MathML fragment (or a full `<math>` document) in an SVG with a
- * `foreignObject` so the math remains selectable and scalable.
- */
-declare function mathMLToSVG(mathml: string, options?: MathSvgOptions): string;
-
-/**
- * Shared message/result shapes between `timeout-runner.ts` (the coordinator,
- * running on the caller's thread) and `run-worker.ts` (the `worker_threads`
- * entry point that actually executes the workbook). Kept in its own module so
- * neither side needs to import the other's runtime code — the worker script
- * stays a minimal, independently loadable entry point.
- *
- * Cell outputs are pre-formatted to strings (via `formatResult`) before they
- * cross the worker boundary: `postMessage` uses the structured-clone
- * algorithm, which cannot faithfully reproduce engine class instances
- * (Complex, matrices, BigNumber, …) — it either drops their prototype or
- * throws. Formatting to a string in the worker (the same rendering every
- * other report consumer already uses) sidesteps that entirely.
- */
-
-/** A `CellResult` with its output pre-formatted to a string (or absent). */
-interface SerializedCellResult {
-    id: string;
-    type: CellResult['type'];
-    status: CellResult['status'];
-    output?: string;
-    error?: string;
-}
-/** A `RunResult` whose cells are `SerializedCellResult`s. */
-interface SerializedRunResult {
-    cells: SerializedCellResult[];
-    ok: boolean;
-}
-
-interface RunWorkbookWithTimeoutOptions {
-    /** Wall-clock budget in milliseconds. Exceeding it terminates the worker. */
-    timeoutMs: number;
-}
-/** Thrown when a workbook run is terminated for exceeding its time budget. */
-declare class WorkbookTimeoutError extends Error {
-    readonly timeoutMs: number;
-    constructor(timeoutMs: number);
-}
-/**
- * Run a workbook's `.mtsw` source to completion (a continue-on-error report,
- * like `runReport()`) inside a worker thread, killing that worker if it
- * exceeds `timeoutMs`. The worker is ALWAYS terminated before this promise
- * settles — on timeout, on success, and on error — so no handle is left open
- * keeping the process alive.
- *
- * @throws {WorkbookTimeoutError} if the run is terminated for exceeding the budget.
- */
-declare function runWorkbookWithTimeout(source: string, options: RunWorkbookWithTimeoutOptions): Promise<SerializedRunResult>;
-
-export { type Cell, type CellPosition, type CellResult, type CellType, type ExecutionMode, type MathSvgOptions, type ParseResult, type RemoveResult, type RunResult, type RunWorkbookWithTimeoutOptions, type RuntimeConfig, SCHEMA_VERSION, type SerializedCellResult, type SerializedRunResult, Session, VERSION, type Workbook, type WorkbookEvent, WorkbookExecutor, type WorkbookMetadata, WorkbookTimeoutError, addCell, buildDependencyGraph, createExecutor, detectCellType, detectCycles, editCell, formatResult, getAncestors, getDependents, handleRequest, mathMLToSVG, moveCell, parseWorkbook, removeCell, renameCell, runWorkbookWithTimeout, serializeWorkbook, setMetadata, stripOutputs, toMermaid, topologicalSort };
+ * @danielsimonjr/mathts-workbook - Scientific workbook runtime
+ * @packageDocumentation
+ */
+export type { Workbook, Cell, CellType, ExecutionMode, WorkbookMetadata, RuntimeConfig, ParseResult, WorkbookEvent, CellResult, RunResult, } from './types';
+export { parseWorkbook, serializeWorkbook, stripOutputs, detectCellType } from './parser';
+export { buildDependencyGraph, topologicalSort, getDependents, detectCycles, getAncestors, toMermaid, } from './graph';
+export { WorkbookExecutor, createExecutor } from './executor';
+export { formatResult } from './formatter';
+export { addCell, editCell, removeCell, moveCell, renameCell, setMetadata } from './edit';
+export type { CellPosition, RemoveResult } from './edit';
+export { SCHEMA_VERSION, VERSION } from './contract';
+export { Session } from './session';
+export { handleRequest } from './rpc';
+export { mathMLToSVG } from './svg-math';
+export type { MathSvgOptions } from './svg-math';
+export { runWorkbookWithTimeout, WorkbookTimeoutError } from './timeout-runner';
+export type { RunWorkbookWithTimeoutOptions, SerializedCellResult, SerializedRunResult, } from './timeout-runner';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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,SAAS,CAAC;AAGjB,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAG1F,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG9D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1F,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAChF,YAAY,EACV,6BAA6B,EAC7B,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   renameCell,
   runWorkbookWithTimeout,
   setMetadata
-} from "./chunk-ZVCYWKM5.js";
+} from "./chunk-JM3ZAYJC.js";
 import {
   WorkbookExecutor,
   buildDependencyGraph,

package/dist/introspect.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Engine introspection shared by the CLI (`capabilities`, `functions`) and the
+ * serve JSON-RPC router. Imports only constants + the math package, so both the
+ * CLI and the RPC layer can use it without an import cycle.
+ */
+import { SCHEMA_VERSION } from './contract';
+/**
+ * Names a code cell can call/use, from the exported surface of
+ * `@danielsimonjr/mathts-functions`. Names only (no signatures); computed once.
+ * Best-effort — the exported surface, not the engine's full internal symbol table.
+ */
+export declare function listFunctions(): {
+    functions: string[];
+    constants: string[];
+};
+/** Capabilities payload — version, cell types, command list, feature flags. */
+export declare function capabilitiesInfo(): {
+    name: string;
+    version: string;
+    schemaVersion: typeof SCHEMA_VERSION;
+    cellTypes: {
+        supported: string[];
+        deferred: string[];
+    };
+    cellSchemas: Record<string, string>;
+    commands: string[];
+    features: Record<string, boolean>;
+};
+//# sourceMappingURL=introspect.d.ts.map

package/dist/introspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../src/introspect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAW,cAAc,EAAiB,MAAM,YAAY,CAAC;AAKpE;;;;GAIG;AACH,wBAAgB,aAAa,IAAI;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAU5E;AAcD,+EAA+E;AAC/E,wBAAgB,gBAAgB,IAAI;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,OAAO,cAAc,CAAC;IACrC,SAAS,EAAE;QAAE,SAAS,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACvD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAuBA"}

package/dist/ipynb.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Assemble a generic RenderDoc into a Jupyter notebook (nbformat v4) JSON
+ * string — the ipynb analog of html.ts's toHTML / tex.ts's toTeX. Operates on
+ * the same plain `RenderDoc`/`RenderCell` model built by the CLI's
+ * `buildRenderDoc`, so it shares the exact same cell/result mapping as the
+ * other exporters instead of re-deriving it from the `Workbook` type.
+ *
+ * Cell mapping:
+ *  - `markdown` -> an nbformat markdown cell (raw content as source).
+ *  - everything else (`equation`, `code`, `test`, `data`, `chart`) -> an
+ *    nbformat code cell. A computed result becomes an `execute_result`
+ *    output; an error becomes an `error` output; a rendered chart becomes a
+ *    `display_data` output (inline SVG); a `test` cell's pass/fail becomes an
+ *    `execute_result` of `"true"`/`"false"`. A cell with none of these (e.g.
+ *    an unevaluated `equation`, or `--no-run`) gets an empty `outputs` array
+ *    and `execution_count: null`, which is valid nbformat v4.
+ *
+ * `source` fields follow the nbformat convention: an array of lines, each
+ * (except possibly the last) retaining its trailing `\n`.
+ */
+import type { RenderDoc } from './html.js';
+/** Render a document structure to a Jupyter notebook (nbformat v4) JSON string. */
+export declare function toIpynb(doc: RenderDoc): string;
+//# sourceMappingURL=ipynb.d.ts.map

package/dist/ipynb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipynb.d.ts","sourceRoot":"","sources":["../src/ipynb.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAc,MAAM,WAAW,CAAC;AAoHvD,mFAAmF;AACnF,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,CAqB9C"}

package/dist/markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal, dependency-free Markdown → HTML for rendered documents. A small
+ * subset (headings, paragraphs, bold/italic/code, fenced code, lists, links,
+ * hr) — NOT CommonMark-complete. XSS-safe: text is HTML-escaped first, then
+ * inline markers are applied to the escaped text, and link hrefs pass a strict
+ * protocol allowlist (not a denylist).
+ */
+export declare function markdownToHtml(src: string): string;
+/** Escape LaTeX specials in a single pass (an escape's own backslash/braces are never re-scanned). */
+export declare function texEscape(s: string): string;
+/** Minimal Markdown → LaTeX, same subset + safety discipline as markdownToHtml. */
+export declare function markdownToTex(src: string): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA2EH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA+DlD;AAED,sGAAsG;AACtG,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAa3C;AA+BD,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6DjD"}

package/dist/parser.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Workbook YAML parser
+ */
+import type { Workbook, ParseResult, CellType } from './types';
+/**
+ * Canonical cell-type keys, in detection-precedence order. Shared between the
+ * `detectCellType` helper and the parser's exactly-one-type-key rule.
+ */
+declare const CELL_TYPE_KEYS: CellType[];
+/** Whether a string is a valid cell id (a MathTS identifier). */
+export declare function isValidIdentifier(id: string): boolean;
+/** Cell types the runtime can execute today (the rest are reserved/deferred). */
+export declare const SUPPORTED_CELL_TYPES: CellType[];
+/**
+ * Detect cell type from YAML keys (first match by precedence).
+ */
+declare function detectCellType(cell: Record<string, unknown>): CellType;
+/**
+ * Parse a workbook from YAML content.
+ */
+export declare function parseWorkbook(content: string): ParseResult;
+/**
+ * Serialize a workbook to YAML that round-trips through {@link parseWorkbook}.
+ *
+ * Structural fidelity (version/metadata/runtime/cells: id/type/content/dependsOn/
+ * metadata) is exact. Persisted `output` values are best-effort: plain
+ * primitives/arrays/objects round-trip exactly (the YAML serializer quotes
+ * scalars that would otherwise re-type); exotic class instances serialize to
+ * their plain shape. Throws only on a structurally invalid workbook.
+ */
+export declare function serializeWorkbook(workbook: Workbook): string;
+/**
+ * Strip outputs from workbook (for git)
+ */
+export declare function stripOutputs(workbook: Workbook): Workbook;
+export { detectCellType, CELL_TYPE_KEYS };
+/**
+ * Build a validated Workbook from a structured document (JSON or YAML — YAML is
+ * a JSON superset, so both parse). Accepts the friendly, `describe`-style shape
+ * `{ metadata?, runtime?, version?, cells: [{ id, type, content, dependsOn? }] }`
+ * (the inverse of `describe --json`), normalizes each cell to the `.mtsw` shape,
+ * then round-trips through serialize + parse so all the usual validation
+ * (identifier ids, uniqueness, supported types, existing deps, no cycle,
+ * prototype-pollution) is reused. Returns a ParseResult.
+ */
+export declare function importWorkbook(input: string): ParseResult;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,QAAQ,EAIT,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,QAAA,MAAM,cAAc,EAAE,QAAQ,EAS7B,CAAC;AAQF,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,EAO1C,CAAC;AAIF;;GAEG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAQ/D;AA8FD;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAqE1D;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAmB5D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CASzD;AAED,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC;AAE1C;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAkEzD"}

package/dist/pdf.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Render a workbook RenderDoc to a PDF file. Reuses plot's latexToPdf primitive:
+ * toTeX(standalone) → LaTeX → PDF. Charts render as native vector TikZ (no
+ * rasterization). Async; throws PlotRenderError if no LaTeX engine is available.
+ */
+import { type RenderOptions } from '@danielsimonjr/mathts-plot/render';
+import type { RenderDoc } from './html.js';
+export interface ToPdfOptions extends RenderOptions {
+    parse?: (expr: string) => unknown;
+}
+export declare function toPDF(doc: RenderDoc, outPath: string, options?: ToPdfOptions): Promise<void>;
+//# sourceMappingURL=pdf.d.ts.map

package/dist/pdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf.d.ts","sourceRoot":"","sources":["../src/pdf.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEnF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACnC;AAED,wBAAgB,KAAK,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhG"}