blitz-pdf 0.1.3 → 0.1.5

package/docs/layout-regressions.md

@@ -0,0 +1,65 @@
+# Report margins and spacing
+
+`tests/layout.test.ts` exercises the public `renderPdf` API against rebuilt
+WASM. The underlying changes are in the vendored Blitz DOM crate; their
+upstream revision and modified files are listed in `vendor/README.md`.
+
+## Fractional geometry
+
+Blitz normally rounds layout boxes to integer screen pixels. PDF physical
+lengths need fractional coordinates: a 25 mm offset is about 94.488 CSS pixels,
+not 94. Truncating the content viewport also moves right-aligned and
+percentage-sized content. Body layout and header/footer templates now use the
+exact CSS viewport and preserve box coordinates through painting and pagination.
+Tests allow Stylo's 1/60-pixel length quantization.
+
+## Table line heights and empty paragraphs
+
+The root text style of an inline formatting context must use baseline
+alignment. A table cell's `vertical-align: middle` belongs to placement inside
+the row; passing it to the text builder inflated the cell's own lines too.
+Tests compare ordinary blocks with cells containing small labels, values, and
+trailing breaks, and retain descendant superscript and cell alignment coverage.
+
+An empty paragraph containing a span must allow margins to collapse through it.
+The previous empty-text shortcut reported a non-collapsible box, adding an
+extra paragraph margin. It also bypassed explicit heights. Empty inline
+contexts now follow normal sizing and collapse calculations; explicit
+height, min-height, padding, borders, and real blank lines remain effective.
+
+## Table widths and generated wrappers
+
+The report's information table uses `max-width: 0` on its cells. That constraint
+affects intrinsic measurement, while the final cells must fill their allocated
+columns. Previously it also clamped the final content width to zero, producing
+character-by-character wrapping. Tests cover auto/fixed tables and both inline
+and block cell contents, including the full text of height-limited tables.
+
+The report body uses `display: table` with ordinary headings, paragraphs, and
+nested tables as children. These require anonymous rows and cells under
+[CSS 2.1 section 17.2.1](https://www.w3.org/TR/CSS2/tables.html#anonymous-boxes).
+Blitz previously discarded those children. Layout construction now wraps
+consecutive improper children while preserving the author's DOM for selectors.
+Tests compare implicit and explicit wrappers, whitespace, hidden siblings,
+row inheritance, CSS page-size changes, and pagination with nested content.
+
+## Project reproduction
+
+The original offer template was expanded with its project's template compiler,
+synthetic offer data, the unmodified DIN stylesheet, and the project's Noto Sans
+font files. The report configuration defaults to `style_din5008`; its export
+call passes `styleFile`, `fontFamily`, and A4 options, without `styleOverwrite`.
+The stylesheet supplies the 27 mm top and 41 mm bottom page margins.
+
+The resulting one-page report was rendered with Poppler and inspected, including
+the address block, information table, greeting, line item, totals, and footer
+text. Chromium DOM measurements verified column distribution and margin
+behavior with the same HTML. Against the supplied Chromium PDF, the six shared
+information-table labels have the same 21 pt baseline interval; their absolute
+baselines differ by 0.118 pt. The delivery heading and greeting differ by
+0.137 pt and 0.125 pt respectively, and the body left edge by 0.003 pt.
+
+The supplied business PDFs contain different
+data, and normal font metrics can vary across Chromium platforms; this is
+coverage of the project template and layout regressions, not a pixel-equality
+claim for different documents.

package/docs/pagination-regressions.md

@@ -58,12 +58,10 @@ width of about 283.46 pixels, cell widths of about 141.73 pixels and a total
 height of 123 pixels. Changing `max-width` to `none` produces the same
 dimensions for these equal cell contents.
 
-Blitz's final cell layout instead has width 2 pixels (zero content width plus
+Unpatched Blitz's final cell layout instead has width 2 pixels (zero content width plus
 padding), height 78 pixels, and four 19-pixel lines for `Text`. Its table grid
 adapts cells to grid items while retaining `max_size.width`; the inline layout
-therefore receives a zero-width constraint. This confirms a browser
-compatibility difference. It does not establish a general correction to the
-CSS table-width algorithm, which remains a separate upstream task.
+therefore receives a zero-width constraint.
 
 The resulting tall table exceeds its container's height. Pagination previously
 used line and row ranges beyond the overflow clip; the document end inside a
