@lofcz/tikz 0.0.0-stage → 0.2.0

package/runtime/dist/texutils.js

@@ -0,0 +1,60 @@
+/**
+ * BibTeX's transcript. A warning is `Warning--...`, sometimes followed by
+ * `--line N of file F`; an error names its place after three dashes, on its own
+ * line or the next one (`I couldn't open database file x.bib` / `---line 6 of file doc.aux`,
+ * `Repeated entry---line 1 of file refs.bib`, `I found no style file---while reading file doc.aux`).
+ */
+export function parseBibtexLog(blg) {
+    const out = [];
+    const lines = blg.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const l = lines[i];
+        const w = /^Warning--(.*)$/.exec(l);
+        if (w) {
+            const d = { severity: 'warning', source: 'bibtex', message: w[1] };
+            const at = /^--line (\d+) of file (.+)$/.exec(lines[i + 1] ?? '');
+            if (at) {
+                d.line = Number(at[1]);
+                d.file = at[2];
+                i++;
+            }
+            out.push(d);
+            continue;
+        }
+        const e = /^(.*?)---(?:line (\d+) of file (.+)|while reading file (.+)|entry "([^"]*)")$/.exec(l);
+        if (!e)
+            continue;
+        let message = e[1] || (lines[i - 1] ?? '');
+        if (e[5] !== undefined)
+            message = `${message} (entry "${e[5]}")${lines[i + 1] ? ` ${lines[++i]}` : ''}`; // a bad cross reference: the reason is on the next line
+        const d = { severity: 'error', source: 'bibtex', message };
+        if (e[2]) {
+            d.line = Number(e[2]);
+            d.file = e[3];
+        }
+        else if (e[4])
+            d.file = e[4];
+        out.push(d);
+    }
+    return out;
+}
+/**
+ * makeindex's transcript: `!! Input index error (file = doc.idx, line = 40):` or
+ * `## Warning (input = doc.idx, line = 39; output = doc.ind, line = 54):`, each
+ * followed by `   -- message`; `!! Input style error` likewise for the .ist.
+ */
+export function parseMakeindexLog(ilg) {
+    const out = [];
+    const lines = ilg.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const m = /^(!!|##) (.*?) \((?:file|input) = ([^,;]+), line = (\d+)[;)]/.exec(lines[i]);
+        if (!m)
+            continue;
+        const text = /^\s*-- (.*)$/.exec(lines[i + 1] ?? '');
+        if (text)
+            i++;
+        out.push({ severity: m[1] === '!!' ? 'error' : 'warning', source: 'makeindex', message: text ? text[1] : m[2], file: m[3], line: Number(m[4]) });
+    }
+    return out;
+}
+//# sourceMappingURL=texutils.js.map

package/runtime/dist/types.d.ts

