@lofcz/tikz 0.0.0-stage → 0.2.0

package/runtime/dist/vfs/bundle.js

@@ -0,0 +1,315 @@
+import { createLazyFile, mkdirp } from './lazyfs.js';
+import { silentLogger, plural } from '../logger.js';
+export const TEXMF_ROOT = '/texmf';
+const inWorker = typeof globalThis.WorkerGlobalScope !== 'undefined' && typeof globalThis.importScripts === 'function';
+/** Inside a Worker, post a `fetching` progress event; the main thread's stall watchdog and status text listen for them. */
+function fetchingEvent(name, current, total) {
+    if (!inWorker)
+        return;
+    try {
+        globalThis.postMessage({ event: 'progress', data: { phase: 'fetching', detail: name, current, total } });
+    }
+    catch { /* ignore */ }
+}
+function joinUrl(base, rel) {
+    if (!base.endsWith('/'))
+        base += '/';
+    return base + rel;
+}
+export class BundleSet {
+    io;
+    files = new Map(); // relative texmf path -> file
+    byName = new Map(); // basename -> files
+    manifests = [];
+    cache = new Map(); // in-memory copy of fetched files
+    negative = new Set();
+    /** The files a first run of each kind touches (`bundles/hot.json`, written by scripts/make-hotlists.mjs). */
+    hot = {};
+    /** Where fetches are reported: prefetch summaries at info, on-demand loads at debug, every file at trace. */
+    logger = silentLogger;
+    constructor(io) {
+        this.io = io;
+    }
+    /** Load a manifest; `spec.manifestUrl` is the bundle directory/URL (containing manifest.json). */
+    async add(spec) {
+        const base = spec.manifestUrl.replace(/\/manifest\.json$/, '');
+        const manifest = (await this.io.fetchJson(joinUrl(base, 'manifest.json')));
+        this.addLoaded(spec, base, manifest);
+    }
+    addLoaded(spec, base, manifest) {
+        this.manifests.push({ spec, manifest, base });
+        const blobBase = spec.blobBaseUrl ?? joinUrl(base, 'files');
+        for (const [path, info] of Object.entries(manifest.files)) {
+            if (this.files.has(path))
+                continue; // first bundle wins
+            // The file's hash in its URL: a rebuilt file gets a new URL, so an HTTP cache can
+            // never hand back a stale copy (a server that sends no Cache-Control lets the
+            // browser reuse files heuristically; a new font with an old font map then drew
+            // nothing), and an unchanged one may be cached for good.
+            const url = joinUrl(blobBase, path) + (info.sha ? `?v=${info.sha}` : '');
+            const f = { bundle: manifest.name, path, size: info.size, sha: info.sha, url };
+            this.files.set(path, f);
+            const name = path.slice(path.lastIndexOf('/') + 1);
+            const list = this.byName.get(name);
+            if (list)
+                list.push(f);
+            else
+                this.byName.set(name, [f]);
+        }
+    }
+    /** Add several bundles: the manifests are fetched in parallel, then merged in the given order (first bundle wins). */
+    async addAll(specs) {
+        const manifests = await Promise.all(specs.map(async (spec) => {
+            const base = spec.manifestUrl.replace(/\/manifest\.json$/, '');
+            return { spec, base, manifest: (await this.io.fetchJson(joinUrl(base, 'manifest.json'))) };
+        }));
+        for (const m of manifests)
+            this.addLoaded(m.spec, m.base, m.manifest);
+    }
+    /** Load the hot lists; optional, so a missing file is not an error. */
+    async loadHot(url) {
+        try {
+            const h = (await this.io.fetchJson(url));
+            if (h && h.kinds)
+                this.hot = h.kinds;
+        }
+        catch { /* no hot.json: prefetch() is a no-op */ }
+    }
+    /** Fetch, in parallel, every file the hot lists name for these kinds that is not in memory yet. Returns how many. */
+    async prefetchHot(kinds, concurrency = 16) {
+        const paths = new Set();
+        for (const k of kinds)
+            for (const p of this.hot[k] ?? [])
+                paths.add(p);
+        const wanted = [];
+        for (const p of paths) {
+            const f = this.files.get(p);
+            if (f && !this.cache.has(f.path))
+                wanted.push(f);
+        }
+        let i = 0, done = 0;
+        await Promise.all(Array.from({ length: Math.min(concurrency, wanted.length) }, async () => {
+            while (i < wanted.length) {
+                const f = wanted[i++];
+                try {
+                    await this.fetchAsync(f);
+                }
+                catch (e) {
+                    this.logger.warn('bundle', `prefetch ${f.path}: ${e?.message ?? e}`);
+                } // the run reports it too
+                fetchingEvent(f.path.slice(f.path.lastIndexOf('/') + 1), ++done, wanted.length);
+            }
+        }));
+        this.logger.info('bundle', `prefetch ${kinds.join(', ')}: ${wanted.length ? `${plural(wanted.length, 'file')} fetched` : 'nothing to fetch'}`);
+        return wanted.length;
+    }
+    /** Every manifest's `eager` list, fetched into memory. */
+    async prefetchEager() {
+        const wanted = [];
+        for (const { manifest } of this.manifests)
+            for (const p of manifest.eager ?? []) {
+                const f = this.files.get(p);
+                if (f)
+                    wanted.push(f);
+            }
+        await Promise.all(wanted.map((f) => this.fetchAsync(f)));
+    }
+    /** Fetch every file in the set (for environments without sync I/O). */
+    async prefetchAll(filter) {
+        const wanted = [...this.files.values()].filter((f) => !this.cache.has(f.path) && (!filter || filter(f)));
+        // modest concurrency
+        let i = 0;
+        const workers = Array.from({ length: 8 }, async () => {
+            while (i < wanted.length) {
+                const f = wanted[i++];
+                await this.fetchAsync(f);
+            }
+        });
+        await Promise.all(workers);
+    }
+    async fetchAsync(f) {
+        const hit = this.cache.get(f.path);
+        if (hit)
+            return hit;
+        const data = await this.io.fetch(f.url);
+        this.cache.set(f.path, data);
+        this.logger.trace('bundle', `fetched ${f.path} (${data.length} bytes)`);
+        return data;
+    }
+    /** Synchronous bytes for a file: from memory, else via fetchSync. Throws if impossible. */
+    fetchSyncFile(f) {
+        const hit = this.cache.get(f.path);
+        if (hit)
+            return hit;
+        if (!this.io.fetchSync)
+            throw new Error(`mp-tikz-wasm: ${f.path} was not prefetched and this environment cannot load files synchronously (run in a Worker, or call preload())`);
+        let data;
+        try {
+            data = this.io.fetchSync(f.url);
+        }
+        catch (e) {
+            this.logger.error('bundle', `${f.path}: ${e?.message ?? e}`);
+            throw e;
+        }
+        this.cache.set(f.path, data);
+        this.logger.debug('bundle', `loaded ${f.path} (${data.length} bytes)`); // a sync XHR in the Worker, a disk read in Node
+        return data;
+    }
+    get canFetchSync() { return !!this.io.fetchSync; }
+    has(path) { return this.cache.has(path); }
+    /**
+     * 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, root = TEXMF_ROOT) {
+        mkdirp(FS, root);
+        const index = this.index();
+        const lazyDir = (dirPath, rel) => {
+            const node = FS.lookupPath(dirPath).node;
+            const origOps = node.node_ops;
+            const children = index.dirs.get(rel);
+            const materialised = new Set();
+            const create = (name) => {
+                if (materialised.has(name))
+                    return false;
+                materialised.add(name);
+                const childRel = rel ? `${rel}/${name}` : name;
+                const full = `${dirPath}/${name}`;
+                if (index.dirs.has(childRel)) {
+                    FS.mkdir(full);
+                    lazyDir(full, childRel);
+                    return true;
+                }
+                const f = this.files.get(childRel);
+                if (!f)
+                    return false;
+                const data = this.cache.get(childRel);
+                if (data)
+                    FS.writeFile(full, data);
+                else
+                    createLazyFile(FS, full, f.size, () => this.fetchSyncFile(f));
+                return true;
+            };
+            node.node_ops = {
+                ...origOps,
+                lookup: (parent, name) => {
+                    if (children?.has(name) && create(name))
+                        return FS.lookupNode(parent, name);
+                    return origOps.lookup(parent, name);
+                },
+                readdir: (n) => { if (children)
+                    for (const name of children)
+                        create(name); return origOps.readdir(n); },
+            };
+        };
+        lazyDir(root, '');
+        FS.writeFile(`${root}/ls-R`, this.lsRText ??= this.lsR());
+    }
+    lsRText;
+    indexCache;
+    /** directory -> immediate children, for the on-demand tree */
+    index() {
+        if (this.indexCache)
+            return this.indexCache;
+        const dirs = new Map();
+        const ensure = (d) => { let s = dirs.get(d); if (!s) {
+            s = new Set();
+            dirs.set(d, s);
+        } return s; };
+        ensure('');
+        for (const path of this.files.keys()) {
+            const parts = path.split('/');
+            let d = '';
+            for (let i = 0; i < parts.length - 1; i++) {
+                ensure(d).add(parts[i]);
+                d = d ? `${d}/${parts[i]}` : parts[i];
+                ensure(d);
+            }
+            ensure(d).add(parts[parts.length - 1]);
+        }
+        for (const { manifest } of this.manifests)
+            for (const d of manifest.dirs ?? []) {
+                const parts = d.split('/');
+                let p = '';
+                for (const x of parts) {
+                    ensure(p).add(x);
+                    p = p ? `${p}/${x}` : x;
+                    ensure(p);
+                }
+            }
+        return (this.indexCache = { dirs });
+    }
+    /** kpathsea ls-R database text for the merged tree. */
+    lsR() {
+        const dirs = new Map();
+        const ensure = (d) => { let l = dirs.get(d); if (!l) {
+            l = [];
+            dirs.set(d, l);
+        } return l; };
+        ensure('.');
+        for (const path of this.files.keys()) {
+            const parts = path.split('/');
+            let d = '.';
+            for (let i = 0; i < parts.length - 1; i++) {
+                const sub = parts[i];
+                const list = ensure(d);
+                if (!list.includes(sub))
+                    list.push(sub);
+                d = d + '/' + sub;
+                ensure(d);
+            }
+            ensure(d).push(parts[parts.length - 1]);
+        }
+        let out = '% ls-R -- filename database for kpathsea; do not change this line.\n';
+        for (const d of [...dirs.keys()].sort()) {
+            out += `\n${d}:\n`;
+            for (const e of dirs.get(d).sort())
+                out += e + '\n';
+        }
+        return out;
+    }
+    /** Find bundle files by bare name (e.g. "cmr10.tfm"), optionally restricted to a directory prefix. */
+    lookup(name, prefixes) {
+        const list = this.byName.get(name);
+        if (!list)
+            return undefined;
+        if (!prefixes)
+            return list[0];
+        for (const p of prefixes) {
+            const f = list.find((x) => x.path.startsWith(p));
+            if (f)
+                return f;
+        }
+        return undefined;
+    }
+    noteMiss(key) { this.negative.add(key); }
+    isMiss(key) { return this.negative.has(key); }
+}
+/** Browser I/O: fetch() plus a synchronous XHR that only works inside a Worker. */
+export function browserIO() {
+    const io = {
+        async fetch(url) { const r = await fetch(url); if (!r.ok)
+            throw new Error(`fetch ${url}: ${r.status}`); return new Uint8Array(await r.arrayBuffer()); },
+        // manifests and hot lists name the current files: always revalidated (a 304 when unchanged)
+        async fetchJson(url) { const r = await fetch(url, { cache: 'no-cache' }); if (!r.ok)
+            throw new Error(`fetch ${url}: ${r.status}`); return r.json(); },
+    };
+    if (inWorker && typeof XMLHttpRequest !== 'undefined') {
+        io.fetchSync = (url) => {
+            fetchingEvent(url.slice(url.lastIndexOf('/') + 1)); // the stall watchdog sees a slow host at work
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', url, false);
+            xhr.responseType = 'arraybuffer';
+            xhr.send(null);
+            if (xhr.status < 200 || xhr.status >= 300)
+                throw new Error(`sync fetch ${url}: ${xhr.status}`);
+            return new Uint8Array(xhr.response);
+        };
+    }
+    return io;
+}
+//# sourceMappingURL=bundle.js.map

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

