fullbleed 0.1.1

package/dist/build.json

@@ -0,0 +1,83 @@
+{
+  "packageVersion": "0.1.1",
+  "engineVersion": "2.5.5",
+  "engineSource": "https://crates.io/crates/fullbleed/2.5.5",
+  "target": "wasm32-wasip1",
+  "memoryMaximumBytes": 536870912,
+  "fonts": [
+    "Inter-Variable.ttf",
+    "DMSerifDisplay-Regular.ttf",
+    "DMSerifDisplay-Italic.ttf",
+    "BebasNeue-Regular.ttf"
+  ],
+  "dependencies": [
+    {
+      "name": "fullbleed",
+      "version": "2.5.5",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "license": "MIT"
+    },
+    {
+      "name": "fullbleed_audit_contract",
+      "version": "0.1.3",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "license": "MIT"
+    },
+    {
+      "name": "rustc-hash",
+      "version": "2.1.3",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "license": "Apache-2.0 OR MIT"
+    },
+    {
+      "name": "subsetter",
+      "version": "0.2.6",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "license": "MIT OR Apache-2.0"
+    },
+    {
+      "name": "unicode-bidi",
+      "version": "0.3.18",
+      "source": "registry+https://github.com/rust-lang/crates.io-index",
+      "license": "MIT OR Apache-2.0"
+    }
+  ],
+  "files": {
+    "dist/engine.wasm": {
+      "bytes": 5047938,
+      "sha256": "60f06871dcd0109f919581f21ba5dac716c2c160094f380d5dba58ec96f0d5ee"
+    },
+    "dist/THIRD_PARTY_NOTICES.txt": {
+      "bytes": 57660,
+      "sha256": "f369b7da5c0d54fb0be0917475e5964cfa276cfe3c7c830f7853213592d41ab8"
+    },
+    "assets/fonts/BebasNeue-OFL.txt": {
+      "bytes": 4337,
+      "sha256": "72082f6cb4d04be2ecf7cc7d9e1e7d73787f0af8a5a278a47cade70c16b78341"
+    },
+    "assets/fonts/BebasNeue-Regular.ttf": {
+      "bytes": 61400,
+      "sha256": "08e4623805102d819f58601e46e345648846075e363b2ceb23313c2d1c83ec73"
+    },
+    "assets/fonts/DMSerifDisplay-Italic.ttf": {
+      "bytes": 71208,
+      "sha256": "df74c0ac387baeaeb0fe4f2324e1668e6a3ed8c09cd9796fe162c71753e19e45"
+    },
+    "assets/fonts/DMSerifDisplay-OFL.txt": {
+      "bytes": 4512,
+      "sha256": "aa49c876a28d8c0b0a3027d6c25b9c607eee8c0fb96165011d42a6ace1408fe1"
+    },
+    "assets/fonts/DMSerifDisplay-Regular.ttf": {
+      "bytes": 76580,
+      "sha256": "8cc3643535edf039aa5d95440a8542735e9197e4f4b8d9303e980fefbf5ab616"
+    },
+    "assets/fonts/Inter-OFL.txt": {
+      "bytes": 4377,
+      "sha256": "5b9321a4298cfeb6b34354164a1c3afc3db114569984c502b9b35d988fd58c57"
+    },
+    "assets/fonts/Inter-Variable.ttf": {
+      "bytes": 876576,
+      "sha256": "29160a80ff49ddcab2c97711247e08b1fab27a484a329ce8b813d820dc559031"
+    }
+  }
+}

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+import type { Buffer } from 'node:buffer';
+
+export interface RenderOptions {
+  html: string;
+  css?: string;
+  /** Additional TrueType font files, as bytes. Use their family names in CSS. */
+  fonts?: readonly Uint8Array[];
+  /** Relative asset names; reference them as assets/name.svg in HTML/CSS. */
+  assets?: Readonly<Record<string, Uint8Array>>;
+  /** 0 disables previews (default); otherwise 36–300 DPI. */
+  previewDpi?: number;
+  /** Includes initial engine loading. Default: 30000 ms. */
+  timeoutMs?: number;
+  /** Reject documents larger than this. Default: 1000. */
+  maxPages?: number;
+  /** Default false: missing glyphs reject the job instead of silently emitting them. */
+  allowMissingGlyphs?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface RenderResult {
+  pdf: Buffer;
+  previews: Buffer[];
+  pages: number;
+  missingGlyphs: number;
+  engineVersion: string;
+}
+
+export class FullbleedError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, options?: ErrorOptions);
+}
+export function renderPdf(options: RenderOptions): Promise<RenderResult>;
+export const engineVersion: string;
+export const version: string;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "fullbleed",
+  "version": "0.1.1",
+  "description": "Generate PDFs from HTML and CSS in Node.js with the Fullbleed Rust engine, bundled fonts, and optional PNG previews.",
+  "type": "module",
+  "main": "./src/index.cjs",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./src/index.cjs"
+      }
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "src/",
+    "dist/",
+    "assets/fonts/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node tools/build.mjs",
+    "prepack": "node tools/check-build.mjs",
+    "test": "node --test test/*.test.mjs",
+    "check:types": "tsc -p tsconfig.json",
+    "verify:native": "node tools/verify-native.mjs",
+    "example": "node examples/invoice.mjs",
+    "verify:pack": "node tools/verify-pack.mjs"
+  },
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "0.4.2"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fullbleed-engine/fullbleed-node.git"
+  },
+  "homepage": "https://github.com/fullbleed-engine/fullbleed-node#readme",
+  "bugs": {
+    "url": "https://github.com/fullbleed-engine/fullbleed-node/issues"
+  },
+  "keywords": [
+    "pdf",
+    "html-to-pdf",
+    "pdf-generation",
+    "fullbleed",
+    "invoice",
+    "reports",
+    "rust",
+    "webassembly"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "fullbleed": {
+    "engineVersion": "2.5.5"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.5",
+    "typescript": "7.0.2"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: MIT
+'use strict';
+const { readFile } = require('node:fs/promises');
+const { createHash } = require('node:crypto');
+const { join } = require('node:path');
+const { Worker } = require('node:worker_threads');
+const { pathToFileURL } = require('node:url');
+const pkg = require('../package.json');
+
+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 hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const sourceLimit = 4_000_000;
+const assetLimit = 64 * 1024 * 1024;
+const root = join(__dirname, '..');
+let runtimePromise;
+
+function runtime() {
+  if (!runtimePromise) runtimePromise = (async () => {
+    const manifest = JSON.parse(await readFile(join(root, 'dist/build.json'), 'utf8'));
+    if (manifest.engineVersion !== pkg.fullbleed.engineVersion) throw new Error('Package and engine versions differ');
+    async function verified(name) {
+      const bytes = await readFile(join(root, name));
+      const expected = manifest.files[name];
+      if (!expected || expected.bytes !== bytes.length || expected.sha256 !== hash(bytes)) throw new Error(`Bundled file failed verification: ${name}`);
+      return new Uint8Array(bytes);
+    }
+    const [wasm, fonts] = await Promise.all([
+      verified('dist/engine.wasm'),
+      Promise.all(manifest.fonts.map(async name => ({ name: 'fonts/' + name, data: await verified('assets/fonts/' + name) }))),
+    ]);
+    const module = await WebAssembly.compile(wasm);
+    const imports = WebAssembly.Module.imports(module);
+    if (!imports.every(i => i.module === 'wasi_snapshot_preview1' && !i.name.startsWith('sock_'))) throw new Error('Unexpected WebAssembly host imports');
+    return { module, fonts };
+  })().catch(cause => { throw new FullbleedError('ENGINE_LOAD_FAILED', 'Could not load the bundled Fullbleed engine: ' + cause.message, { cause }); });
+  return runtimePromise;
+}
+
+function normalize(options) {
+  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']);
+  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 } = 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 (Buffer.byteLength(html) + Buffer.byteLength(css) > 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 (!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: 'body { font-family: Inter; }\n' + css, customFonts, assetFiles, previewDpi, timeoutMs, maxPages, allowMissingGlyphs, signal };
+}
+
+async function renderPdf(options) {
+  if (Number(process.versions.node.split('.')[0]) < 22) throw new FullbleedError('UNSUPPORTED_NODE', 'Fullbleed requires Node.js 22 or newer.');
+  const start = Date.now();
+  const job = normalize(options);
+  const aborted = () => new FullbleedError('ABORTED', 'PDF rendering was aborted.');
+  if (job.signal?.aborted) throw aborted();
+  const remaining = job.timeoutMs - (Date.now() - start);
+  if (remaining <= 0) throw new FullbleedError('TIMEOUT', `PDF rendering exceeded ${job.timeoutMs} ms.`);
+  return new Promise((resolve, reject) => {
+    let worker, timer, settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      job.signal?.removeEventListener('abort', abort);
+      const termination = worker?.terminate();
+      if (termination) termination.catch(() => {});
+      if (error) reject(error); else resolve(result);
+    };
+    const abort = () => finish(aborted());
+    timer = setTimeout(() => finish(new FullbleedError('TIMEOUT', `PDF rendering exceeded ${job.timeoutMs} ms.`)), remaining);
+    job.signal?.addEventListener('abort', abort, { once: true });
+    if (job.signal?.aborted) return abort();
+    runtime().then(loaded => {
+      if (settled) return;
+      // A trusted inline bootstrap supports --input-type callers while letting
+      // Node inherit process flags through its own worker compatibility rules.
+      const entry = pathToFileURL(join(__dirname, 'worker.js')).href;
+      worker = new Worker(`import(${JSON.stringify(entry)})`, {
+        eval: true,
+        workerData: {
+          module: loaded.module, fonts: [...loaded.fonts, ...job.customFonts], assets: job.assetFiles,
+          html: job.html, css: job.css, previewDpi: job.previewDpi, maxPages: job.maxPages,
+          allowMissingGlyphs: job.allowMissingGlyphs,
+        },
+      });
+      worker.once('error', cause => finish(new FullbleedError('WORKER_FAILED', cause.message, { cause })));
+      worker.once('exit', code => {
+        if (!settled) finish(new FullbleedError('WORKER_FAILED', `Rendering worker exited before producing a result (code ${code}).`));
+      });
+      worker.once('message', result => {
+        if (!result.ok) return finish(new FullbleedError(result.code, result.message));
+        finish(null, { pdf: Buffer.from(result.pdf), previews: result.previews.map(bytes => Buffer.from(bytes)),
+          pages: result.pages, missingGlyphs: result.missingGlyphs, engineVersion: pkg.fullbleed.engineVersion });
+      });
+      if (job.signal?.aborted) abort();
+    }).catch(cause => finish(cause instanceof FullbleedError ? cause : new FullbleedError('WORKER_FAILED', cause.message, { cause })));
+  });
+}
+
+exports.renderPdf = renderPdf;
+exports.FullbleedError = FullbleedError;
+exports.engineVersion = pkg.fullbleed.engineVersion;
+exports.version = pkg.version;

package/src/index.d.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+import type { Buffer } from 'node:buffer';
+
+export interface RenderOptions {
+  html: string;
+  css?: string;
+  /** Additional TrueType font files, as bytes. Use their family names in CSS. */
+  fonts?: readonly Uint8Array[];
+  /** Relative asset names; reference them as assets/name.svg in HTML/CSS. */
+  assets?: Readonly<Record<string, Uint8Array>>;
+  /** 0 disables previews (default); otherwise 36–300 DPI. */
+  previewDpi?: number;
+  /** Includes initial engine loading. Default: 30000 ms. */
+  timeoutMs?: number;
+  /** Reject documents larger than this. Default: 1000. */
+  maxPages?: number;
+  /** Default false: missing glyphs reject the job instead of silently emitting them. */
+  allowMissingGlyphs?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface RenderResult {
+  pdf: Buffer;
+  previews: Buffer[];
+  pages: number;
+  missingGlyphs: number;
+  engineVersion: string;
+}
+
+export class FullbleedError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, options?: ErrorOptions);
+}
+export function renderPdf(options: RenderOptions): Promise<RenderResult>;
+export const engineVersion: string;
+export const version: string;

package/src/index.js

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MIT
+import api from './index.cjs';
+export const { renderPdf, FullbleedError, engineVersion, version } = api;

package/src/worker.js

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+import { parentPort, workerData } from 'node:worker_threads';
+import { WASI, File, OpenFile, Directory, ConsoleStdout, PreopenDirectory } from '@bjorn3/browser_wasi_shim';
+
+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) });
+}