@@ -0,0 +1,376 @@
+/**
+ * mp-tikz-wasm — public types. Mirrors reference/api.d.ts (the M7 contract);
+ * see docs/08-javascript-api.md for the rationale behind each choice.
+ */
+export type BundleName = 'core' | 'cm-tfm' | 'cm-type1' | 'tex-plain' | 'latex-core' | 'latex-extra' | 'opentype' | 'otf-fonts' | 'classico' | 'ghostscript' | 'latex-doc' | (string & {});
+export interface BundleSpec {
+    name: string;
+    /** URL (browser) or directory (Node) of the bundle's manifest.json. */
+    manifestUrl: string;
+    blobBaseUrl?: string;
+}
+export type NumberSystem = 'scaled' | 'double' | 'decimal' | 'binary' | 'interval';
+export type TexEngine = 'none' | 'plain' | 'etex' | 'latex' | 'auto';
+export type MpFileType = 'terminal' | 'error' | 'program' | 'log' | 'postscript' | 'bitmap' | 'memfile' | 'metrics' | 'fontmap' | 'font' | 'encoding' | 'text';
+export type PrefetchKind = 'metapost' | 'latex' | 'lualatex' | 'plain';
+/** How much a run writes to the console; each level includes the ones before it. */
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
+/** Who produced a log record: an engine's own output, the bundle loader, or the library itself. */
+export type LogSource = 'metapost' | 'tex' | 'dvisvgm' | 'bibtex' | 'makeindex' | 'bundle' | 'host';
+export interface LogRecord {
+    level: Exclude<LogLevel, 'silent'>;
+    source: LogSource;
+    message: string;
+    /** Milliseconds since the engine was created. */
+    time: number;
+}
+export interface MetaPostOptions {
+    /** Bundles to load. Default: ['core', 'cm-tfm', 'cm-type1', 'tex-plain', 'latex-core'] when a bundleBaseUrl is known. */
+    bundles?: (BundleName | BundleSpec)[];
+    /** Base URL (browser) or directory (Node) under which `<bundle>/manifest.json` lives. */
+    bundleBaseUrl?: string;
+    /** Node only: a texmf directory to mount directly (mirrors build/texmf). Overrides bundles. */
+    texmfDir?: string;
+    numberSystem?: NumberSystem;
+    tex?: TexEngine;
+    texPreamble?: string;
+    deterministic?: boolean;
+    randomSeed?: number;
+    interaction?: 'batch' | 'nonstop' | 'scroll';
+    haltOnError?: boolean;
+    /** false selects the classic .mpx path instead of the make_text path. */
+    extensions?: boolean;
+    /** Append `end.` after `input <job>` so a file that forgets `end` still finishes cleanly (default true). */
+    autoEnd?: boolean;
+    memoryLimitBytes?: number;
+    /** A run is terminated when it makes no progress (no engine phase change, no file fetched) for this long.
+     *  Default 20 000 ms; worker only. It is a stall limit, not a total: a first run on a slow host may fetch
+     *  a hundred files one after another and is not cut short for it. */
+    timeoutMs?: number;
+    /** Fetch, in parallel, the bundle files a first run of these kinds needs, right after the engine starts
+     *  (from `bundles/hot.json`, recorded at build time). On a high-latency host this turns ~90 serial
+     *  round trips into a few seconds. The drop-in tags do it automatically for the kinds the page contains. */
+    prefetch?: PrefetchKind[];
+    texTimeoutMs?: number;
+    maxTexRuns?: number;
+    runScript?: (code: string) => string;
+    makeText?: (text: string, verbatim: boolean) => string | undefined;
+    onFindFile?: (name: string, type: MpFileType, mode: 'r' | 'w') => string | undefined;
+    cache?: 'memory' | false;
+    /** How much each run writes to the console (default 'warn'). 'silent': nothing. 'error': the errors of every run
+     *  (MetaPost, TeX, dvisvgm, bundles). 'warn': plus warnings. 'info': plus one line per run and per engine pass,
+     *  with timings. 'debug': plus the engines' own terminal output, line by line, as it is written. 'trace': plus
+     *  every file looked up or fetched and every label-cache lookup. `mp.logLevel = 'debug'` changes it at any time. */
+    logLevel?: LogLevel;
+    /** Receives every record the level admits, instead of the console (also the 'record' event). */
+    logger?: (record: LogRecord) => void;
+    /** Every line the engines print, whatever the level (also the 'log' event). */
+    log?: (line: string) => void;
+    wasmUrls?: {
+        mplib?: string;
+        tex?: string;
+    };
+    /**
+     * PostScript in LaTeX documents (PSTricks, EPS images, `\special{ps: …}`,
+     * graphicx's rotation and scaling under its dvips driver) through a separate
+     * Ghostscript module (AGPL), loaded only when a document's DVI carries such
+     * PostScript. On by default when the `ghostscript` bundle is in `bundles`;
+     * set it for `texmfDir`, which has no bundle list.
+     */
+    ghostscript?: boolean;
+    /** Where the Ghostscript module's gs.mjs and gs.wasm are; default `ghostscript/` beside index.js. */
+    ghostscriptBaseUrl?: string;
+    /** Pre-loaded Emscripten module factories (e.g. for a single-file build); in-process mode only. */
+    modules?: {
+        mplib?: (opts?: Record<string, unknown>) => Promise<any>;
+        tex?: (opts?: Record<string, unknown>) => Promise<any>;
+        luatex?: (opts?: Record<string, unknown>) => Promise<any>;
+        dvisvgm?: (opts?: Record<string, unknown>) => Promise<any>;
+        ghostscript?: (opts?: Record<string, unknown>) => Promise<any>;
+        bibtex?: (opts?: Record<string, unknown>) => Promise<any>;
+        makeindex?: (opts?: Record<string, unknown>) => Promise<any>;
+    };
+    /** Custom bundle I/O (e.g. files embedded in the page); in-process mode only. */
+    bundleIO?: {
+        fetch(url: string): Promise<Uint8Array>;
+        fetchSync?: (url: string) => Uint8Array;
+        fetchJson(url: string): Promise<unknown>;
+    };
+    /** Run in-process instead of in a Web Worker (default: worker in browsers, in-process in Node). */
+    worker?: boolean;
+    /** Default for latex()'s snapshot option. Node: 'auto' (tikz.fmt from local files is free). Browser: 'none',
+     *  because the 5.8 MB format does not compress and costs more to download than the files it replaces
+     *  (2.5 MB gzipped); set 'auto' when many TikZ figures amortise it or the format is already cached. */
+    snapshot?: 'auto' | 'none';
+}
+export type OutputFormat = 'svg' | 'eps' | 'json' | 'none';
+export interface RunOptions {
+    format?: OutputFormat | OutputFormat[];
+    prologues?: 0 | 1 | 2 | 3;
+    procset?: 0 | 1;
+    files?: Record<string, string | Uint8Array>;
+    jobName?: string;
+    internals?: Record<string, number | string>;
+    tex?: TexEngine;
+    svg?: SvgPostOptions;
+    signal?: AbortSignal;
+}
+export interface SvgPostOptions {
+    /** Round numbers to this many decimals (default 3). false = leave MetaPost's %.6f. */
+    precision?: number | false;
+    /** Prefix glyph ids so several figures can be inlined on one page (default: per figure). */
+    idPrefix?: string | false;
+    /** Rewrite xlink:href to href. Default false (keep upstream output). */
+    modernHref?: boolean;
+    /** Add role="img" and a <title>. */
+    title?: string;
+    /** Units for width/height: 'pt' keeps MetaPost's, 'px' converts at 96/72, 'none' drops them. */
+    units?: 'pt' | 'px' | 'none';
+}
+export type Status = 'ok' | 'warning' | 'error' | 'fatal';
+export interface RunResult {
+    status: Status;
+    history: 0 | 1 | 2 | 3 | 4;
+    figures: FigureResult[];
+    log: string;
+    texLog?: string;
+    diagnostics: Diagnostic[];
+    stats: RunStats;
+    artifacts: Record<string, Uint8Array>;
+}
+export interface FigureResult {
+    charcode: number;
+    bbox: [number, number, number, number];
+    width: number;
+    height: number;
+    depth: number;
+    italicCorrection: number;
+    svg?: string;
+    eps?: string;
+    json?: Figure;
+}
+export interface RunStats {
+    totalMs: number;
+    metapostMs: number;
+    texMs: number;
+    texRuns: number;
+    metapostRuns: number;
+    snippetCacheHits: number;
+    snippetCacheMisses: number;
+}
+export interface Diagnostic {
+    severity: 'error' | 'warning';
+    source: 'metapost' | 'tex' | 'bundle' | 'host' | 'bibtex' | 'makeindex';
+    message: string;
+    help?: string[];
+    file?: string;
+    line?: number;
+    column?: number;
+    snippet?: string;
+}
+export interface ProgressEvent {
+    /** `fetching`: a bundle file is being fetched on demand (Worker only); `detail` is its name. */
+    phase: 'loading' | 'fetching' | 'scanning' | 'typesetting' | 'running' | 'rendering';
+    detail?: string;
+    current?: number;
+    total?: number;
+}
+export interface Figure {
+    charcode: number;
+    bbox: [number, number, number, number];
+    width: number;
+    height: number;
+    depth: number;
+    italicCorrection: number;
+    objects: GraphicObject[];
+}
+export type GraphicObject = FillObject | StrokeObject | TextObject | ClipObject | BoundsObject | SpecialObject;
+export interface Knot {
+    x: number;
+    y: number;
+    lx: number;
+    ly: number;
+    rx: number;
+    ry: number;
+    leftType: KnotType;
+    rightType: KnotType;
+}
+export type KnotType = 0 | 1 | 2 | 3 | 4 | 5;
+export interface Color {
+    model: 'none' | 'grey' | 'rgb' | 'cmyk';
+    values: number[];
+}
+interface ObjectBase {
+    prescript?: string;
+    postscript?: string;
+}
+export interface FillObject extends ObjectBase {
+    type: 'fill';
+    path: Knot[];
+    closed: boolean;
+    htap?: Knot[];
+    pen?: Knot[];
+    color: Color;
+    ljoin: number;
+    miterlimit: number;
+}
+export interface StrokeObject extends ObjectBase {
+    type: 'stroke';
+    path: Knot[];
+    closed: boolean;
+    pen?: Knot[];
+    color: Color;
+    ljoin: number;
+    lcap: number;
+    miterlimit: number;
+    dash?: {
+        offset: number;
+        pattern: number[];
+    };
+}
+export interface TextObject extends ObjectBase {
+    type: 'text';
+    text: string;
+    font: string;
+    designSize: number;
+    color: Color;
+    width: number;
+    height: number;
+    depth: number;
+    transform: [number, number, number, number, number, number];
+}
+export interface ClipObject {
+    type: 'startClip' | 'stopClip';
+    path?: Knot[];
+}
+export interface BoundsObject {
+    type: 'startBounds' | 'stopBounds';
+    path?: Knot[];
+}
+export interface SpecialObject extends ObjectBase {
+    type: 'special';
+    script: string;
+}
+export interface LatexRunOptions {
+    /** Which engine and format run the document. Default 'latex' (pdfTeX in DVI mode). 'plain' is
+     *  plain TeX with e-TeX extensions (TeX Live's etex; PGF needs them); 'tex' is Knuth-compatible
+     *  plain.fmt. 'lualatex' and 'luatex' run LuaTeX in DVI mode (TeX Live's dvilualatex/dviluatex),
+     *  which is what TikZ's graphdrawing library and \directlua need; text is set in the Type 1
+     *  fonts unless the `opentype` bundle is loaded, which adds luaotfload and so \usepackage{fontspec}
+     *  with real OTF/TTF faces. 'auto' picks 'lualatex' when the source uses
+     *  graphdrawing, \directlua or luacode, 'plain' for a \bye document, 'latex' otherwise. */
+    engine?: 'latex' | 'plain' | 'etex' | 'tex' | 'lualatex' | 'luatex' | 'auto';
+    /** What the run produces: 'svg' (default; DVI, then one SVG per page through dvisvgm) or 'pdf'
+     *  (pdfTeX's or LuaTeX's own PDF back end: `pdf` in the result holds the document, `pages` is
+     *  empty, and the SVG options -- fonts, bbox, dvisvgmArgs, svg, pages -- do not apply). */
+    output?: 'svg' | 'pdf';
+    /** PGF system driver. 'dvisvgm' (default) prepends \def\pgfsysdriver{pgfsys-dvisvgm.def} so TikZ
+     *  draws with SVG specials -- with output 'pdf', the driver that matches it instead
+     *  (pgfsys-pdftex.def or pgfsys-luatex.def); 'auto' leaves PGF's own choice (in DVI mode dvips,
+     *  whose PostScript specials need Ghostscript and are ignored here). */
+    pgfDriver?: 'dvisvgm' | 'auto';
+    /** The pre-warmed format: 'auto' (default) runs documents that load tikz, pgfplots or tikz-cd with
+     *  tikz.fmt (LaTeX with PGF, its common libraries and pgfplots already loaded);
+     *  'tikz' forces it, 'none' always uses plain latex.fmt. Requires the tikz-snapshot bundle.
+     *  Never used with output 'pdf': the snapshot has PGF's dvisvgm driver built in. */
+    snapshot?: 'auto' | 'tikz' | 'none';
+    /** The date and time TeX sees: \today, \time, babel's dates, the PDF's CreationDate and ModDate.
+     *  'fixed' (default): 1 January 2025, 00:00 UTC, so the same source always gives the same bytes
+     *  (what figures and tests want). 'now': the clock, in the local time zone, as a desktop TeX
+     *  run (what a person exporting a document wants). A Date, or milliseconds since 1970 as
+     *  Date.now() gives: that instant, \today included, in UTC. */
+    date?: 'fixed' | 'now' | Date | number;
+    /** Files to place next to the document (images, .sty, .tex inputs, the previous pass's .aux).
+     *  They stay on the instance for later runs, as addFiles' do, until removeFiles takes them off. */
+    files?: Record<string, string | Uint8Array>;
+    jobName?: string;
+    /** Which DVI pages to convert: 'all' or a 1-based page number. Default 'all'. */
+    pages?: 'all' | number;
+    /** How text is emitted: 'paths' (glyph outlines, self-contained; default) or 'woff2' (embedded web fonts). */
+    fonts?: 'paths' | 'woff2';
+    /** Bounding box for each page: dvisvgm's --bbox value ('min' default, 'preview', 'papersize', 'dvi', or explicit). */
+    bbox?: string;
+    /** Extra dvisvgm command-line arguments, appended verbatim. */
+    dvisvgmArgs?: string[];
+    svg?: SvgPostOptions;
+    signal?: AbortSignal;
+}
+export interface LatexResult {
+    status: Status;
+    /** One SVG per DVI page (empty with output 'pdf'). */
+    pages: string[];
+    /** The PDF, with output 'pdf' (absent when TeX wrote none). */
+    pdf?: Uint8Array;
+    log: string;
+    texLog: string;
+    dvisvgmLog: string;
+    diagnostics: Diagnostic[];
+    stats: {
+        totalMs: number;
+        texMs: number;
+        dvisvgmMs: number;
+        texSetupMs: number;
+        texMainMs: number;
+        instantiateMs: number;
+    };
+    /** The format that ran the document ('latex', 'tikz', 'etex', 'plain', 'dvilualatex', 'dviluatex'). */
+    format: string;
+    /** The files TeX wrote beside the document (.aux, .toc, .out, .idx, ...), apart from the
+     *  output and the .log. A file passed in `files` is among them when TeX wrote it again, so one
+     *  pass's artifacts are the next pass's `files`, however many passes there are. */
+    artifacts: Record<string, Uint8Array>;
+}
+export interface BibtexOptions {
+    /** The .aux file's name without .aux, as `bibtex doc` takes it. Default 'doc', latex()'s default jobName. */
+    jobName?: string;
+    /** Files to place beside it: the .aux (latex()'s artifacts), the .bib databases, a .bst of the
+     *  document's own. They stay on the instance, as latex()'s `files` do, until removeFiles. The
+     *  styles TeX Live ships (plainnat, apalike, plain, unsrt, ...) come from the `latex-doc` bundle. */
+    files?: Record<string, string | Uint8Array>;
+    /** More command-line options, before the name: ['-min-crossrefs=3']. */
+    args?: string[];
+}
+export interface MakeindexOptions {
+    /** The index file to sort, as `makeindex doc.idx` takes it. Default 'doc.idx'; imakeidx's
+     *  \makeindex[name=authors] writes authors.idx. */
+    input?: string;
+    /** An index style (makeindex -s): a file passed in `files`, or one from the `latex-doc` bundle. */
+    style?: string;
+    /** Files to place beside it (the .idx: latex()'s artifacts); they stay on the instance, as latex()'s do. */
+    files?: Record<string, string | Uint8Array>;
+    /** More command-line options, before the input: ['-l'], ['-g'], ['-o', 'other.ind']. */
+    args?: string[];
+}
+export interface ToolResult {
+    /** 'ok'; 'warning' when the .blg or .ilg has warnings (or makeindex rejected entries), though
+     *  the program exited 0; 'error' when it stopped or reported errors (BibTeX exit 1 or 2,
+     *  makeindex exit 1); 'fatal' after one of BibTeX's fatal errors (exit 3). */
+    status: Status;
+    exitCode: number;
+    /** What the program printed. */
+    log: string;
+    /** The files it wrote: BibTeX doc.bbl and doc.blg, makeindex doc.ind and doc.ilg (or what -o and -t name).
+     *  Pass them to the next latex() run with the previous run's artifacts. */
+    artifacts: Record<string, Uint8Array>;
+    /** The .blg's or .ilg's warnings and errors, with the file and line they name. */
+    diagnostics: Diagnostic[];
+    stats: {
+        totalMs: number;
+    };
+}
+/** The bundle manifest format (docs/06 §3). Paths are relative to the texmf root. */
+export interface BundleManifest {
+    name: string;
+    version: string;
+    texlive?: string;
+    /** relative path -> size in bytes (and optional sha256) */
+    files: Record<string, {
+        size: number;
+        sha?: string;
+    }>;
+    /** files fetched together with the manifest */
+    eager?: string[];
+    /** directories that exist even if empty */
+    dirs?: string[];
+}
+export {};