@@ -73,8 +71,11 @@ glyph bounds with the scene's nested clips. PDF text emission uses the same
 clip bounds to omit fully hidden runs. Regression coverage includes both
 `max-width` values, nested `hidden`/`clip` containers and clipped oversized ink.
 
-The zero-width case now exports, but its column widths still differ from the
-browser. Its test deliberately does not claim that all twelve cells are visible.
+The subsequent [layout patch](layout-regressions.md) separates the intrinsic
+width constraint from the final allocated column width. The zero-width case
+now renders all twelve cells, and the test requires that content for both
+`max-width` values. This fixes the reproduction without replacing the entire
+table width algorithm.
 
 ## Diagnostic distinctions
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitz-pdf",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Render HTML and CSS to PDF with Blitz and WebAssembly in Node.js, Bun, and browsers.",
   "type": "module",
   "license": "MIT",
@@ -15,7 +15,10 @@
   "engines": {
     "node": ">=20"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/worker.js",
+    "./dist/node-worker.js"
+  ],
   "main": "./dist/node.js",
   "module": "./dist/browser.js",
   "types": "./dist/node.d.ts",

package/src/api.ts

@@ -1,44 +1,55 @@
-import loadWasm, { render_pdf, engine_version, RenderJob } from "../wasm/blitz_pdf.js";
+import loadWasm, { engine_version } from "../wasm/blitz_pdf.js";
 import { createAssetLoader } from "./assets.js";
 import { normalizeOptions } from "./options.js";
+import { render, validateHtml } from "./render.js";
+import { compileWasm } from "./wasm.js";
+import { renderInWorker, type SpawnWorker } from "./worker-host.js";
 import type { InitOptions, PdfOptions, WasmSource } from "./types.js";
 
-export function createApi(defaultSource: () => Promise<WasmSource> | WasmSource,
-  prepare: (source: WasmSource) => Promise<WasmSource> = async source => source) {
+export interface ApiConfig {
+  defaultSource: () => Promise<WasmSource> | WasmSource;
+  prepare?: (source: WasmSource) => Promise<WasmSource>;
+  spawnWorker: SpawnWorker;
+}
+
+export function createApi({ defaultSource, prepare = async source => source, spawnWorker }: ApiConfig) {
+  let compiled: Promise<WebAssembly.Module> | undefined;
   let ready: Promise<void> | undefined;
 
+  function compile(source?: WasmSource): Promise<WebAssembly.Module> {
+    if (compiled) return compiled;
+    compiled = (async () => compileWasm(await prepare(source ?? await defaultSource())))()
+      .catch((error: unknown) => { compiled = undefined; throw error; });
+    return compiled;
+  }
+
   /** Initialize once. Concurrent callers share initialization; failed loads can be retried. */
   function init(options: InitOptions = {}): Promise<void> {
     if (ready) return ready;
     ready = (async () => {
-      const source = await prepare(options.wasm ?? await defaultSource());
-      await loadWasm({ module_or_path: source });
+      await loadWasm({ module_or_path: await compile(options.wasm) });
     })().catch((error: unknown) => { ready = undefined; throw error; });
     return ready;
   }
 
+  /** The compiled WASM module, compiled once and shared with every worker. It can be posted to your own workers. */
+  function getWasmModule(): Promise<WebAssembly.Module> { return compile(); }
+
   /** Render HTML/CSS to a vector PDF/A-3u with embedded fonts and selectable text. */
   async function renderPdf(html: string, options: PdfOptions = {}): Promise<Uint8Array> {
-    if (typeof html !== "string") throw new TypeError("html must be a string");
-    if (new TextEncoder().encode(html).byteLength > 16 * 1024 * 1024) throw new RangeError("HTML exceeds the 16 MiB limit");
+    validateHtml(html);
     const { assetResolver, ...normalized } = normalizeOptions(options);
     await init();
-    if (!assetResolver) return render_pdf(html, normalized);
-    const load = createAssetLoader(assetResolver);
-    const job = new RenderJob(html, normalized);
-    try {
-      for (;;) {
-        const urls = job.pending_assets();
-        if (urls.length === 0) return job.finish();
-        const data = await load(urls);
-        for (let i = 0; i < urls.length; i++) job.provide_asset(urls[i]!, data[i]!);
-      }
-    } finally {
-      // In-flight JS loaders never access this job, including after a sibling rejects.
-      job.free();
-    }
+    return render(html, normalized, assetResolver && createAssetLoader(assetResolver));
+  }
+
+  /** Like `renderPdf`, but layout and serialization run in a new worker. An `assets` function still runs on the calling thread. */
+  async function renderPdfInWorker(html: string, options: PdfOptions = {}): Promise<Uint8Array> {
+    validateHtml(html);
+    const { assetResolver, ...normalized } = normalizeOptions(options);
+    return renderInWorker(spawnWorker, await compile(), html, normalized, assetResolver);
   }
 
   async function getEngineVersion(): Promise<string> { await init(); return engine_version(); }
-  return { init, renderPdf, getEngineVersion };
+  return { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion };
 }

package/src/browser.ts

@@ -1,6 +1,16 @@
 import { createApi } from "./api.js";
 
 export type { AssetData, AssetMap, AssetResolver, AttachmentRelationship, BinaryData, InitOptions, Length, PageFormat, PageNumberOptions, PdfAttachment, PdfDate, PdfMetadata, PdfOptions, PdfXmpProperty, PdfXmpSchema, WasmSource } from "./types.js";
-export const { init, renderPdf, getEngineVersion } = createApi(
-  () => new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url),
-);
+export const { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion } = createApi({
+  defaultSource: () => new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url),
+  spawnWorker: events => {
+    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+    worker.onmessage = event => events.message(event.data);
+    worker.onerror = event => {
+      event.preventDefault();
+      events.error(new Error(`Render worker failed: ${event.message || "unknown error"}`));
+    };
+    worker.onmessageerror = () => events.error(new Error("Render worker sent a message that could not be deserialized"));
+    return { post: (message, transfer) => worker.postMessage(message, transfer), terminate: () => worker.terminate() };
+  },
+});