@@ -0,0 +1,62 @@
+/**
+ * lazyfs.ts — lazily-loaded files in the Emscripten MEMFS (docs/06 §4.3).
+ *
+ * A lazy file is a real MEMFS node whose size is known up front (so that
+ * stat(), readdir() and kpathsea's ls-R walks work) and whose bytes are
+ * fetched synchronously the first time anything reads it. The loader must be
+ * synchronous: a sync XMLHttpRequest inside a Web Worker, or fs.readFileSync
+ * in Node. On the browser main thread there is no synchronous loader, so the
+ * caller must prefetch (see bundle.ts).
+ */
+export interface EmscriptenFS {
+    mkdir(path: string, mode?: number): void;
+    writeFile(path: string, data: Uint8Array | string, opts?: {
+        encoding?: string;
+    }): void;
+    readFile(path: string, opts?: {
+        encoding?: 'binary' | 'utf8';
+    }): Uint8Array | string;
+    analyzePath(path: string): {
+        exists: boolean;
+        object?: any;
+        isRoot?: boolean;
+    };
+    createFile(parent: string, name: string, properties: object, canRead: boolean, canWrite: boolean): any;
+    lookupPath(path: string, opts?: object): {
+        node: any;
+    };
+    unlink(path: string): void;
+    readdir(path: string): string[];
+    stat(path: string): {
+        size: number;
+        mode: number;
+        mtime: Date;
+    };
+    isDir(mode: number): boolean;
+    isFile(mode: number): boolean;
+    chdir(path: string): void;
+    cwd(): string;
+    mount(type: unknown, opts: object, mountpoint: string): void;
+    utime?(path: string, atime: number, mtime: number): void;
+    [k: string]: any;
+}
+export type LazyLoader = (path: string) => Uint8Array;
+/** mkdir -p */
+export declare function mkdirp(FS: EmscriptenFS, dir: string): void;
+/** Create a lazy node at `path` with the given size. Returns false if a file already exists there. */
+export declare function createLazyFile(FS: EmscriptenFS, path: string, size: number, load: LazyLoader): boolean;
+/** True if `path` is a lazy node that has not been fetched yet. */
+export declare function isUnloadedLazy(FS: EmscriptenFS, path: string): boolean;
+/** Force-load a lazy node (no-op for ordinary files). */
+export declare function ensureLoaded(FS: EmscriptenFS, path: string): void;
+/** Write a text or binary file, creating directories as needed. */
+export declare function writeFileDeep(FS: EmscriptenFS, path: string, data: Uint8Array | string): void;
+/**
+ * Record every file opened for writing from now on (absolute paths, into the
+ * returned set). The engine's open syscall reaches the filesystem through
+ * FS.open, so wrapping it sees TeX's \openout and LuaTeX's io.open alike;
+ * install it after the host's own setup writes, or they count too.
+ */
+export declare function trackWrites(FS: EmscriptenFS): Set<string>;
+/** Recursively collect regular files under `dir` (used to harvest artifacts). */
+export declare function listFiles(FS: EmscriptenFS, dir: string): string[];

