@openpresentation/opf-render 0.20.0 → 0.20.4

package/README.md

@@ -1,6 +1,6 @@
 # OPF Render
 
-**OPF 0.18 (RR-73, RR-74, unreleased; requires core 0.18).** One shape for every engine: `toX(deck, slides?, options?)`. The second argument is a slide number (one result), a selection (`"1-3"`, `"1,3-5"`, `"2-"`, `[1, 3]`; a list of results) or the options, told apart by type, and slides count from 1. Renamed and removed outright (no aliases); an old option fails with `invalid-render-options` or `invalid-conversion-option` and names its replacement:
+**OPF 0.18 (RR-73, RR-74; requires core 0.18).** One shape for every engine: `toX(deck, slides?, options?)`. The second argument is a slide number (one result), a selection (`"1-3"`, `"1,3-5"`, `"2-"`, `[1, 3]`; a list of results) or the options, told apart by type, and slides count from 1. Renamed and removed outright (no aliases); an old option fails with `invalid-render-options` or `invalid-conversion-option` and names its replacement:
 
 | 0.17 | 0.18 |
 | --- | --- |
@@ -12,14 +12,14 @@
 | `mode: "raster"` | `raster: true` (vector is the default) |
 | `fontDirs` | `fonts`: the handle, or font folders (a path or a list) for SVG input |
 