package/src/node-worker.ts

@@ -0,0 +1,9 @@
+import { parentPort } from "node:worker_threads";
+import { serve } from "./worker-runtime.js";
+
+const port = parentPort;
+if (!port) throw new Error("blitz-pdf node-worker must run in a worker thread");
+serve({
+  post: (message, transfer) => port.postMessage(message, transfer),
+  onMessage: handler => { port.on("message", handler); },
+});

package/src/node.ts

@@ -1,12 +1,21 @@
 import { readFile } from "node:fs/promises";
+import { Worker } from "node:worker_threads";
 import { createApi } from "./api.js";
 
 export type { AssetData, AssetMap, AssetResolver, AttachmentRelationship, BinaryData, InitOptions, Length, PageFormat, PageNumberOptions, PdfAttachment, PdfDate, PdfMetadata, PdfOptions, PdfXmpProperty, PdfXmpSchema, WasmSource } from "./types.js";
-export const { init, renderPdf, getEngineVersion } = createApi(
-  () => readFile(new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url)),
-  async source => {
+export const { init, renderPdf, renderPdfInWorker, getWasmModule, getEngineVersion } = createApi({
+  defaultSource: () => readFile(new URL("../wasm/blitz_pdf_bg.wasm", import.meta.url)),
+  prepare: async source => {
     if (source instanceof URL && source.protocol === "file:") return readFile(source);
     if (typeof source === "string" && source.startsWith("file:")) return readFile(new URL(source));
     return source;
   },
-);
+  spawnWorker: events => {
+    const worker = new Worker(new URL("./node-worker.js", import.meta.url));
+    worker.on("message", events.message);
+    worker.on("error", events.error);
+    worker.on("messageerror", events.error);
+    worker.on("exit", code => events.error(new Error(`Render worker exited with code ${code}`)));
+    return { post: (message, transfer) => worker.postMessage(message, transfer), terminate: () => void worker.terminate() };
+  },
+});

package/src/render.ts

@@ -0,0 +1,28 @@
+import { render_pdf, RenderJob } from "../wasm/blitz_pdf.js";
+import type { normalizeOptions } from "./options.js";
+
+/** Normalized options without the resolver function, so they can be posted to a worker. */
+export type RenderOptions = Omit<ReturnType<typeof normalizeOptions>, "assetResolver">;
+export type LoadAssets = (urls: string[]) => Promise<Uint8Array[]>;
+
+export function validateHtml(html: unknown): asserts html is string {
+  if (typeof html !== "string") throw new TypeError("html must be a string");
+  if (new TextEncoder().encode(html).byteLength > 16 * 1024 * 1024) throw new RangeError("HTML exceeds the 16 MiB limit");
+}
+
+/** Requires an initialized WASM instance in the current thread. */
+export async function render(html: string, options: RenderOptions, load?: LoadAssets): Promise<Uint8Array> {
+  if (!load) return render_pdf(html, options);
+  const job = new RenderJob(html, options);
+  try {
+    for (;;) {
+      const urls = job.pending_assets();
+      if (urls.length === 0) return job.finish();
+      const data = await load(urls);
+      for (let i = 0; i < urls.length; i++) job.provide_asset(urls[i]!, data[i]!);
+    }
+  } finally {
+    // In-flight JS loaders never access this job, including after a sibling rejects.
+    job.free();
+  }
+}

