fullbleed 0.1.5 → 0.3.0

package/src/render-input.cjs

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+'use strict';
+
+class FullbleedError extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = 'FullbleedError';
+    this.code = code;
+  }
+}
+const invalid = message => { throw new FullbleedError('INVALID_INPUT', message); };
+const sourceLimit = 4_000_000;
+const assetLimit = 64 * 1024 * 1024;
+
+function normalize(options, { browser = false } = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) invalid('Pass an options object with an html string.');
+  const supported = new Set(['html', 'css', 'fonts', 'assets', 'previewDpi', 'timeoutMs', 'maxPages', 'allowMissingGlyphs', 'signal']);
+  if (!browser) supported.add('isolation');
+  for (const key of Object.keys(options)) if (!supported.has(key)) invalid(`Unknown option: ${key}`);
+  const { html, css = '', fonts = [], assets = {}, previewDpi = 0, timeoutMs = 30000, maxPages = 1000, allowMissingGlyphs = false, signal, isolation = 'worker' } = options;
+  if (typeof html !== 'string' || !html.trim()) invalid('html must be a nonempty string.');
+  if (typeof css !== 'string') invalid('css must be a string.');
+  if (new TextEncoder().encode(html).byteLength + new TextEncoder().encode(css).byteLength > sourceLimit) invalid('HTML and CSS together must not exceed 4,000,000 UTF-8 bytes.');
+  if (!Number.isInteger(previewDpi) || (previewDpi !== 0 && (previewDpi < 36 || previewDpi > 300))) invalid('previewDpi must be 0 (disabled) or an integer from 36 to 300.');
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) invalid('timeoutMs must be a positive integer no greater than 2147483647.');
+  if (!Number.isSafeInteger(maxPages) || maxPages < 1) invalid('maxPages must be a positive integer.');
+  if (typeof allowMissingGlyphs !== 'boolean') invalid('allowMissingGlyphs must be a boolean.');
+  if (signal !== undefined && !(signal instanceof AbortSignal)) invalid('signal must be an AbortSignal.');
+  if (isolation !== 'worker' && isolation !== 'process') invalid('isolation must be worker or process.');
+  if (!Array.isArray(fonts)) invalid('fonts must be an array of font byte arrays.');
+  if (!assets || typeof assets !== 'object' || Array.isArray(assets)) invalid('assets must map relative names to byte arrays.');
+  let assetBytes = 0;
+  function bytes(value, label) {
+    if (!(value instanceof Uint8Array) || !value.byteLength) invalid(`${label} must be a nonempty Uint8Array or Buffer.`);
+    assetBytes += value.byteLength;
+    if (assetBytes > assetLimit) invalid('Custom fonts and assets together must not exceed 64 MiB.');
+    return Uint8Array.from(value); // Snapshot caller-owned buffers before any await.
+  }
+  const customFonts = fonts.map((font, i) => ({ name: `fonts/custom-${i}.ttf`, data: bytes(font, `fonts[${i}]`) }));
+  const names = Object.keys(assets);
+  const fileNames = new Set(names);
+  const assetFiles = names.map(name => {
+    const segments = name.split('/');
+    if (!name || /[\\:\0]/.test(name) || segments.some(s => !s || s === '.' || s === '..')) invalid(`Invalid asset path: ${name}`);
+    for (let i = 1; i < segments.length; i++) if (fileNames.has(segments.slice(0, i).join('/'))) invalid(`Asset is both a file and a directory: ${name}`);
+    return { name: 'assets/' + name, data: bytes(assets[name], `assets[${name}]`) };
+  });
+  return { html, css, customFonts, assetFiles, previewDpi, timeoutMs, maxPages, allowMissingGlyphs, signal, isolation };
+}
+
+module.exports = { FullbleedError, normalize };

package/src/worker.js

@@ -1,46 +1,6 @@
 // SPDX-License-Identifier: MIT
 import { parentPort, workerData } from 'node:worker_threads';
-import { WASI, File, OpenFile, Directory, ConsoleStdout, PreopenDirectory } from '@bjorn3/browser_wasi_shim';
+import { runEngine } from './engine-runner.js';
 
-try {
-  const job = workerData;
-  const root = new PreopenDirectory('.', new Map());
-  const put = (path, data) => {
-    const parts = path.split('/');
-    let directory = root.dir;
-    for (const part of parts.slice(0, -1)) {
-      if (!directory.contents.has(part)) directory.contents.set(part, new Directory(new Map()));
-      directory = directory.contents.get(part);
-    }
-    directory.contents.set(parts.at(-1), new File(data));
-  };
-  const encoder = new TextEncoder();
-  put('input.html', encoder.encode(job.html));
-  put('style.css', encoder.encode(job.css));
-  for (const file of [...job.fonts, ...job.assets]) put(file.name, file.data);
-  let log = '';
-  const collect = line => { if (log.length < 4000) log += String(line).slice(0, 4000 - log.length) + '\n'; };
-  const wasi = new WASI(['fullbleed', String(job.maxPages), String(job.previewDpi), job.allowMissingGlyphs ? 'allow' : 'reject', ...job.fonts.map(f => f.name)], [], [
-    new OpenFile(new File([])), ConsoleStdout.lineBuffered(collect), ConsoleStdout.lineBuffered(collect), root,
-  ], { debug: false });
-  const instance = await WebAssembly.instantiate(job.module, { wasi_snapshot_preview1: wasi.wasiImport });
-  const status = wasi.start(instance);
-  if (status !== 0) {
-    const code = ['PAGE_LIMIT', 'MISSING_GLYPHS', 'PREVIEW_FAILED'].find(c => log.includes(c + ':')) ?? 'RENDER_FAILED';
-    parentPort.postMessage({ ok: false, code, message: log.trim() || `The engine exited with code ${status}.` });
-  } else {
-    const read = name => {
-      const file = root.dir.contents.get(name);
-      if (!(file instanceof File)) throw new Error(`Missing engine output: ${name}`);
-      return Uint8Array.from(file.data);
-    };
-    const report = JSON.parse(new TextDecoder().decode(read('result.json')));
-    const pdf = read('document.pdf');
-    if (new TextDecoder().decode(pdf.slice(0, 5)) !== '%PDF-') throw new Error('Engine output is not a PDF.');
-    const previews = job.previewDpi ? Array.from({ length: report.pages }, (_, i) => read(`preview-${i + 1}.png`)) : [];
-    parentPort.postMessage({ ok: true, pdf, previews, ...report }, [pdf.buffer, ...previews.map(p => p.buffer)]);
-  }
-} catch (cause) {
-  const code = cause instanceof WebAssembly.RuntimeError || cause instanceof RangeError ? 'ENGINE_LIMIT' : 'RENDER_FAILED';
-  parentPort.postMessage({ ok: false, code, message: cause.message || String(cause) });
-}
+const result = await runEngine(workerData);
+parentPort.postMessage(result, result.ok ? [result.pdf.buffer, ...result.previews.map(page => page.buffer)] : []);