@lofcz/tikz 0.0.0-stage → 0.2.0

package/runtime/licenses/LGPL-3.0.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/runtime/licenses/OFL-1.1.txt

@@ -0,0 +1,93 @@
+Copyright 2017 The EB Garamond Project Authors (https://github.com/octaviopardo/EBGaramond12)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/runtime/package.json

@@ -0,0 +1 @@
+{"type":"module","version":"0.5.0"}

package/runtime/upstream.json

@@ -0,0 +1,27 @@
+{
+  "repository": "https://github.com/lofcz/mp-tikz-wasm",
+  "version": "0.5.0",
+  "commit": "d44aeeba98b0e60d13c35dfd080076e6b05c68b5",
+  "archive": "https://github.com/lofcz/mp-tikz-wasm/releases/download/native-v0.5.0-r1/tikz-native-0.5.0.tar.gz",
+  "sha256": "fa5b8752f7e59e83ad9ffa934022ced278b3f19c7c4d0205b5c3cb028ffc5560",
+  "bundles": [
+    "core",
+    "cm-tfm",
+    "cm-type1",
+    "lm-fonts",
+    "ps-fonts",
+    "tex-plain",
+    "latex-core",
+    "latex-extra",
+    "tikz-snapshot",
+    "luatex"
+  ],
+  "upstream": {
+    "repository": "https://github.com/jmckalex/mp-tikz-wasm",
+    "version": "0.5.0",
+    "commit": "d44aeeba98b0e60d13c35dfd080076e6b05c68b5",
+    "archive": "https://github.com/jmckalex/mp-tikz-wasm/releases/download/v0.5.0/mp-tikz-wasm-0.5.0.tar.gz",
+    "sha256": "76b5591a83adfb96e8087b8560fd993c6ebba475ad15a63269a8aa47517dd575"
+  },
+  "distribution": "brotli-bundle-archives-v1"
+}

package/src/browser-worker.js

@@ -0,0 +1,26 @@
+import { MetaPost } from '../runtime/dist/index.js';
+
+try {
+  const engine = await MetaPost.create({ worker: false, logLevel: 'silent' });
+  self.onmessage = async ({ data: { source: code, maxOutputBytes } }) => {
+    try {
+      const source = /^\s*\\documentclass\b/m.test(code) ? code : String.raw`\documentclass[tikz,border=6pt]{standalone}
+\usetikzlibrary{calc,intersections,angles,quotes,arrows.meta,positioning}
+\begin{document}
+${code}
+\end{document}`;
+      const result = await engine.latex(source, { fonts: 'paths' });
+      if (result.status === 'error' || result.status === 'fatal' || result.pages?.length !== 1)
+        throw new Error('TikZ requires one valid page. ' + JSON.stringify(result.diagnostics).slice(0, 2000));
+      const svg = result.pages[0], bytes = new TextEncoder().encode(svg);
+      if (bytes.length > maxOutputBytes) throw new Error('TikZ output too large; simplify the picture.');
+      const dimensions = svg.match(/viewBox=['"]([^'"]+)['"]/)?.[1].trim().split(/[ ,]+/).map(Number);
+      if (!dimensions || dimensions.length !== 4 || !dimensions.every(Number.isFinite) || dimensions[2] <= 0 || dimensions[3] <= 0)
+        throw new Error('TikZ returned an invalid picture size');
+      let binary = '';
+      for (let start = 0; start < bytes.length; start += 8192) binary += String.fromCharCode(...bytes.subarray(start, start + 8192));
+      self.postMessage({ image: { svg, width: dimensions[2], height: dimensions[3], dataUrl: `data:image/svg+xml;base64,${btoa(binary)}` } });
+    } catch (error) { self.postMessage({ error: String(error).slice(0, 3000) }); }
+  };
+  self.postMessage({ ready: true });
+} catch (error) { self.postMessage({ error: String(error).slice(0, 3000) }); }

package/src/browser.d.ts

@@ -0,0 +1,18 @@
+import type { TikzImage, TikzRenderOptions } from './index.js';
+export declare const TIKZ_MAX_SOURCE: 12000;
+export interface BrowserTikzRendererOptions {
+  /** Same-origin URL ending in /, populated with copyTikzBrowserAssets. */
+  assetBaseUrl: string | URL;
+  /** Compilation deadline, default 30000 ms. */
+  timeoutMs?: number;
+  /** Initial worker/runtime loading deadline, default 60000 ms. */
+  loadTimeoutMs?: number;
+  maxQueue?: number;
+  maxSourceLength?: number;
+  maxOutputBytes?: number;
+}
+export interface BrowserTikzRenderer {
+  render(source: string, options?: TikzRenderOptions): Promise<TikzImage>;
+  dispose(): void;
+}
+export declare function createTikzRenderer(options: BrowserTikzRendererOptions): BrowserTikzRenderer;

package/src/browser.js

@@ -0,0 +1,68 @@
+export const TIKZ_MAX_SOURCE = 12_000;
+const aborted = () => new DOMException('TikZ rendering aborted', 'AbortError');
+
+/** A lazy, reusable worker. TeX never runs on the UI thread. */
+export function createTikzRenderer(options) {
+  const { assetBaseUrl, timeoutMs = 30_000, loadTimeoutMs = 60_000,
+    maxQueue = 8, maxSourceLength = TIKZ_MAX_SOURCE, maxOutputBytes = 4_000_000 } = options ?? {};
+  if (!assetBaseUrl) throw new TypeError('TikZ assetBaseUrl is required');
+  for (const [name, value] of Object.entries({ timeoutMs, loadTimeoutMs, maxQueue, maxSourceLength, maxOutputBytes }))
+    if (!Number.isSafeInteger(value) || value < (name === 'maxQueue' ? 0 : 1)) throw new TypeError(`Invalid TikZ ${name}`);
+  let worker, ready = false, active, disposed = false;
+  const queue = [];
+  function stop() { worker?.terminate(); worker = undefined; ready = false; }
+  function finish(error, image) {
+    const job = active; if (!job) return;
+    active = undefined; clearTimeout(job.timer); job.signal?.removeEventListener('abort', job.abort);
+    if (error) { stop(); job.reject(error); } else job.resolve(image);
+    pump();
+  }
+  function execute() {
+    if (!active) return;
+    clearTimeout(active.timer);
+    active.timer = setTimeout(() => finish(new Error('TikZ execution timed out; simplify or split the picture.')), timeoutMs);
+    worker.postMessage({ source: active.source, maxOutputBytes });
+  }
+  function pump() {
+    if (active || disposed || !queue.length) return;
+    active = queue.shift(); clearTimeout(active.timer);
+    if (ready) { execute(); return; }
+    active.timer = setTimeout(() => finish(new Error('TikZ runtime loading timed out.')), loadTimeoutMs);
+    try {
+      worker = new Worker(new URL('src/browser-worker.js', new URL(assetBaseUrl, location.href)), { type: 'module', name: 'tikz' });
+      worker.onmessage = ({ data }) => {
+        if (data.ready) { ready = true; execute(); }
+        else if (data.error) finish(new Error(data.error));
+        else if (data.image) finish(undefined, data.image);
+      };
+      worker.onerror = event => { event.preventDefault(); finish(new Error(event.message || 'TikZ worker failed')); };
+      worker.onmessageerror = () => finish(new Error('Invalid TikZ worker response'));
+    } catch (error) { finish(error); }
+  }
+  return {
+    render(source, { signal } = {}) {
+      if (disposed) return Promise.reject(new Error('TikZ renderer disposed'));
+      if (signal?.aborted) return Promise.reject(aborted());
+      if (typeof source !== 'string' || !source.trim() || source.length > maxSourceLength)
+        return Promise.reject(new Error(`TikZ: use 1–${maxSourceLength.toLocaleString('en-US')} characters.`));
+      if (active && queue.length >= maxQueue) return Promise.reject(new Error('TikZ renderer busy; retry shortly.'));
+      return new Promise((resolve, reject) => {
+        const job = { source, signal, resolve, reject, timer: undefined, abort: undefined };
+        const remove = error => {
+          if (active === job) { finish(error); return; }
+          const index = queue.indexOf(job); if (index < 0) return;
+          queue.splice(index, 1); clearTimeout(job.timer); signal?.removeEventListener('abort', job.abort); reject(error);
+        };
+        job.abort = () => remove(aborted());
+        signal?.addEventListener('abort', job.abort, { once: true });
+        job.timer = setTimeout(() => remove(new Error('TikZ queue wait timed out')), loadTimeoutMs + timeoutMs);
+        queue.push(job); pump();
+      });
+    },
+    dispose() {
+      disposed = true;
+      finish(new Error('TikZ renderer disposed')); stop();
+      for (const job of queue.splice(0)) { clearTimeout(job.timer); job.signal?.removeEventListener('abort', job.abort); job.reject(new Error('TikZ renderer disposed')); }
+    },
+  };
+}

package/src/deploy.d.ts

@@ -0,0 +1,5 @@
+/** Include the full package in a standalone Node function's node_modules. */
+export declare function copyTikzAssets(functionDirectory: string): Promise<{ directory: string; version: string }>;
+
+/** Copy worker, WASM, licenses and expanded TeX bundles to a static directory. */
+export declare function copyTikzBrowserAssets(directory: string): Promise<{ directory: string; version: string }>;

package/src/deploy.js

@@ -0,0 +1,48 @@
+import { cp, mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { brotliDecompressSync } from 'node:zlib';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+
+/** Copy a complete package into an otherwise standalone Node function artifact. */
+export async function copyTikzAssets(functionDirectory) {
+  const source = dirname(createRequire(import.meta.url).resolve('@lofcz/tikz/package.json'));
+  const destination = resolve(functionDirectory, 'node_modules/@lofcz/tikz');
+  if (await realpath(destination).catch(() => '') === await realpath(source))
+    throw new Error('TikZ deployment destination must differ from the installed package');
+  await mkdir(destination, { recursive: true });
+  const manifest = JSON.parse(await readFile(join(source, 'package.json'), 'utf8'));
+  for (const entry of ['src', 'runtime', 'LICENSE', 'NOTICE.md', 'upstream.json', 'package.json'])
+    await cp(join(source, entry), join(destination, entry), { recursive: true, dereference: true });
+  // Validate resolution from the output, never accidentally use the developer's install.
+  const resolved = createRequire(join(resolve(functionDirectory), 'handler.mjs')).resolve('@lofcz/tikz/package.json');
+  if (await realpath(dirname(resolved)) !== await realpath(destination))
+    throw new Error('TikZ resolves outside the deployment artifact');
+  return { directory: destination, version: manifest.version };
+}
+
+/** Produce ordinary static assets; no backend endpoint or special HTTP encoding. */
+export async function copyTikzBrowserAssets(directory) {
+  const source = dirname(createRequire(import.meta.url).resolve('@lofcz/tikz/package.json'));
+  const destination = resolve(directory);
+  if (destination === source || destination.startsWith(source + '/'))
+    throw new Error('TikZ browser assets must be outside the installed package');
+  await mkdir(join(destination, 'src'), { recursive: true });
+  await cp(join(source, 'runtime'), join(destination, 'runtime'), { recursive: true });
+  for (const name of ['browser.js', 'browser-worker.js'])
+    await cp(join(source, 'src', name), join(destination, 'src', name));
+  for (const name of ['LICENSE', 'NOTICE.md', 'upstream.json'])
+    await cp(join(source, name), join(destination, name));
+  const pin = JSON.parse(await readFile(join(source, 'upstream.json'), 'utf8'));
+  for (const name of pin.bundles) {
+    const base = join(destination, 'runtime/dist/bundles', name);
+    const index = JSON.parse(await readFile(join(base, 'files.index.json'), 'utf8'));
+    const bytes = brotliDecompressSync(await readFile(join(base, 'files.br')));
+    for (const [path, [offset, size]] of Object.entries(index)) {
+      const file = join(base, 'files', path);
+      await mkdir(dirname(file), { recursive: true });
+      await writeFile(file, bytes.subarray(offset, offset + size));
+    }
+    await rm(join(base, 'files.br')); await rm(join(base, 'files.index.json'));
+  }
+  return { directory: destination, version: JSON.parse(await readFile(join(source, 'package.json'), 'utf8')).version };
+}

package/src/index.d.ts

@@ -0,0 +1,28 @@
+export interface TikzImage {
+  svg: string;
+  width: number;
+  height: number;
+  /** Inert SVG image URL, suitable for an img element. */
+  dataUrl: string;
+}
+export interface TikzRenderOptions { signal?: AbortSignal }
+export interface TikzRendererOptions {
+  /** Running child processes. Default: 2. */
+  concurrency?: number;
+  /** Waiting renders; overflow rejects immediately. Default: 8. */
+  maxQueue?: number;
+  /** Per-render execution deadline, and maximum queue wait. Default: 30000. */
+  timeoutMs?: number;
+  /** Default: 12000 UTF-16 code units. */
+  maxSourceLength?: number;
+  /** Default: 4000000 UTF-8 bytes. */
+  maxOutputBytes?: number;
+  /** Optional Node executable for Bun hosts that do not have node on PATH. */
+  nodeExecutable?: string;
+}
+export interface TikzRenderer {
+  render(source: string, options?: TikzRenderOptions): Promise<TikzImage>;
+}
+export declare const TIKZ_MAX_SOURCE: 12000;
+export declare function createTikzRenderer(options?: TikzRendererOptions): TikzRenderer;
+export declare function renderTikz(source: string, options?: TikzRenderOptions): Promise<TikzImage>;

package/src/index.js

@@ -0,0 +1,103 @@
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+
+export const TIKZ_MAX_SOURCE = 12_000;
+const packageRoot = () => dirname(createRequire(import.meta.url).resolve('@lofcz/tikz/package.json'));
+const abortError = () => new DOMException('TikZ rendering aborted', 'AbortError');
+const busyError = () => new Error('TikZ renderer busy; retry shortly.');
+
+/** @param {import('./index.js').TikzRendererOptions} [options] */
+export function createTikzRenderer(options = {}) {
+  const settings = {
+    concurrency: 2, maxQueue: 8, timeoutMs: 30_000,
+    maxSourceLength: TIKZ_MAX_SOURCE, maxOutputBytes: 4_000_000,
+    nodeExecutable: process.versions.bun ? 'node' : process.execPath,
+    ...options,
+  };
+  for (const name of ['concurrency', 'maxQueue', 'timeoutMs', 'maxSourceLength', 'maxOutputBytes']) {
+    if (!Number.isSafeInteger(settings[name]) || settings[name] < (name === 'maxQueue' ? 0 : 1))
+      throw new TypeError(`Invalid TikZ ${name}`);
+  }
+  if (typeof settings.nodeExecutable !== 'string' || !settings.nodeExecutable)
+    throw new TypeError('Invalid TikZ nodeExecutable');
+  let active = 0;
+  const queue = [];
+  function release() {
+    const next = queue.shift();
+    if (next) next.ready();
+    else active--;
+  }
+  async function acquire(signal) {
+    if (signal?.aborted) throw abortError();
+    if (active < settings.concurrency) { active++; return; }
+    if (queue.length >= settings.maxQueue) throw busyError();
+    await new Promise((resolve, reject) => {
+      const cleanup = () => { clearTimeout(timer); signal?.removeEventListener('abort', aborted); };
+      const remove = (error) => {
+        const index = queue.indexOf(entry);
+        if (index >= 0) queue.splice(index, 1);
+        cleanup(); reject(error);
+      };
+      const aborted = () => remove(abortError());
+      const entry = { ready() { cleanup(); resolve(); } };
+      const timer = setTimeout(() => remove(busyError()), settings.timeoutMs);
+      signal?.addEventListener('abort', aborted, { once: true });
+      queue.push(entry);
+    });
+  }
+  function compile(source, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) { reject(abortError()); return; }
+      const root = packageRoot();
+      const child = spawn(settings.nodeExecutable, ['--max-old-space-size=512', join(root, 'src/worker.js')], {
+        env: {}, cwd: root, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+      });
+      const chunks = [];
+      let bytes = 0, stderr = '', failure;
+      // Keep the semaphore slot until close confirms the killed process is gone.
+      const fail = (error) => { failure ??= error; child.kill('SIGKILL'); };
+      const aborted = () => fail(abortError());
+      const timer = setTimeout(() => fail(new Error(`TikZ exceeded ${settings.timeoutMs}ms; simplify or split the picture.`)), settings.timeoutMs);
+      signal?.addEventListener('abort', aborted, { once: true });
+      child.stdout.on('data', chunk => {
+        bytes += chunk.length;
+        if (bytes > settings.maxOutputBytes) fail(new Error('TikZ output too large; simplify the picture.'));
+        else chunks.push(chunk);
+      });
+      child.stderr.on('data', chunk => { stderr = (stderr + chunk).slice(-4000); });
+      child.on('error', error => { failure ??= error; });
+      child.stdin.on('error', () => {});
+      child.on('close', (code, terminationSignal) => {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', aborted);
+        if (failure) { reject(failure); return; }
+        if (code !== 0 || terminationSignal) { reject(new Error(stderr || 'TikZ compilation failed')); return; }
+        try {
+          const { svg } = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+          const dimensions = typeof svg === 'string' && svg.match(/viewBox=['"]([^'"]+)['"]/)?.[1].trim().split(/[ ,]+/).map(Number);
+          if (!dimensions || dimensions.length !== 4 || !dimensions.every(Number.isFinite) || dimensions[2] <= 0 || dimensions[3] <= 0)
+            throw new Error('TikZ returned an invalid picture size');
+          resolve({ svg, width: dimensions[2], height: dimensions[3], dataUrl: `data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}` });
+        } catch (error) { reject(error); }
+      });
+      child.stdin.end(JSON.stringify({ source }));
+    });
+  }
+  return {
+    async render(code, { signal } = {}) {
+      if (typeof code !== 'string' || !code.trim() || code.length > settings.maxSourceLength)
+        throw new Error(`TikZ: use 1–${settings.maxSourceLength.toLocaleString('en-US')} characters.`);
+      const source = /^\s*\\documentclass\b/m.test(code) ? code : String.raw`\documentclass[tikz,border=6pt]{standalone}
+\usetikzlibrary{calc,intersections,angles,quotes,arrows.meta,positioning}
+\begin{document}
+${code}
+\end{document}`;
+      await acquire(signal);
+      try { return await compile(source, signal); }
+      finally { release(); }
+    },
+  };
+}
+const defaultRenderer = createTikzRenderer();
+export const renderTikz = (source, options) => defaultRenderer.render(source, options);