package/src/wasm.ts

@@ -0,0 +1,17 @@
+import type { WasmSource } from "./types.js";
+
+export async function compileWasm(source: WasmSource): Promise<WebAssembly.Module> {
+  if (source instanceof WebAssembly.Module) return source;
+  if (typeof source === "string" || source instanceof URL || (typeof Request === "function" && source instanceof Request)) {
+    source = await fetch(source);
+  }
+  if (typeof Response === "function" && source instanceof Response) {
+    if (!source.ok) throw new Error(`Failed to fetch WASM: ${source.status} ${source.statusText} fetching '${source.url}'`);
+    // Streaming compilation rejects other MIME types, so fall back to buffering instead.
+    if (typeof WebAssembly.compileStreaming === "function" && source.headers.get("Content-Type") === "application/wasm") {
+      return WebAssembly.compileStreaming(source);
+    }
+    return WebAssembly.compile(await source.arrayBuffer());
+  }
+  return WebAssembly.compile(source as BufferSource);
+}

package/src/worker-host.ts

@@ -0,0 +1,45 @@
+import { createAssetLoader } from "./assets.js";
+import type { RenderOptions } from "./render.js";
+import type { AssetResolver } from "./types.js";
+import type { HostMessage, WorkerMessage } from "./worker-protocol.js";
+
+export interface WorkerEvents {
+  message(message: WorkerMessage): void;
+  /** Crashes, unreadable messages, or an exit before the render settled. */
+  error(error: unknown): void;
+}
+
+export interface WorkerHandle {
+  post(message: HostMessage, transfer: ArrayBuffer[]): void;
+  terminate(): void;
+}
+
+export type SpawnWorker = (events: WorkerEvents) => WorkerHandle;
+
+/** Renders in a fresh worker that instantiates the precompiled module, then terminates it. */
+export function renderInWorker(spawn: SpawnWorker, module: WebAssembly.Module, html: string,
+  options: RenderOptions, resolver: AssetResolver | undefined): Promise<Uint8Array> {
+  return new Promise<Uint8Array>((resolve, reject) => {
+    const load = resolver && createAssetLoader(resolver);
+    let settled = false;
+    const settle = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      worker.terminate();
+      callback();
+    };
+    const worker: WorkerHandle = spawn({
+      message(message) {
+        if (message.type === "done") settle(() => resolve(message.pdf));
+        else if (message.type === "error") settle(() => reject(message.error));
+        else if (!load) settle(() => reject(new Error("Render worker requested assets without a resolver")));
+        else load(message.urls).then(
+          data => { if (!settled) worker.post({ type: "assets", data }, data.map(bytes => bytes.buffer as ArrayBuffer)); },
+          (error: unknown) => settle(() => reject(error)),
+        );
+      },
+      error(error) { settle(() => reject(error)); },
+    });
+    worker.post({ type: "render", module, html, options, external: load !== undefined }, []);
+  });
+}

package/src/worker-protocol.ts

@@ -0,0 +1,10 @@
+import type { RenderOptions } from "./render.js";
+
+export type HostMessage =
+  | { type: "render"; module: WebAssembly.Module; html: string; options: RenderOptions; external: boolean }
+  | { type: "assets"; data: Uint8Array[] };
+
+export type WorkerMessage =
+  | { type: "assets"; urls: string[] }
+  | { type: "done"; pdf: Uint8Array }
+  | { type: "error"; error: unknown };

package/src/worker-runtime.ts