package/runtime/dist/vfs/lazyfs.js

@@ -0,0 +1,133 @@
+/**
+ * lazyfs.ts — lazily-loaded files in the Emscripten MEMFS (docs/06 §4.3).
+ *
+ * A lazy file is a real MEMFS node whose size is known up front (so that
+ * stat(), readdir() and kpathsea's ls-R walks work) and whose bytes are
+ * fetched synchronously the first time anything reads it. The loader must be
+ * synchronous: a sync XMLHttpRequest inside a Web Worker, or fs.readFileSync
+ * in Node. On the browser main thread there is no synchronous loader, so the
+ * caller must prefetch (see bundle.ts).
+ */
+const LAZY = Symbol('mpwasm.lazy');
+/** mkdir -p */
+export function mkdirp(FS, dir) {
+    const parts = dir.split('/').filter(Boolean);
+    let cur = '';
+    for (const p of parts) {
+        cur += '/' + p;
+        const a = FS.analyzePath(cur);
+        if (!a.exists)
+            FS.mkdir(cur);
+    }
+}
+/** Create a lazy node at `path` with the given size. Returns false if a file already exists there. */
+export function createLazyFile(FS, path, size, load) {
+    const i = path.lastIndexOf('/');
+    const dir = i > 0 ? path.slice(0, i) : '/';
+    const name = path.slice(i + 1);
+    if (FS.analyzePath(path).exists)
+        return false;
+    mkdirp(FS, dir);
+    const node = FS.createFile(dir, name, {}, true, true);
+    const state = { loaded: false, data: null };
+    node[LAZY] = state;
+    const origOps = node.stream_ops;
+    const origUsedBytes = Object.getOwnPropertyDescriptor(node, 'usedBytes');
+    Object.defineProperty(node, 'usedBytes', {
+        configurable: true, enumerable: true,
+        get: () => (state.loaded ? state.data.length : size),
+        set: () => { },
+    });
+    const force = () => {
+        if (state.loaded)
+            return;
+        const data = load(path);
+        state.loaded = true;
+        state.data = data;
+        // become an ordinary MEMFS file again
+        delete node.usedBytes;
+        if (origUsedBytes)
+            Object.defineProperty(node, 'usedBytes', origUsedBytes);
+        node.contents = data;
+        node.usedBytes = data.length;
+        node.stream_ops = origOps;
+    };
+    const ops = {};
+    for (const k of Object.keys(origOps)) {
+        ops[k] = (...args) => { force(); return origOps[k](...args); };
+    }
+    node.stream_ops = ops;
+    return true;
+}
+/** True if `path` is a lazy node that has not been fetched yet. */
+export function isUnloadedLazy(FS, path) {
+    const a = FS.analyzePath(path);
+    if (!a.exists || !a.object)
+        return false;
+    const st = a.object[LAZY];
+    return !!st && !st.loaded;
+}
+/** Force-load a lazy node (no-op for ordinary files). */
+export function ensureLoaded(FS, path) {
+    const a = FS.analyzePath(path);
+    if (!a.exists || !a.object)
+        return;
+    const st = a.object[LAZY];
+    if (st && !st.loaded) {
+        // trigger through the stream ops
+        const fd = FS.open(path, 'r');
+        const buf = new Uint8Array(1);
+        FS.read(fd, buf, 0, 1, 0);
+        FS.close(fd);
+    }
+}
+/** Write a text or binary file, creating directories as needed. */
+export function writeFileDeep(FS, path, data) {
+    const i = path.lastIndexOf('/');
+    if (i > 0)
+        mkdirp(FS, path.slice(0, i));
+    if (FS.analyzePath(path).exists) {
+        try {
+            FS.unlink(path);
+        }
+        catch { /* ignore */ }
+    }
+    FS.writeFile(path, data);
+}
+/**
+ * Record every file opened for writing from now on (absolute paths, into the
+ * returned set). The engine's open syscall reaches the filesystem through
+ * FS.open, so wrapping it sees TeX's \openout and LuaTeX's io.open alike;
+ * install it after the host's own setup writes, or they count too.
+ */
+export function trackWrites(FS) {
+    const written = new Set();
+    const open = FS.open;
+    FS.open = function (path, flags, mode) {
+        const stream = open.call(this, path, flags, mode);
+        // O_WRONLY or O_RDWR (numeric), or any mode string but plain 'r'
+        if (typeof flags === 'string' ? flags !== 'r' : (flags & 3) !== 0)
+            written.add(stream.path);
+        return stream;
+    };
+    return written;
+}
+/** Recursively collect regular files under `dir` (used to harvest artifacts). */
+export function listFiles(FS, dir) {
+    const out = [];
+    const walk = (d) => {
+        for (const name of FS.readdir(d)) {
+            if (name === '.' || name === '..')
+                continue;
+            const p = d === '/' ? '/' + name : d + '/' + name;
+            const st = FS.stat(p);
+            if (FS.isDir(st.mode))
+                walk(p);
+            else
+                out.push(p);
+        }
+    };
+    walk(dir);
+    return out;
+}
+//# sourceMappingURL=lazyfs.js.map