package/runtime/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * mp-tikz-wasm — public types. Mirrors reference/api.d.ts (the M7 contract);
+ * see docs/08-javascript-api.md for the rationale behind each choice.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/runtime/dist/vfs/bundle.d.ts

@@ -0,0 +1,88 @@
+/**
+ * bundle.ts — texmf bundles: manifest + files (docs/06 §3–§4).
+ *
+ * A bundle is a directory (or URL prefix) holding `manifest.json` and the
+ * files themselves under `files/<relative path>`. The BundleSet merges any
+ * number of bundles into one virtual texmf tree rooted at /texmf.
+ *
+ * Loading strategies:
+ *   - Node:   files are read with fs.readFileSync on demand (always sync).
+ *   - Worker: files are fetched with a synchronous XMLHttpRequest on demand.
+ *   - Main thread: no sync I/O; everything reachable is prefetched with
+ *     fetch() by `prefetchAll()` before the engine runs.
+ */
+import type { BundleManifest, BundleSpec } from '../types.js';
+import { type EmscriptenFS } from './lazyfs.js';
+import { Logger } from '../logger.js';
+export interface BundleFile {
+    bundle: string;
+    path: string;
+    size: number;
+    sha?: string;
+    url: string;
+}
+export interface BundleIO {
+    /** async fetch of bytes */
+    fetch(url: string): Promise<Uint8Array>;
+    /** sync fetch of bytes, or undefined if this environment cannot do sync I/O */
+    fetchSync?: (url: string) => Uint8Array;
+    /** fetch + parse JSON */
+    fetchJson(url: string): Promise<unknown>;
+}
+export declare const TEXMF_ROOT = "/texmf";
+export declare class BundleSet {
+    private io;
+    readonly files: Map<string, BundleFile>;
+    readonly byName: Map<string, BundleFile[]>;
+    readonly manifests: {
+        spec: BundleSpec;
+        manifest: BundleManifest;
+        base: string;
+    }[];
+    private cache;
+    private negative;
+    /** The files a first run of each kind touches (`bundles/hot.json`, written by scripts/make-hotlists.mjs). */
+    hot: Record<string, string[]>;
+    /** Where fetches are reported: prefetch summaries at info, on-demand loads at debug, every file at trace. */
+    logger: Logger;
+    constructor(io: BundleIO);
+    /** Load a manifest; `spec.manifestUrl` is the bundle directory/URL (containing manifest.json). */
+    add(spec: BundleSpec): Promise<void>;
+    private addLoaded;
+    /** Add several bundles: the manifests are fetched in parallel, then merged in the given order (first bundle wins). */
+    addAll(specs: BundleSpec[]): Promise<void>;
+    /** Load the hot lists; optional, so a missing file is not an error. */
+    loadHot(url: string): Promise<void>;
+    /** Fetch, in parallel, every file the hot lists name for these kinds that is not in memory yet. Returns how many. */
+    prefetchHot(kinds: string[], concurrency?: number): Promise<number>;
+    /** Every manifest's `eager` list, fetched into memory. */
+    prefetchEager(): Promise<void>;
+    /** Fetch every file in the set (for environments without sync I/O). */
+    prefetchAll(filter?: (f: BundleFile) => boolean): Promise<void>;
+    fetchAsync(f: BundleFile): Promise<Uint8Array>;
+    /** Synchronous bytes for a file: from memory, else via fetchSync. Throws if impossible. */
+    fetchSyncFile(f: BundleFile): Uint8Array;
+    get canFetchSync(): boolean;
+    has(path: string): boolean;
+    /**
+     * Materialise the tree in the Emscripten FS under /texmf, plus an ls-R
+     * database so kpathsea never has to walk directories. Directories are
+     * created on demand: the root gets a lookup hook that creates a child
+     * directory or a lazy file the first time anything asks for it, so a run
+     * pays for the handful of files it touches, not for the whole tree
+     * (installing every node eagerly cost ~60 ms per TeX run).
+     */
+    install(FS: EmscriptenFS, root?: string): void;
+    private lsRText?;
+    private indexCache?;
+    /** directory -> immediate children, for the on-demand tree */
+    private index;
+    /** kpathsea ls-R database text for the merged tree. */
+    lsR(): string;
+    /** Find bundle files by bare name (e.g. "cmr10.tfm"), optionally restricted to a directory prefix. */
+    lookup(name: string, prefixes?: string[]): BundleFile | undefined;
+    noteMiss(key: string): void;
+    isMiss(key: string): boolean;
+}
+/** Browser I/O: fetch() plus a synchronous XHR that only works inside a Worker. */
+export declare function browserIO(): BundleIO;