@@ -0,0 +1,35 @@
+import { initSync } from "../wasm/blitz_pdf.js";
+import { render } from "./render.js";
+import type { HostMessage, WorkerMessage } from "./worker-protocol.js";
+
+export interface WorkerEndpoint {
+  post(message: WorkerMessage, transfer: ArrayBuffer[]): void;
+  onMessage(handler: (message: HostMessage) => void): void;
+}
+
+/** Worker side of `renderPdfInWorker`: one render per worker; asset bytes come from the host. */
+export function serve(endpoint: WorkerEndpoint): void {
+  let receiveAssets: ((data: Uint8Array[]) => void) | undefined;
+  endpoint.onMessage(async message => {
+    if (message.type === "assets") {
+      const receive = receiveAssets;
+      receiveAssets = undefined;
+      receive?.(message.data);
+      return;
+    }
+    try {
+      initSync({ module: message.module });
+      const load = message.external
+        ? (urls: string[]) => new Promise<Uint8Array[]>(resolve => {
+          receiveAssets = resolve;
+          endpoint.post({ type: "assets", urls }, []);
+        })
+        : undefined;
+      const pdf = await render(message.html, message.options, load);
+      endpoint.post({ type: "done", pdf }, [pdf.buffer as ArrayBuffer]);
+    } catch (error) {
+      try { endpoint.post({ type: "error", error }, []); }
+      catch { endpoint.post({ type: "error", error: new Error(String(error)) }, []); }
+    }
+  });
+}

package/src/worker.ts

@@ -0,0 +1,12 @@
+import { serve } from "./worker-runtime.js";
+
+interface DedicatedWorkerScope {
+  postMessage(message: unknown, transfer: Transferable[]): void;
+  onmessage: ((event: MessageEvent) => void) | null;
+}
+
+const scope = globalThis as unknown as DedicatedWorkerScope;
+serve({
+  post: (message, transfer) => scope.postMessage(message, transfer),
+  onMessage: handler => { scope.onmessage = event => handler(event.data); },
+});

package/vendor/README.md

@@ -40,3 +40,38 @@ No invoice-specific behavior is added to the engine or public API.
 
 When upgrading Krilla, review this patch and run `tests/document.test.ts`, the
 Node/browser checks, and `npm run test:pdfa` against the rebuilt WASM.
+
+# Blitz print layout patch
+
+`blitz-dom/` contains `packages/blitz-dom` from Blitz revision
+`e72650a6e67941852fddf025295cfee30c39ea32`, with its MIT/Apache-2.0 licenses.
+Its standalone manifest expands the upstream workspace dependencies and pins
+the sibling Blitz crates to the same revision.
+
+- `config.rs`, `document.rs`, `stylo_device.rs`, `iframe.rs`, `resolve.rs`, and
+  `layout/writing_mode.rs`: provide an optional fractional CSS viewport and
+  optional layout rounding. Defaults preserve the upstream window behavior.
+  The PDF body and margin templates disable rounding and supply the exact
+  printable dimensions, including after CSS page setup changes them. Layout,
+  transforms, painting, and pagination share the resulting geometry.
+- `layout/construct.rs`: use baseline alignment for the root of an inline
+  formatting context. A table cell's `vertical-align: middle` aligns the cell
+  content within its row; applying it again to its own text inflated every line.
+  Descendant inline alignment and the cell's placement remain intact.
+- `layout/inline.rs`: let empty inline contexts compute their size and margin
+  collapse normally. The empty-text shortcut prevented margins from collapsing
+  through paragraphs containing empty spans and discarded explicit heights.
+- `layout/table.rs`: keep `max-width` as an intrinsic measurement constraint,
+  while allowing the final cell layout to use the width allocated by the grid.
+  Generate anonymous row/cell wrappers around improper table children, including
+  block content in a `display: table` container. `layout/construct.rs` creates
+  the wrappers without altering the DOM; `layout/damage.rs` retains their roles
+  and inherited styles when refreshing them. Ownership tracking frees them on
+  reconstruction.
+
+When upgrading Blitz, review these changes against upstream and run
+`tests/layout.test.ts`, `tests/pagination.test.ts`, and `tests/reports.test.ts`
+against rebuilt WASM. Layout tests check physical margins, fractional viewport
+widths, header/footer geometry, table line spacing, descendant alignment, empty
+paragraphs, explicit empty-box dimensions, exact page-boundary fits, constrained
+table columns, anonymous cells, and inheritance after CSS page-size changes.

package/vendor/blitz-dom/Cargo.toml