package/src/worker.js

@@ -0,0 +1,15 @@
+// A separate process makes synchronous TeX loops terminable. The Emscripten
+// filesystem is in-memory; no host texmf tree, shell or caller environment.
+import { readFileSync } from 'node:fs';
+import { MetaPost } from '../runtime/dist/index.js';
+const { source } = JSON.parse(readFileSync(0, 'utf8'));
+const engine = await MetaPost.create({ worker: false, logLevel: 'silent' });
+try {
+  const result = await engine.latex(source, { fonts: 'paths' });
+  if (result.status === 'error' || result.status === 'fatal' || result.pages?.length !== 1)
+    throw new Error('TikZ requires one valid page. ' + JSON.stringify(result.diagnostics).slice(0, 2000));
+  process.stdout.write(JSON.stringify({ svg: result.pages[0] }));
+} catch (error) {
+  process.stderr.write(String(error).slice(0, 3000));
+  process.exitCode = 1;
+} finally { engine.dispose(); }

package/upstream.json

@@ -0,0 +1,27 @@
+{
+  "repository": "https://github.com/lofcz/mp-tikz-wasm",
+  "version": "0.5.0",
+  "commit": "d44aeeba98b0e60d13c35dfd080076e6b05c68b5",
+  "archive": "https://github.com/lofcz/mp-tikz-wasm/releases/download/native-v0.5.0-r1/tikz-native-0.5.0.tar.gz",
+  "sha256": "fa5b8752f7e59e83ad9ffa934022ced278b3f19c7c4d0205b5c3cb028ffc5560",
+  "bundles": [
+    "core",
+    "cm-tfm",
+    "cm-type1",
+    "lm-fonts",
+    "ps-fonts",
+    "tex-plain",
+    "latex-core",
+    "latex-extra",
+    "tikz-snapshot",
+    "luatex"
+  ],
+  "upstream": {
+    "repository": "https://github.com/jmckalex/mp-tikz-wasm",
+    "version": "0.5.0",
+    "commit": "d44aeeba98b0e60d13c35dfd080076e6b05c68b5",
+    "archive": "https://github.com/jmckalex/mp-tikz-wasm/releases/download/v0.5.0/mp-tikz-wasm-0.5.0.tar.gz",
+    "sha256": "76b5591a83adfb96e8087b8560fd993c6ebba475ad15a63269a8aa47517dd575"
+  },
+  "distribution": "brotli-bundle-archives-v1"
+}