-**OPF 0.15 (FA-23, unreleased; requires core 0.15).** Catalogs are registered by the host, and every picture is an image background or an image block. The breaking changes are listed in `changes/fa-23-opf-0-15.md` (the next CHANGELOG section); the [0.15 design](https://github.com/OpenPresentation/opf/blob/main/docs/programs/format-audit/0.15-design.md) explains them.
+**OPF 0.15 (FA-23; requires core 0.15).** Catalogs are registered by the host, and every picture is an image background or an image block. The breaking changes are recorded in [CHANGELOG.md](CHANGELOG.md); the [0.15 design](https://github.com/OpenPresentation/opf/blob/main/docs/programs/format-audit/0.15-design.md) explains them.
 
 - The renderer bundles, looks up and fetches no catalog. Every entry point (`toSvg`, `resolvePresentation`, the font loaders' `renderOptions`, `/player`, `<opf-deck>`) takes core's `catalogs: Catalog[]` and passes it unchanged to core resolution. Register the gallery snapshot yourself: `import { gallery } from '@openpresentation/gallery'` and `toSvg(deck, { catalogs: [gallery] })`. `strictReferences: true` fails with `unresolved-reference` instead of falling back.
 - What resolves nowhere draws with core's engine defaults (`engineDefaults` is `{ theme, colorScheme, fontScheme, chartType }`: core's `ENGINE_DEFAULT_THEME`, `ENGINE_DEFAULT_COLOR_SCHEME`, `ENGINE_DEFAULT_FONT_SCHEME`) and is reported once per reference as `unresolved-reference`.
 - An image background (`design.background: { type: "image", src, alt, fit, focus, opacity, recolor, overlay }`, or an image source string) draws from core's `geometry.backgroundImage`: the canvas colour, the picture (cover, contain, stretch or tile; recolor and opacity on the pixels only), then the overlay (the whole slide or an edge band). `alt` is the picture's accessible name; without it the picture is decorative.
 - Every content picture is an image block drawn from `item.image`: frame, fit (`cover`, `contain`, `stretch`; default `design.imageFit`, else `cover`), focus, shape mask, border, opacity, recolor and overlay, and a placed block (`placement`) at its edge band.
 
-**Lighter install (RR-63, unreleased, 0.16.0).** `pdf-lib`, `@resvg/resvg-js`, `sharp` and every `@expo-google-fonts/*` font package are optional peer dependencies, loaded on first use: an SVG-only install holds none of them. Add what you export (see [Install](#install-what-to-add-for-what-rr-63)); a missing converter rejects with `converter-missing`. New `/png` and `/pdf` entries beside `/svg`. Rendered output is unchanged.
+**Lighter install (RR-63, 0.16.0).** `pdf-lib`, `@resvg/resvg-js`, `sharp` and every `@expo-google-fonts/*` font package are optional peer dependencies, loaded on first use: an SVG-only install holds none of them. Add what you export (see [Install](#install-what-to-add-for-what-rr-63)); a missing converter rejects with `converter-missing`. New `/png` and `/pdf` entries beside `/svg`. Rendered output is unchanged.
 
 **0.14.0 (RR-55, with core 0.14.0, opf-pptx 0.14.0 and opf-editor 0.14.0).** One fonts handle, whole-deck and one-slide render functions, and core's slide context. This release renames and deletes outright (no aliases; the CHANGELOG has the old-to-new table):
 
@@ -193,7 +193,7 @@ Installed size, measured on Windows with `npm install --ignore-scripts`, unpacke
 - Public API: `toSvg(opf, slides?, opts)` (every slide, one slide or a selection), `resolvePresentation(opf, opts)`, `toPng(opf or svg, slides?, opts)`, `toPdf(opf or svgs, slides?, opts)` and `loadFonts(opts)` (`/fonts-node`, `/fonts-browser`)
 - Player and embedding (RR-28): `<opf-deck>` and a slideshow with a speaker view, see [Player and `<opf-deck>`](#player-and-opf-deck-rr-28)
 
-`toSvg(deck)` returns one SVG string per slide (`skipHidden: true` leaves out slides marked `hidden`, the player's sequence, so the result is then shorter than the deck); `toSvg(deck, 3)` returns the SVG of the third slide (slides count from 1; out of range throws `slide-out-of-range`), and `toSvg(deck, "1-3")` or `toSvg(deck, [1, 3])` the selected slides, hidden or not (`invalid-slide-selection` for a malformed one). Every form checks the format at the boundary (core `validate(deck, { only: ['format'] })`; a failure throws `OPFRenderError` `invalid-opf` whose `findings` are the error findings), resolve references from the document's embedded records and the host's `catalogs` (core `Catalog[]`, never fetched), and emit byte-stable SVG for the same input. With a `fonts` handle, each SVG embeds as `@font-face` data only the faces of `embeddedFonts` that its own text draws (by family, weight and style; a face flagged `embed: "always"` goes into every SVG), so the handle is safe to pass to every preview: over the 127 core example decks, an office-pack slide carries 2.4 MB on average (4.1 MB at most) instead of every eager face (15 MB), a base-pack slide 0.53 MB instead of 1.76 MB. Each embedded face is also cut to the glyphs the slide draws (RR-65): the Node handle (and a browser handle given `subsetWasm`, the URL of `harfbuzzjs/dist/harfbuzz-subset.wasm` the host serves, or its bytes or compiled module) subsets each face with HarfBuzz's own subsetter (hb-subset from the pinned harfbuzzjs, MIT), keeping every layout feature, so the browser shapes and draws it exactly like the whole face (147 example slides with 384 embedded faces are pixel-identical in a browser) and the bytes are the same for the same slide. Over the 127 core example decks an office-pack slide falls from 2.4 MB to 59 KB on average (2.85 MB to 59 KB at the median, 1.95 GB to 48 MB for all 807 slides), a base-pack slide from 530 KB to 73 KB. Only a face whose license allows a modified version is cut: a bundled face (by sha256 against the pinned manifest) under a permitted license whose family and file names do not contain a Reserved Font Name of its package (a subset is a modified version, owner decision 2026-09-29) and whose OS/2 fsType allows subsetting; Carlito, Raleway, Lora, Playfair Display, PT Serif, Merriweather Sans, Source Sans 3 and every face a host supplies are embedded whole. `subsetFonts: false` embeds whole faces (for an SVG whose text will be edited outside the renderer). A face whose OS/2 fsType forbids embedding (Restricted License 0x0002, or bitmap-only 0x0200, since an SVG carries outlines) is never embedded (RR-76): the SVG names its family without the data, so a viewer without the font draws the generic family, and a `font-embedding-restricted` diagnostic lists the faces left out. `renderDeckHtml` with `fontMode: "shared"` embeds each face once for the page, cut to the characters all of its slides draw (a three-slide Roboto page: 53 KB, against 101 KB with per-slide subsets and 442 KB with whole shared faces). `text: "system"` writes no `@font-face` data at all (the handle still measures), for a browser host whose `loadFonts` handle already added the faces to the page; keep the default where an SVG must stand alone (a file, the browser PDF export). Slide background colours (solid, gradient stops, pattern colours) accept the same colour references as text and table colours: a hex value, a `var:` variable, or a colour scheme slot or role such as `accent2` or `primary`.
+`toSvg(deck)` returns one SVG string per slide (`skipHidden: true` leaves out slides marked `hidden`, the player's sequence, so the result is then shorter than the deck); `toSvg(deck, 3)` returns the SVG of the third slide (slides count from 1; out of range throws `slide-out-of-range`), and `toSvg(deck, "1-3")` or `toSvg(deck, [1, 3])` the selected slides, hidden or not (`invalid-slide-selection` for a malformed one). Every form checks the format at the boundary (core `validate(deck, { only: ['format'] })`; a failure throws `OPFRenderError` `invalid-opf` whose `findings` are the error findings), resolve references from the document's embedded records and the host's `catalogs` (core `Catalog[]`, never fetched), and emit byte-stable SVG for the same input. With a `fonts` handle, each SVG embeds as `@font-face` data only the faces of `embeddedFonts` that its own text draws (by family, weight and style; a face flagged `embed: "always"` goes into every SVG), so the handle is safe to pass to every preview: over the 127 core example decks, an office-pack slide carries 2.4 MB on average (4.1 MB at most) instead of every eager face (15 MB), a base-pack slide 0.53 MB instead of 1.76 MB. Each embedded face is also cut to the glyphs the slide draws (RR-65): the Node handle (and a browser handle given `subsetWasm`, the URL of `harfbuzzjs/dist/harfbuzz-subset.wasm` the host serves, or its bytes or compiled module) subsets each face with HarfBuzz's own subsetter (hb-subset from the pinned harfbuzzjs, MIT), keeping every layout feature, so the browser shapes and draws it exactly like the whole face (147 example slides with 384 embedded faces are pixel-identical in a browser) and the bytes are the same for the same slide. Over the 127 core example decks an office-pack slide falls from 2.4 MB to 59 KB on average (2.85 MB to 59 KB at the median, 1.95 GB to 48 MB for all 807 slides), a base-pack slide from 530 KB to 73 KB. Only a face whose license allows a modified version is cut: a bundled face (by sha256 against the pinned manifest) under a permitted license whose family and file names do not contain a Reserved Font Name of its package (a subset is a modified version, owner decision 2026-09-29) and whose OS/2 fsType allows subsetting; Carlito, Raleway, Lora, Playfair Display, PT Serif, Merriweather Sans, Source Sans 3 and every face a host supplies are embedded whole. `subsetFonts: false` embeds whole faces (for an SVG whose text will be edited outside the renderer). A face whose OS/2 fsType forbids embedding (Restricted License 0x0002, or bitmap-only 0x0200, since an SVG carries outlines) is never embedded (RR-76): the SVG names its family without the data, so a viewer without the font draws the generic family, and a `font-embedding-restricted` diagnostic lists the faces left out. `toHtml` with `fontMode: "shared"` embeds each face once for the page, cut to the characters all of its slides draw (a three-slide Roboto page: 53 KB, against 101 KB with per-slide subsets and 442 KB with whole shared faces). `text: "system"` writes no `@font-face` data at all (the handle still measures), for a browser host whose `loadFonts` handle already added the faces to the page; keep the default where an SVG must stand alone (a file, the browser PDF export). Slide background colours (solid, gradient stops, pattern colours) accept the same colour references as text and table colours: a hex value, a `var:` variable, or a colour scheme slot or role such as `accent2` or `primary`.
 
 Accessibility of the SVG (FA-30): the slide root is a labelled container, `role="group"` with `aria-roledescription="slide"` and `aria-label` set to the slide title, never `role="img"`, which would make every text node inside presentational. Titles, body text, list entries, quotes, metrics, table cells, captions, footnotes and header or footer text stay live text a screen reader reaches, in the order the renderer paints them. Purely decorative drawing (the background and its overlay, card frames, table cell fills and borders, dividers, timeline markers, watermarks, and an image whose `alt` is `""`) carries `aria-hidden="true"`. A picture with `alt` is `role="img"` with that label (a header or footer picture without `alt` is hidden); a chart with `alt` is a `role="img"` group, and one with `alt: ""` is hidden. `<opf-deck>`, the player and `toHtml` remove the root's `role`, `aria-roledescription` and `aria-label` (the slide section or figure around the drawing carries the one name), so a slide is announced once (not tested with assistive technology; see Accessibility under `<opf-deck>`).
 
@@ -263,7 +263,7 @@ const pdf = await toPdf(svgs, { fonts });
 
 ```js
 const pdf = await toPdf(svgs, {
-  fontFiles: fonts.fontFiles, useBundledFonts: false,
+  fonts,
   metadata: { title: "Quarterly review", author: "Finance", language: "en-GB" },
   onDiagnostic: (d) => d.code === "pdf-raster-fallback" && console.warn(d.path, d.reason),
 });

package/dist/charts.js

@@ -858,7 +858,7 @@ function drawLines(c, spec, series, stacks, { plot, band, at, categorySlot = (i)
   }
   // RR-35: data labels sit beside each point, over every line.
   if (c.dataLabels) series.forEach((s, j) => stacks[j].forEach((point, i) => {
-    if (point) drawPointLabel(c, labelString(c, { category: c.rows[i][0] === null || c.rows[i][0] === undefined ? "" : String(c.rows[i][0]), value: s.values[i], format: s.format }), [plot.x + (i + 0.5) * band, at(point.to)], `${c.path}.data.rows.${i}.${s.column}`);
+    if (point) drawPointLabel(c, labelString(c, { category: c.rows[i][0] === null || c.rows[i][0] === undefined ? "" : String(c.rows[i][0]), value: s.values[i], format: s.format }), [plot.x + (categorySlot(i) + 0.5) * band, at(point.to)], `${c.path}.data.rows.${i}.${s.column}`);
   }));
 }
 
@@ -874,7 +874,7 @@ function drawAreas(c, series, stacks, { plot, band, at, crossing, categorySlot =
   if (c.dataLabels) series.forEach((s, j) => stacks[j].forEach((point, i) => {
     if (!point) return;
     const lowerEdge = point.from === 0 ? crossing : at(point.from);
-    drawCenteredLabel(c, labelString(c, { category: c.rows[i][0] === null || c.rows[i][0] === undefined ? "" : String(c.rows[i][0]), value: s.values[i], format: s.format }), plot.x + (i + 0.5) * band, (lowerEdge + at(point.to)) / 2, `${c.path}.data.rows.${i}.${s.column}`, seriesColor(c, j));
+    drawCenteredLabel(c, labelString(c, { category: c.rows[i][0] === null || c.rows[i][0] === undefined ? "" : String(c.rows[i][0]), value: s.values[i], format: s.format }), plot.x + (categorySlot(i) + 0.5) * band, (lowerEdge + at(point.to)) / 2, `${c.path}.data.rows.${i}.${s.column}`, seriesColor(c, j));
   }));
 }
 
@@ -1481,7 +1481,7 @@ function renderTreemapChart(c) {
  * values and clamps to the extremes, whiskers reach the furthest values within
  * 1.5 IQR of the box, and values beyond are outliers.
  */
-export function boxStatistics(values) {
+export function boxStatistics(values, path = "chart") {
   const sorted = values.filter((value) => value !== null && Number.isFinite(value)).sort((a, b) => a - b);
   const n = sorted.length;
   if (!n) return null;
@@ -1494,8 +1494,9 @@ export function boxStatistics(values) {
   };
   const q1 = quantile(0.25), median = quantile(0.5), q3 = quantile(0.75);
   const iqr = q3 - q1;
-  const inside = sorted.filter((value) => value >= q1 - 1.5 * iqr && value <= q3 + 1.5 * iqr);
   const mean = sorted.reduce((sum, value) => sum + value, 0) / n;
+  if (![q1, median, q3, iqr, mean].every(Number.isFinite)) throw chartAggregateError(path, "box statistics");
+  const inside = sorted.filter((value) => value >= q1 - 1.5 * iqr && value <= q3 + 1.5 * iqr);
   return { q1, median, q3, mean, low: inside[0] ?? q1, high: inside[inside.length - 1] ?? q3, outliers: sorted.filter((value) => value < q1 - 1.5 * iqr || value > q3 + 1.5 * iqr) };
 }
 
@@ -1512,7 +1513,7 @@ function renderBoxWhiskerChart(c) {
     if (!group) groups.push(group = { name, first: i, rows: [] });
     group.rows.push(i);
   });
-  const boxes = series.map((s) => groups.map((group) => ({ stats: boxStatistics(group.rows.map((i) => s.values[i])), rows: group.rows })));
+  const boxes = series.map((s) => groups.map((group) => ({ stats: boxStatistics(group.rows.map((i) => s.values[i]), c.path), rows: group.rows })));
   const all = boxes.flat().flatMap((entry) => entry.stats ? [entry.stats.low, entry.stats.high, ...entry.stats.outliers] : []);
   const dataMin = all.length ? Math.min(...all) : 0, dataMax = all.length ? Math.max(...all) : 1;
   const legendWidth = seriesLegend(c, series);
@@ -1569,7 +1570,7 @@ function renderRegionMapChart(c) {
   const light = mixHex(/^#[0-9A-Fa-f]{6}$/.test(c.surface) ? c.surface : "#FFFFFF", c.colors[0], 0.15);
   categories.forEach((name, i) => {
     const value = values[i];
-    const t = value === null ? 0 : max > min ? (value - min) / (max - min) : 1;
+    const t = value === null ? 0 : max > min ? axisFraction(value, {min, max}) : 1;
     const x = area.x + (i % columns) * tileWidth, y = area.y + Math.floor(i / columns) * tileHeight;
     c.mark("rect", { x, y, width: tileWidth, height: tileHeight, fill: value === null ? c.surface : mixHex(light, c.colors[0], t), stroke: "#FFFFFF", "stroke-width": c.pt }, `${c.path}.data.rows.${i}.${column}`);
     const inset = { x: x + fontPx * 0.25, width: Math.max(1, tileWidth - fontPx * 0.5) };

package/dist/fonts-browser.js

@@ -25,7 +25,7 @@ async function verifyDigest(entry, data, subtle) {
 }
 
 // The registry behind `loadFonts`: fetch only host-selected font files, then use those exact bytes for shaping and CSS.
-async function loadRegistry(entries, options = {}) {
+async function loadRegistry(entries, options = {}, startup = {}) {
   // Validate the host's extra faces first: a bad list must not leave startup faces registered in the document with no registry to dispose.
   const extraLazy = normalizeExtraLazyFonts(options.extraLazyFonts);
   const documentRef = options.document ?? globalThis.document;
@@ -63,6 +63,12 @@ async function loadRegistry(entries, options = {}) {
   const faces = await fetchFaces(entries, options.signal);
   const registry = createFontRegistry(faces, options),
     loaded = [];
+  let disposed = startup.failed === true;
+  const dispose = () => {
+    disposed = true;
+    for (const face of loaded) documentRef.fonts.delete(face);
+  };
+  startup.dispose = dispose;
   // Normalize family names using the registry's parsed font metadata.
   const described = registry.describeFaces();
   // Registers browser FontFaces for faces already parsed by the registry; on failure nothing stays registered.
@@ -84,19 +90,21 @@ async function loadRegistry(entries, options = {}) {
           added.push(face);
         }),
       );
+      if (disposed) throw new OPFFontError("font-registry-disposed", "The font registry was disposed.");
+      loaded.push(...added);
       for (const face of added) documentRef.fonts.add(face);
       await documentRef.fonts.ready;
+      if (disposed) throw new OPFFontError("font-registry-disposed", "The font registry was disposed.");
     } catch (error) {
       for (const face of added) documentRef.fonts.delete(face);
       throw new OPFFontError("font-load-failed", error.message);
     }
-    loaded.push(...added);
   };
   await registerBrowserFaces(faces, described);
 
   // Script faces (FF-19) are loaded lazily, once a document needs them, and only for the scripts it uses.
   const scriptPackages = new Set();
-  let queue = Promise.resolve(), disposed = false;
+  let queue = Promise.resolve();
   // FF-41: the `toSvg` options a document resolves with (`catalogs`, ...). `options.renderOptions` are the defaults; a call's own
   // options (everything but `signal`) are added over them, so a host that passes its canvas options gets the same resolution here.
   const renderOptionsFor = (callOptions) => { const { signal: _signal, ...own } = callOptions ?? {}; return { ...options.renderOptions, ...own }; };
@@ -264,12 +272,7 @@ async function loadRegistry(entries, options = {}) {
     for (const face of loaded) documentRef.fonts.delete(face);
     throw error;
   }
-  return Object.assign(registry, {
-    dispose() {
-      disposed = true;
-      for (const face of loaded) documentRef.fonts.delete(face);
-    },
-  });
+  return Object.assign(registry, { dispose });
 }
 
 const MAX_ENSURE_ROUNDS = 4;
@@ -306,8 +309,19 @@ async function fetchWasm(source, fetchImpl, signal, name) {
 }
 
 export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options } = {}) {
-  const [registry, subsetter, shaper] = await Promise.all([loadRegistry(faces, options), subsetWasm === undefined ? null : browserSubsetter(subsetWasm, options.fetch, options.signal),
-    shapeWasm === undefined ? null : browserShaper(shapeWasm, options.fetch, options.signal)]);
+  // A sibling WASM failure must reject promptly even if a host font request/ready promise
+  // never settles. The private startup guard removes registered faces now and prevents
+  // any pending face load from registering later; successful startup stays parallel.
+  const startup = {};
+  let registry, subsetter, shaper;
+  try {
+    [registry, subsetter, shaper] = await Promise.all([loadRegistry(faces, options, startup), subsetWasm === undefined ? null : browserSubsetter(subsetWasm, options.fetch, options.signal),
+      shapeWasm === undefined ? null : browserShaper(shapeWasm, options.fetch, options.signal)]);
+  } catch (error) {
+    startup.failed = true;
+    startup.dispose?.();
+    throw error;
+  }
   // The embedded list is base64 of every eager face: compute it once, and again only when faces were added.
   let embedded, stale = true;
   const addFaces = registry.addFaces;

package/dist/fonts-node.js

@@ -283,6 +283,9 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
   const selectEmbedded = () => registry.selectEmbeddedFonts(face => embedScriptFonts || !face.scripts || face.fallbackOnly);
   // The embedded list is base64 of every face: computed on first use, and again after `ensure` added faces.
   let embeddedFonts, fontFiles = [...registry.fontFiles];
+  // Calls mutate one registry: serialize their reads/additions, while returning each
+  // call's own result or error. A rejection must not poison later preparation.
+  let ensureQueue = Promise.resolve();
   const refresh = () => { embeddedFonts = undefined; fontFiles = [...registry.fontFiles]; };
   const [subsetter, shaper] = await Promise.all([nodeHarfbuzz("subsets"), nodeHarfbuzz("shaper")]);
   for (const [kind, engine] of [["subsets", subsetter], ["shaper", shaper]]) if (!engine) {
@@ -303,9 +306,13 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
     manifest: BUNDLED_FONT_MANIFEST,
     get substitutions() { return registry.substitutions; },
     /** Load the script faces the presentation's text needs (see `ensureFonts`); `embeddedFonts` and `fontFiles` then include them. */
-    async ensure(presentation, callOptions = {}) {
-      const result = await ensureFonts(registry, loaded, presentation, {onDiagnostic: callOptions.onDiagnostic ?? options.onDiagnostic, renderOptions: {...options.renderOptions, ...callOptions.renderOptions}});
-      refresh();
+    ensure(presentation, callOptions = {}) {
+      const result = ensureQueue.then(async () => {
+        const prepared = await ensureFonts(registry, loaded, presentation, {onDiagnostic: callOptions.onDiagnostic ?? options.onDiagnostic, renderOptions: {...options.renderOptions, ...callOptions.renderOptions}});
+        refresh();
+        return prepared;
+      });
+      ensureQueue = result.catch(() => {});
       return result;
     },
     /** Synchronous: the script packages the presentation needs that are not loaded yet. Empty means `ensure` loads nothing. */

package/dist/index.d.ts

@@ -27,6 +27,17 @@ export declare const engineDefaults: Readonly<{
 }>;
 
 export type RenderDiagnostic = LayoutDiagnostic | {
+  /** A run stays text because its face cannot safely be written as outlines. */
+  code: "text-as-paths-fallback";
+  reason: "colour-font" | "restricted" | "shaping";
+  fontFamily: string;
+  message: string;
+} | {
+  /** Faces omitted from the SVG because their OS/2 fsType restricts embedding. */
+  code: "font-embedding-restricted";
+  faces: { fontFamily: string; weight: number; italic: boolean; fsType: number }[];
+  message: string;
+} | {
   /** A face lacked glyphs for the text; a bundled fallback face draws them in the preview. A note, not an error. */
   code: "font-glyph-fallback";
   path?: string;

package/dist/pdf-vector.js

@@ -738,6 +738,24 @@ class Converter {
   // Text
 
   async text(node, attrs, ctx) {
+    // Relative per-character positions need cumulative SVG text layout across
+    // chunks, anchors and bidi runs. Do not silently approximate that as run dx.
+    const pending = [node];
+    while (pending.length) {
+      const current = pending.pop();
+      const own = attributesOf(current);
+      for (const attribute of ["dx", "dy"]) {
+        if (own[attribute] === undefined) continue;
+        const value = String(own[attribute]).trim();
+        const values = value.split(/\s*,\s*|\s+/);
+        if (values.length && values.every(item => parseLength(item, { reference: 1 }) === 0)) continue;
+        const mark = `${attribute}=${value}`;
+        if (ctx.page.reportedAttributes.has(mark)) continue;
+        ctx.page.reportedAttributes.add(mark);
+        this.unsupported("pdf-unsupported-feature", `${attribute}="${value.slice(0, 40)}" on <${current.name}> is not drawn in the vector PDF; relative text positioning is unsupported.`, { path: current.attrs["data-opf-path"], element: current.name, attribute });
+      }
+      for (const child of current.children) if (["tspan", "textPath", "tref", "a"].includes(child.name)) pending.push(child);
+    }
     const { runs } = layoutText(node, this.env, ctx.parentStyle, ctx.link);
     if (!runs.length) return;
     for (const run of runs) {

package/dist/svg.d.ts

@@ -27,6 +27,17 @@ export declare const engineDefaults: Readonly<{
 }>;
 
 export type RenderDiagnostic = LayoutDiagnostic | {
+  /** A run stays text because its face cannot safely be written as outlines. */
+  code: "text-as-paths-fallback";
+  reason: "colour-font" | "restricted" | "shaping";
+  fontFamily: string;
+  message: string;
+} | {
+  /** Faces omitted from the SVG because their OS/2 fsType restricts embedding. */
+  code: "font-embedding-restricted";
+  faces: { fontFamily: string; weight: number; italic: boolean; fsType: number }[];
+  message: string;
+} | {
   /** A face lacked glyphs for the text; a bundled fallback face draws them in the preview. A note, not an error. */
   code: "font-glyph-fallback";
   path?: string;

package/dist/svg.js

@@ -1962,6 +1962,7 @@ function trimRichLineEdges(line,textMeasurement) {
 }
 
 function renderRichLines(value,fit,box,bound,config) {
+  for (const run of value) assertXmlText(typeof run === 'string' ? run : run.text, config.path);
   const logicalAlignment=fit.placement?.alignment??config.align??bound.geometry.design.contentAlignment;
   // Each line takes its paragraph's direction from core (every wrapped line shares it) and its physical edge from that.
   const lineAlignment=index=>fit.placement?.lines[index]?.alignment??physicalAlignment(logicalAlignment,fit.directions?.[index]);
@@ -2061,9 +2062,13 @@ function renderRichLines(value,fit,box,bound,config) {
   return tag('g',{...traceAttrs(config.options,config.path),...(config.options.trace?{'data-opf-box-width':box.width,'data-opf-rich-text':config.rich===false?undefined:'true','data-opf-rich-lines':JSON.stringify(lineTrace),'data-opf-rich-spacing':spacing}:{}),...(fit.overflow?{'data-opf-overflow':'true'}:{})},content.join('\n'));
 }
 
-function renderTextBox(text, box, bound, config) {
+function assertXmlText(text, path) {
   const invalid=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE\uFFFF]/u.exec(String(text??''));
-  if(invalid)throw new OPFRenderError('invalid-text',`Text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which SVG XML cannot represent.`,{path:config.path});
+  if(invalid)throw new OPFRenderError('invalid-text',`Text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which SVG XML cannot represent.`,{path});
+}
+
+function renderTextBox(text, box, bound, config) {
+  assertXmlText(text, config.path);
   const scale = Math.min(bound.design.dimensions.width, bound.design.dimensions.height) / 720;
   const style = config.textStyle ?? resolveTextStyle({fontFamily:config.fontFamily,fontWeight:config.fontWeight ?? 400,italic:config.italic ?? false,path:config.path},config.options.textMeasurement);
   const fit = config.fit ?? fitText(String(text ?? ""), box, config.fontSize * scale,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-render",
-  "version": "0.20.0",
+  "version": "0.20.4",
   "description": "Deterministic local OPF renderer for SVG, PNG, and PDF output.",
   "license": "MIT",
   "type": "module",
@@ -142,7 +142,7 @@
     "test:forced-colors-browser": "node test/forced-colors-browser.mjs artifacts/forced-colors"
   },
   "dependencies": {
-    "@openpresentation/opf": "^0.20.1",
+    "@openpresentation/opf": "^0.20.5",
     "bidi-js": "1.1.0",
     "fontkit": "^2.0.4",
     "harfbuzzjs": "1.6.3",
@@ -388,13 +388,13 @@
     "@expo-google-fonts/tinos": "0.4.2",
     "@hyzyla/pdfium": "2.1.13",
     "@jspawn/qpdf-wasm": "0.0.2",
-    "@napi-rs/canvas": "1.0.10",
+    "@napi-rs/canvas": "1.0.11",
     "@resvg/resvg-js": "2.6.2",
     "axe-core": "4.14.0",
     "esbuild": "0.28.2",
     "pdf-lib": "1.17.1",
     "pdfjs-dist": "6.4.299",
-    "playwright": "1.63.0",
+    "playwright": "1.64.0",
     "sharp": "0.35.5"
   },
   "bin": {