package/runtime/dist/worker.d.ts

@@ -0,0 +1,15 @@
+export interface WorkerRequest {
+    id: number;
+    op: 'init' | 'run' | 'latex' | 'bibtex' | 'makeindex' | 'addFiles' | 'removeFiles' | 'clearCache' | 'preload' | 'prefetch' | 'setLogLevel' | 'dispose';
+    [k: string]: unknown;
+}
+export interface WorkerResponse {
+    id: number;
+    ok: boolean;
+    result?: unknown;
+    error?: string;
+}
+export interface WorkerEvent {
+    event: 'progress' | 'log' | 'record';
+    data: unknown;
+}

package/runtime/dist/worker.js

@@ -0,0 +1,143 @@
+/**
+ * worker.ts — the Web Worker entry point (docs/01 §2). Hosts one MetaPostCore
+ * and speaks a tiny request/response protocol with index.ts. The same file runs
+ * as a Node worker_threads worker (MetaPost.create({ worker: true }) in Node),
+ * so that a runaway engine can be terminated there too: a synchronous wasm loop
+ * cannot be interrupted from the thread it runs on.
+ */
+import { MetaPostCore } from './core.js';
+import { BundleSet, browserIO } from './vfs/bundle.js';
+import { resolveBundleSpecs, DEFAULT_BUNDLES } from './bundles-config.js';
+import { Logger, DEFAULT_LOG_LEVEL } from './logger.js';
+import { isNode, nodeIO } from './node.js';
+import { ghostscriptLoader, ghostscriptWanted } from './ghostscript.js';
+// Node worker_threads: give the rest of this file the Web Worker surface it uses
+// (self.onmessage, postMessage, close), backed by parentPort.
+if (isNode) {
+    const { parentPort } = await import('node:worker_threads');
+    if (parentPort) {
+        const g = globalThis;
+        g.self = g;
+        g.postMessage = (m, transfer) => parentPort.postMessage(m, transfer);
+        g.close = () => parentPort.close();
+        parentPort.on('message', (data) => g.onmessage?.({ data }));
+    }
+}
+let core = null;
+let bundles = null;
+let logger = null;
+let baseUrl = '';
+const post = (m, transfer) => self.postMessage(m, transfer ?? []);
+self.onmessage = async (ev) => {
+    const req = ev.data;
+    try {
+        switch (req.op) {
+            case 'init': {
+                const options = req.options;
+                baseUrl = String(req.baseUrl);
+                const io = isNode ? await nodeIO() : browserIO();
+                bundles = new BundleSet(io);
+                // records cross to the main thread, which writes them to the console (or the `logger` option)
+                logger = new Logger(options.logLevel ?? DEFAULT_LOG_LEVEL, (r) => post({ event: 'record', data: r }));
+                bundles.logger = logger;
+                // Node can mount a real texmf tree instead of loading bundles
+                const texmfDir = isNode ? options.texmfDir : undefined;
+                // manifests, hot lists and engine glue all at once: a slow host charges per round trip
+                const bundleBase = options.bundleBaseUrl ?? new URL('./bundles/', baseUrl).href;
+                const wantTex = (options.tex ?? 'auto') !== 'none';
+                const glue = (name) => import(/* @vite-ignore */ new URL(name, baseUrl).href).then((m) => m.default, () => undefined);
+                const [mplibFactory, texFactory, dvisvgmFactory, luatexFactory] = await Promise.all([
+                    import(/* @vite-ignore */ new URL('./mplib.mjs', baseUrl).href).then((m) => m.default),
+                    wantTex ? glue('./tex.mjs') : undefined,
+                    wantTex ? glue('./dvisvgm.mjs') : undefined,
+                    wantTex ? glue('./luatex.mjs') : undefined,
+                    texmfDir ? undefined : bundles.addAll(resolveBundleSpecs(options.bundles ?? DEFAULT_BUNDLES, bundleBase)),
+                    texmfDir ? undefined : bundles.loadHot((bundleBase.endsWith('/') ? bundleBase : bundleBase + '/') + 'hot.json'),
+                ]);
+                if (!texmfDir) {
+                    await bundles.prefetchEager();
+                    if (!bundles.canFetchSync)
+                        await bundles.prefetchAll();
+                }
+                const gsBase = options.ghostscriptBaseUrl ?? new URL('./ghostscript/', baseUrl).href;
+                const ghostscript = dvisvgmFactory && ghostscriptWanted(options.ghostscript, options.bundles ?? DEFAULT_BUNDLES)
+                    ? ghostscriptLoader({ glueUrl: new URL('gs.mjs', gsBase).href, wasmUrl: new URL('gs.wasm', gsBase).href, fetch: (u) => io.fetch(u), log: (m) => logger?.info('host', m) })
+                    : undefined;
+                // bibtex.wasm and makeindex.wasm: imported on first use
+                const toolFactories = new Map();
+                const tools = (name) => { let f = toolFactories.get(name); if (!f)
+                    toolFactories.set(name, f = glue(`./${name}.mjs`)); return f; };
+                core = new MetaPostCore({
+                    mplibFactory, texFactory, luatexFactory, dvisvgmFactory, ghostscript, tools, bundles: texmfDir ? undefined : bundles, texmfDir, options, logger,
+                    onProgress: (e) => post({ event: 'progress', data: e }),
+                    onLog: (line) => post({ event: 'log', data: line }),
+                });
+                await core.init();
+                post({ id: req.id, ok: true, result: { version: core.version } });
+                break;
+            }
+            case 'run': {
+                const r = await core.run(req.source, req.options);
+                post({ id: req.id, ok: true, result: r });
+                break;
+            }
+            case 'latex': {
+                const r = await core.latex(req.source, req.options);
+                post({ id: req.id, ok: true, result: r });
+                break;
+            }
+            case 'bibtex':
+                post({ id: req.id, ok: true, result: await core.bibtex(req.options) });
+                break;
+            case 'makeindex':
+                post({ id: req.id, ok: true, result: await core.makeindex(req.options) });
+                break;
+            case 'addFiles':
+                core.addFiles(req.files);
+                post({ id: req.id, ok: true });
+                break;
+            case 'removeFiles':
+                core.removeFiles(req.names);
+                post({ id: req.id, ok: true });
+                break;
+            case 'clearCache':
+                core.clearCache();
+                post({ id: req.id, ok: true });
+                break;
+            case 'preload': {
+                const names = req.bundles;
+                for (const spec of resolveBundleSpecs(names, new URL('./bundles/', baseUrl).href)) {
+                    if (!bundles.manifests.some((m) => m.spec.name === spec.name))
+                        await bundles.add(spec);
+                }
+                await bundles.prefetchAll((f) => names.includes(f.bundle));
+                post({ id: req.id, ok: true });
+                break;
+            }
+            case 'prefetch': {
+                const n = await bundles.prefetchHot(req.kinds);
+                post({ id: req.id, ok: true, result: n });
+                break;
+            }
+            case 'setLogLevel':
+                if (logger)
+                    logger.level = req.level;
+                post({ id: req.id, ok: true });
+                break;
+            case 'dispose':
+                post({ id: req.id, ok: true });
+                self.close();
+                break;
+        }
+    }
+    catch (e) {
+        const msg = typeof e === 'string' ? e : e?.stack ?? e?.message ?? (() => { try {
+            return JSON.stringify(e);
+        }
+        catch {
+            return String(e);
+        } })();
+        post({ id: req.id, ok: false, error: msg });
+    }
+};
+//# sourceMappingURL=worker.js.map