@@ -0,0 +1,113 @@
+[package]
+name = "blitz-dom"
+description = "Blitz DOM implementation"
+documentation = "https://docs.rs/blitz-dom"
+version = "0.3.0-beta.3"
+license = "MIT OR Apache-2.0"
+homepage = "https://github.com/dioxuslabs/blitz"
+repository = "https://github.com/dioxuslabs/blitz"
+categories = ["gui"]
+edition = "2024"
+rust-version = "1.91.0"
+
+[features]
+default = [
+    "svg",
+    "woff",
+    "accessibility",
+    "system-fonts",
+    "file-input",
+    "custom-widget",
+    "text-transform-icu"
+]
+custom-widget = ["dep:anyrender", "accessibility"]
+tracing = ["dep:tracing"]
+svg = ["dep:usvg", "dep:svgtypes"]
+# WOFF decoding (using the "wuff" crate which is pure Rust)
+woff = ["dep:wuff"]
+accessibility = ["accesskit"]
+system-fonts = ["parley/system"]
+# complex-scripts: enable dictionary-based line-breaking
+complex-scripts = ["parley/complex-scripts"]
+# text-transform-icu: language-aware, Unicode-complete case mapping for `text-transform`
+# (otherwise falls back to the standard library's case mapping)
+text-transform-icu = ["dep:icu_casemap", "dep:writeable"]
+autofocus = []
+floats = ["taffy/float_layout", "stylo_taffy/floats"]
+# CSS vertical `writing-mode` support (layout runs in each box's writing-mode frame; see layout/writing_mode.rs)
+writing-mode = ["stylo_taffy/writing-mode"]
+file-input = []
+# Overlay-scrollbar thumb interaction (drag + hover tracking). Normally
+# enabled through `blitz-paint/scrollbars`, which paints the thumbs.
+scrollbars = []
+parallel-construct = []
+log-phase-times = ["debug_timer/enable"]
+
+[dependencies]
+# Blitz dependencies
+blitz-traits = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
+stylo_taffy = { version = "=0.3.0-beta.3", default-features = false, git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32", features = ["default"] }
+debug_timer = { version = "0.1.2", git = "https://github.com/DioxusLabs/blitz", rev = "e72650a6e67941852fddf025295cfee30c39ea32" }
+
+# Servo dependencies
+style = { version = "0.22.0", package = "stylo" }
+selectors = { version = "0.41.0", package = "selectors" }
+cssparser = { version = "0.38.0" }
+style_config = { version = "0.22.0", package = "stylo_static_prefs" }
+style_traits = { version = "0.22.0", package = "stylo_traits" }
+style_dom = { version = "0.22.0", package = "stylo_dom" }
+app_units = { version = "0.7.5" }
+euclid = { version = "0.22" }
+atomic_refcell = { version = "0.1.13" }
+markup5ever = { version = "0.40.0" }
+smallvec = { version = "1" }
+thin-vec = { version = "0.2" }
+
+# DioxusLabs dependencies
+taffy = { git = "https://github.com/DioxusLabs/taffy", rev = "6c2106e3df79493d304f954dc2cd4a4a382981d3", default-features = false, features = ["std", "flexbox", "flexbox_balance", "grid", "block_layout", "content_size", "calc", "detailed_layout_info"] }
+anyrender = { version = "0.14.0", optional = true }
+
+# Linebender/Fontations dependencies
+accesskit = { version = "0.25", optional = true }
+parley = { version = "0.12", default-features = false, features = ["std"] }
+skrifa = { version = "0.44", default-features = false, features = ["std"] }
+linebender_resource_handle = { version = "0.1" }
+color = { version = "0.3" }
+kurbo = { version = "0.13.1" }
+
+# Unicode
+icu_casemap = { version = "2.3", default-features = false, features = ["compiled_data"], optional = true }
+icu_locale_core = { version = "2.3", default-features = false }
+icu_properties = { version = "2.3", default-features = false, features = ["compiled_data"] }
+icu_segmenter = { version = "2.3", default-features = false, features = ["compiled_data"] }
+writeable = { version = "0.6", default-features = false, optional = true }
+
+# Other dependencies
+slotmap = { version = "1.0.7" }
+bitflags = { version = "2.8.0" }
+tracing = { version = "0.1.40", optional = true }
+rayon = { version = "1" }
+
+# Media & Decoding
+image = { version = "0.25.6", default-features = false }
+usvg = { version = "0.48.1", optional = true }
+svgtypes = { version = "0.16.1", optional = true }
+wuff = { version = "0.2", optional = true }
+html-escape = { version = "0.2.13" }
+percent-encoding = { version = "2.3.1" }
+
+# IO & Networking
+url = { version = "2.5.0" }
+
+# Input
+keyboard-types = { version = "0.7" }
+cursor-icon = { version = "1" }
+thread_local = { version = "1" }
+
+# WASM
+web-time = { version = "1" }
+
+# HACK: Blitz doesn't need to depend on objc2 directly. But this feature flag is necessary
+# to prevent debug builds from panicking.
+[target.'cfg(any(target_vendor = "apple"))'.dependencies]
+objc2 = { version = "0.6", features = ["disable-encoding-assertions"] }