@openpresentation/opf-render 0.17.0 → 0.17.1

package/README.md

@@ -152,11 +152,11 @@ Installed size, measured on Windows with `npm install --ignore-scripts`, unpacke
 - Public API: `renderSvg(opf, opts)` (every slide), `renderSlideSvg(opf, index, opts)` (one slide), `resolvePresentation(opf, opts)`, `svgToPng(svg, opts)`, `svgToPdf(svgs, 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)
 
-`renderSvg` 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); `renderSlideSvg` returns the SVG of one slide (a zero-based index; out of range throws `slide-index-out-of-range`). Both check 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. Faces are embedded whole, not as glyph subsets. `embedFonts: false` 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`.
+`renderSvg` 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); `renderSlideSvg` returns the SVG of one slide (a zero-based index; out of range throws `slide-index-out-of-range`). Both check 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). `embedFonts: false` 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 `renderDeckHtml` 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.
 
-Text as outlines (RR-64): `renderSvg(deck, { fonts, textAsPaths: true })` draws every `<text>` as glyph outlines, so the SVG needs no font and looks the same in every browser, image viewer and design tool. Each glyph is a `<use>` of an outline kept once per slide in `<defs>` (in font units, under an id made of the face's content hash and the glyph id, so SVGs inlined on one page never mix up glyphs); positions, widths and shaping are the vector PDF's (the same layout of the renderer's pinned lines), so over the core example decks resvg draws an outlined slide like its text (mean channel difference at most 0.006 of 255) and an outlined slide is about 38 KB at the median (58 KB at p90, 98 KB at most) against 0.5 to 4 MB with embedded faces. It needs the fonts handle `loadFonts()` returns, which carries the outline engine as `fonts.outlines` (`text-as-paths-needs-fonts` otherwise); the handle's faces are parsed for outlining once, on the first outlined slide. Each outlined element is a group that keeps the element's attributes and `data-opf-*` trace (a tspan's trace stays on a nested group), labelled `role="img"` with its text for assistive technology unless it is `aria-hidden`; links stay `<a>`; underline and line-through are rectangles from the font's own metrics. Text in a colour or bitmap font (emoji) stays text, reported as `text-as-paths-kept-text`, and the SVG embeds just that text's faces. The trade-offs, which make it the choice for thumbnails, previews and portable SVG files and not for an editing surface: the text is no longer text (it cannot be selected, copied, searched or translated, and assistive technology reads one label per text element instead of the text itself); a caret, selection and input method need live text; a vector PDF made from an outlined SVG has paths instead of selectable text, so `svgToPdf` should get the `<text>` SVG; browsers draw outlines without the hinting they give text, so small text looks a little lighter than browser text (resvg already draws text as outlines); and in `/fonts-browser` the outline engine adds about 85 KB (minified) to the bundle. Plan and later phases: [opf-render#164](https://github.com/OpenPresentation/opf-render/issues/164).
+Text as outlines (RR-64): `renderSvg(deck, { fonts, textAsPaths: true })` draws every `<text>` as glyph outlines, so the SVG needs no font and looks the same in every browser, image viewer and design tool. Each glyph is a `<use>` of an outline kept once per slide in `<defs>` (in font units, under an id made of the face's content hash and the glyph id, so SVGs inlined on one page never mix up glyphs); positions and widths are the vector PDF's layout of the renderer's pinned lines, and the glyphs are shaped by HarfBuzz, the shaper browsers use (the Node handle always; a browser handle given `shapeWasm`, the host's copy of `harfbuzzjs/dist/harfbuzz.wasm`; fontkit otherwise). Over the 30 script corpora every outlined glyph has HarfBuzz's id and position (fontkit, which the layout measures with, picks other glyphs on 10 samples: Bengali, Thai, Lao, Khmer, Myanmar, Syriac and Japanese combining marks); a run inside a pinned width is scaled to it, as the browser scales text. Over the core example decks resvg draws an outlined slide like its text (mean channel difference at most 0.006 of 255) and an outlined slide is about 40 KB at the median (60 KB at p90, 106 KB at most) against 0.5 to 4 MB with whole embedded faces. It needs the fonts handle `loadFonts()` returns, which carries the outline engine as `fonts.outlines` (`text-as-paths-needs-fonts` otherwise); the handle's faces are parsed for outlining once, on the first outlined slide. Each outlined element is a group that keeps the element's attributes and `data-opf-*` trace (a tspan's trace stays on a nested group); its glyphs are hidden from assistive technology and each outlined line is also real text, invisible (`fill="none"`, the generic family, so no face is embedded for it) and pinned to the drawn width, in reading order: a screen reader reads the words as text (the FA-30 tree, checked with axe), and selection, copy and find-in-page work. Links stay `<a>`; underline and line-through are rectangles from the font's own metrics. A run stays text where outlines would not be faithful, reported as `text-as-paths-fallback` with its `reason`: a colour or bitmap font (`colour-font`, emoji), a face whose fsType restricts embedding (`restricted`), or a run with no pinned width on which HarfBuzz and the layout's measurement disagree by more than 0.1 px (`shaping`); the SVG embeds just those runs' faces. The trade-offs, which make it the choice for thumbnails, previews and portable SVG files and not for an editing surface: the drawn text is not editable (a caret and an input method need live text in its own font); a vector PDF made from an outlined SVG has paths instead of selectable text, so `svgToPdf` should get the `<text>` SVG; browsers draw outlines without the hinting they give text, so small text looks a little lighter than browser text (resvg already draws text as outlines); and in `/fonts-browser` the outline engine adds about 85 KB (minified) to the bundle. Plan and later phases: [opf-render#164](https://github.com/OpenPresentation/opf-render/issues/164).
 
 The preview draws three accepted spec fields from tables shared with opf-pptx through core (`@openpresentation/opf`): `code.language` colours code (comments, strings, numbers, keywords, names and types, in theme-derived colours kept at 4.5:1 or more on the code panel; an unknown language stays plain and the text is never changed), `metric.trend` draws an arrow beside the trend word (green up, red down, neutral flat, with "Trend: up" as its text alternative) and colours the delta and trend text, and every one of the 54 DrawingML preset pattern backgrounds draws from its 8 x 8 bitmap (one pixel per 1/96 inch from the slide's top-left). With a core that lacks these exports the preview draws plain, without a new diagnostic. `scripts/derive-pattern-bitmaps.mjs` compares a PowerPoint export of the pattern slides with core's tiles (ECMA-376 names the presets without defining their pixels; core's tiles were measured with it from desktop PowerPoint, Office 365, Windows, 2026-10-01).
 
@@ -256,6 +256,13 @@ container.innerHTML = renderSlideSvg(presentation, 0, { fonts });
 
 Each entry of `faces` contains `url` or `data: Uint8Array`, with optional `family`, `weight`, `italic` and `license`. The loader registers browser FontFaces using the same bytes used for measurement. It fetches only URLs supplied by the host, supports an AbortSignal and custom fetch, and awaits font loading. Use pinned static faces and retain their licenses. A standalone SVG embeds the faces of the handle's `embeddedFonts` that its text draws (the same `{ fonts }` option); embedding is unnecessary for each live draft after browser fonts are loaded.
 
+Subset embedded faces in the browser (RR-65): pass `subsetWasm` to `loadFonts` to cut each face a standalone SVG embeds to the glyphs its slide draws, as the Node handle always does. It is the `harfbuzz-subset.wasm` file of the `harfbuzzjs` dependency (`harfbuzzjs/dist/harfbuzz-subset.wasm`, MIT), served by the host like the font files: its URL, its bytes or a compiled `WebAssembly.Module`. The loader instantiates it asynchronously and fetches nothing else; without it a browser handle embeds whole faces. Live previews in a page that already holds the faces should use `embedFonts: false` instead, which embeds nothing.
+
+```js
+const fonts = await loadFonts({ faces: fontFileEntries, subsetWasm: '/vendor/harfbuzz-subset.wasm' });
+const standalone = renderSlideSvg(presentation, 0, { fonts }); // each @font-face is a glyph subset
+```
+
 ## Player and `<opf-deck>` (RR-28)
 
 A slideshow player and an embeddable web component, both built on `renderSlideSvg`: the slide a page shows is the slide the preview, the editor and the PDF show, with no second layout engine. They are plain ES modules, typed, framework-free and tree-shakeable, and importing them touches no DOM, so they are safe in Next.js and other server renderers.

package/dist/drawn-faces.js

@@ -0,0 +1,38 @@
+// The faces and characters an SVG's text draws, read from its markup: the families of each text's font-family list, at the
+// font-weight and font-style the text takes (attributes are inherited down the element tree, as in SVG). RR-61 embeds only the
+// faces a slide draws; RR-65 cuts each to the characters drawn in its family. Shared by the SVG writer and the SSR deck markup.
+
+const FONT_WEIGHT_KEYWORDS = { normal: "400", bold: "700" };
+const TEXT_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+export function decodeTextEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, code) => code[0] === "#" ? String.fromCodePoint(code[1].toLowerCase() === "x" ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10)) : TEXT_ENTITIES[code] ?? match);
+}
+/** family (lowercase) to the set of "weight|style" pairs the markup draws text in; with `characters` (a Map), also the code points each family draws. */
+export function drawnFaces(markup, characters) {
+  const drawn = new Map();
+  const tokens = /<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|[^<]+/g;
+  const stack = [{ families: [], weight: "400", style: "normal", text: false }];
+  const attribute = (attributes, name) => { const found = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(attributes); return found ? found[1] ?? found[2] : undefined; };
+  for (const [token, close, name, attributes, selfClose] of markup.matchAll(tokens)) {
+    const top = stack.at(-1);
+    if (name === undefined) {
+      if (top.text && /\S/.test(token)) for (const family of top.families) { const set = drawn.get(family) ?? new Set(); set.add(`${top.weight}|${top.style}`); drawn.set(family, set); }
+      if (characters && top.text && token[0] !== "<") {
+        const points = [...decodeTextEntities(token)].map(character => character.codePointAt(0));
+        for (const family of top.families) { const set = characters.get(family) ?? new Set(); for (const point of points) set.add(point); characters.set(family, set); }
+      }
+      continue;
+    }
+    if (close) { if (stack.length > 1) stack.pop(); continue; }
+    const family = attribute(attributes, "font-family"), weight = attribute(attributes, "font-weight"), style = attribute(attributes, "font-style");
+    const next = {
+      families: family === undefined ? top.families : family.split(",").map(item => item.trim().replace(/^&quot;|&quot;$|^["']|["']$/g, "").toLowerCase()).filter(Boolean),
+      weight: weight === undefined ? top.weight : FONT_WEIGHT_KEYWORDS[weight.trim()] ?? weight.trim(),
+      style: style === undefined ? top.style : /italic|oblique/.test(style) ? "italic" : "normal",
+      text: top.text || name === "text",
+    };
+    if (!selfClose) stack.push(next);
+  }
+  return drawn;
+}

package/dist/element.js

@@ -7,6 +7,7 @@ import {
 } from "./deck-runtime.js";
 import { loadPreviewFonts } from "./preview-fonts.js";
 import { renderSlideSvg } from "./svg.js";
+import { drawnFaces } from "./drawn-faces.js";
 
 export { DeckError } from "./deck-runtime.js";
 export { loadPreviewFonts, previewBaseFaces, previewFontLayout } from "./preview-fonts.js";
@@ -528,19 +529,24 @@ export function renderDeckHtml(input, options = {}) {
   if (!["standalone", "shared", "external"].includes(fontMode)) throw new DeckError("invalid-font-mode", "Choose standalone, shared or external SSR fonts.");
   // Every mode measures with the same handle; external writes no @font-face data (RR-61 `embedFonts: false`).
   const renderFonts = handle ?? options.renderOptions?.fonts;
-  const sharedRules = new Set();
+  const sharedRules = new Set(), sharedCharacters = new Map();
   const attributes = { src: options.src, slide: options.slide, fonts: handle ? undefined : options.fonts, label: options.label, ...options.attributes };
   const attributeText = Object.entries(attributes).filter(([, value]) => value !== undefined && value !== false).map(([name, value]) => (value === true ? ` ${name}` : ` ${name}="${escapeHtml(value)}"`)).join("")
     + (options.thumbnails ? " thumbnails" : "") + (options.present ? " present" : "") + (options.includeHidden ? " include-hidden" : "");
   const date = options.renderOptions?.date ?? options.date;
   const figures = shown.map((position) => {
     const index = sequence[position];
-    let svg = renderSlideSvg(deck, index, { ...options.renderOptions, fonts: renderFonts, ...(fontMode === "external" ? { embedFonts: false } : {}), ...(date ? { date } : {}) });
-    if (fontMode === "shared") svg = svg.replace(/<style>(@font-face[\s\S]*?)<\/style>/g, (_, css) => {
-      // These rules are produced by renderSlideSvg after its used-face selection and validation.
-      for (const rule of css.split("\n")) sharedRules.add(rule);
-      return "";
-    });
+    // Shared rules are deduplicated across slides, so the slides embed whole faces and the shared set is cut below to what
+    // every slide draws (RR-65); per-slide subsets would differ and repeat each face once per slide.
+    let svg = renderSlideSvg(deck, index, { ...options.renderOptions, fonts: renderFonts, ...(fontMode === "external" ? { embedFonts: false } : {}), ...(fontMode === "shared" ? { subsetFonts: false } : {}), ...(date ? { date } : {}) });
+    if (fontMode === "shared") {
+      drawnFaces(svg, sharedCharacters);
+      svg = svg.replace(/<style>(@font-face[\s\S]*?)<\/style>/g, (_, css) => {
+        // These rules are produced by renderSlideSvg after its used-face selection and validation.
+        for (const rule of css.split("\n")) sharedRules.add(rule);
+        return "";
+      });
+    }
     const { width, height } = svgDimensions(svg);
     const prepared = prepareSlideSvg(svg).replace(/^<svg\b/, `<svg style="display:block;width:100%;height:auto;aspect-ratio:${width} / ${height}"`);
     const label = slideLabel(slideInfo(deck, index), position + 1, sequence.length);
@@ -549,6 +555,13 @@ export function renderDeckHtml(input, options = {}) {
   const titles = wanted === "first" && sequence.length > 1
     ? `<nav aria-label="Slides"><ol>${sequence.map((index) => `<li>${escapeHtml(slideInfo(deck, index).title)}</li>`).join("")}</ol></nav>` : "";
   const embedded = options.embed ? `<script type="application/opf+json">${JSON.stringify(deck).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")}</script>` : "";
-  const shared = sharedRules.size ? `<style>${[...sharedRules].join("\n")}</style>` : "";
+  const subsets = options.renderOptions?.subsetFonts === false ? undefined : renderFonts?.subsets;
+  const sharedRule = (rule) => {
+    const face = /^@font-face\{font-family:"([^"]+)";font-weight:(\d+);font-style:(\w+);src:url\("([^"]+)"\)\}$/.exec(rule);
+    const points = face && sharedCharacters.get(face[1].toLowerCase());
+    if (!subsets || !points?.size) return rule;
+    return rule.replace(face[4], subsets.subsetDataUrl({ family: face[1], weight: Number(face[2]), italic: face[3] === "italic", dataUrl: face[4] }, points));
+  };
+  const shared = sharedRules.size ? `<style>${[...sharedRules].map(sharedRule).join("\n")}</style>` : "";
   return `<${tag}${attributeText}>${shared}${figures.join("")}${titles}${embedded}</${tag}>`;
 }

package/dist/font-fstype.js

@@ -0,0 +1,70 @@
+// RR-76: what a face's license lets a document embed, from its OS/2 fsType (the OpenType embedding permissions). Bit 0x0002
+// (Restricted License) forbids embedding; 0x0200 (bitmap embedding only) allows only bitmaps, so an outline face cannot be
+// embedded either; 0x0100 (no subsetting) allows the whole face only. 0x0004 (preview and print) and 0x0008 (editable) allow it.
+// A face with no OS/2 table carries no restriction. No imports: the SVG writer and the subsetter both read it.
+
+const RESTRICTED = 0x0002, NO_SUBSETTING = 0x0100, BITMAP_ONLY = 0x0200;
+
+/** The OS/2 fsType of font bytes, or null when the font has no OS/2 table. */
+export function fsTypeOf(data) {
+  if (!data || data.length < 12) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const count = view.getUint16(4);
+  for (let index = 0; index < count; index++) {
+    const at = 12 + index * 16;
+    if (at + 16 > data.length) return null;
+    if (String.fromCharCode(data[at], data[at + 1], data[at + 2], data[at + 3]) !== "OS/2") continue;
+    const offset = view.getUint32(at + 8);
+    return offset + 10 <= data.length ? view.getUint16(offset + 8) : null;
+  }
+  return null;
+}
+
+/**
+ * The OS/2 fsType of a font data URL (base64), reading only the table directory and the two fsType bytes, so a large face is
+ * never decoded whole; null when the font has no OS/2 table or the URL cannot be read.
+ */
+export function dataUrlFsType(dataUrl) {
+  const comma = String(dataUrl ?? "").indexOf(",");
+  if (comma < 0) return null;
+  const base64 = dataUrl.slice(comma + 1);
+  const head = decodeRange(base64, 0, 12);
+  if (head.length < 12) return null;
+  const count = (head[4] << 8) | head[5];
+  const directory = decodeRange(base64, 12, 12 + count * 16);
+  for (let index = 0; index + 16 <= directory.length; index += 16) {
+    if (String.fromCharCode(directory[index], directory[index + 1], directory[index + 2], directory[index + 3]) !== "OS/2") continue;
+    const offset = ((directory[index + 8] << 24) | (directory[index + 9] << 16) | (directory[index + 10] << 8) | directory[index + 11]) >>> 0;
+    const bytes = decodeRange(base64, offset + 8, offset + 10);
+    return bytes.length === 2 ? (bytes[0] << 8) | bytes[1] : null;
+  }
+  return null;
+}
+
+/** Whether the face may be embedded at all (as outline data). */
+export function embeddingAllowed(fsType) {
+  return fsType === null || ((fsType & RESTRICTED) === 0 && (fsType & BITMAP_ONLY) === 0);
+}
+
+/** Whether the face may be embedded as a subset. */
+export function subsettingAllowed(fsType) {
+  return fsType !== null && embeddingAllowed(fsType) && (fsType & NO_SUBSETTING) === 0;
+}
+
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const VALUES = new Map([...ALPHABET].map((character, index) => [character, index]));
+
+// Bytes [start, end) of base64 text, decoding only the 4-character groups that hold them.
+function decodeRange(base64, start, end) {
+  const first = Math.floor(start / 3), last = Math.ceil(end / 3);
+  const text = base64.slice(first * 4, last * 4);
+  const bytes = [];
+  for (let index = 0; index + 4 <= text.length; index += 4) {
+    const [a, b, c, d] = [...text.slice(index, index + 4)].map((character) => VALUES.get(character));
+    if (a === undefined || b === undefined) break;
+    bytes.push((a << 2) | (b >> 4));
+    if (c !== undefined) bytes.push(((b & 15) << 4) | (c >> 2));
+    if (d !== undefined) bytes.push(((c & 3) << 6) | d);
+  }
+  return bytes.slice(start - first * 3, end - first * 3);
+}

package/dist/font-subset.js

@@ -0,0 +1,173 @@
+// RR-65: glyph subsets for the faces an SVG embeds as @font-face data. HarfBuzz's own subsetter (hb-subset, the
+// `harfbuzz-subset.wasm` of the pinned harfbuzzjs package, MIT) keeps the glyphs a slide's characters reach through the
+// font's layout tables (every GSUB and GPOS feature is kept, so the browser shapes the subset exactly as the whole face),
+// renumbers them and trims cmap, hmtx, GPOS and the rest to them. The module has no imports, so it is instantiated
+// synchronously from its bytes and `renderSvg` stays synchronous; the same input always gives the same bytes.
+//
+// Only a face whose license allows it is subset: a bundled face (matched by the sha256 of its bytes against the pinned
+// manifest) under an allowed license, whose family and file names do not contain one of its package's Reserved Font Names
+// (a subset is a modified version, owner decision 2026-09-29), and whose OS/2 fsType allows subsetting. Every other face
+// (a host's own faces, Carlito, Raleway, ...) is embedded whole, as before.
+
+import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
+import { sha256Bytes } from "./sha256.js";
+import { fsTypeOf, subsettingAllowed } from "./font-fstype.js";
+
+const SUBSET_LICENSES = new Set(["OFL-1.1", "Apache-2.0", "MIT", "UFL-1.0"]);
+const HB_MEMORY_MODE_READONLY = 1;
+const HB_SUBSET_SETS_LAYOUT_FEATURE_TAG = 6;
+const CACHE_LIMIT = 256;
+
+/** The manifest faces that may be subset, by sha256: permissive license, no Reserved Font Name in the family or file name. */
+const SUBSETTABLE = (() => {
+  const hashes = new Set();
+  for (const pkg of BUNDLED_FONT_MANIFEST.packages) {
+    if (!SUBSET_LICENSES.has(pkg.license)) continue;
+    const reserved = (pkg.reservedFontNames ?? []).map((name) => name.toLowerCase());
+    for (const face of pkg.faces) {
+      const names = `${face.family} ${face.file}`.toLowerCase();
+      if (!reserved.some((name) => names.includes(name)) && /^[0-9a-f]{64}$/.test(face.sha256 ?? "")) hashes.add(face.sha256);
+    }
+  }
+  return hashes;
+})();
+
+/** Whether a face may be subset: a permitted bundled face whose OS/2 fsType allows subsetting (and embedding). */
+export function subsetPermitted(data) {
+  return SUBSETTABLE.has(hexDigest(data)) && fsTypeAllowsSubset(data);
+}
+
+/** Whether the OS/2 fsType allows embedding a subset: not restricted (0x0002), not "no subsetting" (0x0100), not bitmap-only (0x0200). */
+export function fsTypeAllowsSubset(data) {
+  return subsettingAllowed(fsTypeOf(data));
+}
+
+function hexDigest(data) {
+  return [...sha256Bytes(data)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+/**
+ * A synchronous subsetter over hb-subset: `subset(data, codePoints)` returns the subset font bytes, or null when HarfBuzz
+ * cannot subset the face. `wasm` is the `harfbuzz-subset.wasm` bytes, a compiled WebAssembly.Module or an Instance.
+ */
+export function createSubsetter(wasm) {
+  // A browser instantiates asynchronously (large modules may not compile synchronously on the main thread) and passes the instance.
+  const instance = wasm instanceof WebAssembly.Instance ? wasm : new WebAssembly.Instance(wasm instanceof WebAssembly.Module ? wasm : new WebAssembly.Module(wasm), {});
+  const exports = instance.exports;
+  const required = ["memory", "malloc", "free", "hb_blob_create", "hb_blob_destroy", "hb_blob_get_length", "hb_blob_get_data", "hb_face_create", "hb_face_destroy",
+    "hb_face_reference_blob", "hb_set_add", "hb_set_clear", "hb_set_invert", "hb_subset_input_create_or_fail", "hb_subset_input_destroy", "hb_subset_input_unicode_set",
+    "hb_subset_input_set", "hb_subset_or_fail"];
+  for (const name of required) if (!(name in exports)) throw new Error(`harfbuzz-subset.wasm has no export ${name}.`);
+  return {
+    subset(data, codePoints) {
+      const pointer = exports.malloc(data.length);
+      if (!pointer) return null;
+      new Uint8Array(exports.memory.buffer, pointer, data.length).set(data);
+      const blob = exports.hb_blob_create(pointer, data.length, HB_MEMORY_MODE_READONLY, 0, 0);
+      const face = exports.hb_face_create(blob, 0);
+      const input = exports.hb_subset_input_create_or_fail();
+      let result = 0, output = null;
+      try {
+        if (!input) return null;
+        const unicodes = exports.hb_subset_input_unicode_set(input);
+        for (const codePoint of codePoints) exports.hb_set_add(unicodes, codePoint);
+        // Every layout feature, not only HarfBuzz's default list: the browser shapes the subset like the whole face whatever
+        // font-feature-settings the SVG asks for.
+        const features = exports.hb_subset_input_set(input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
+        exports.hb_set_clear(features);
+        exports.hb_set_invert(features);
+        result = exports.hb_subset_or_fail(face, input);
+        if (!result) return null;
+        const subsetBlob = exports.hb_face_reference_blob(result);
+        const length = exports.hb_blob_get_length(subsetBlob), at = exports.hb_blob_get_data(subsetBlob, 0);
+        output = length && at ? new Uint8Array(exports.memory.buffer, at, length).slice() : null;
+        exports.hb_blob_destroy(subsetBlob);
+        return output && glyfBeforeLastTable(output);
+      } finally {
+        if (result) exports.hb_face_destroy(result);
+        if (input) exports.hb_subset_input_destroy(input);
+        exports.hb_face_destroy(face);
+        exports.hb_blob_destroy(blob);
+        exports.free(pointer);
+      }
+    },
+  };
+}
+
+// hb-subset writes glyf as the last table. fontkit reads a 10-byte glyph header even for an empty glyph (a space), so when
+// the last glyph is empty it reads past the end of the file, and the vector PDF and the outline engine (which parse SVG
+// @font-face data with fontkit) would fail. Table order in the file is free: glyf moves before the other tables, every table
+// keeps its bytes and checksum, and head.checkSumAdjustment is recomputed for the new file.
+function glyfBeforeLastTable(font) {
+  const view = new DataView(font.buffer, font.byteOffset, font.byteLength);
+  const count = view.getUint16(4);
+  const tables = [];
+  for (let index = 0; index < count; index++) {
+    const at = 12 + index * 16;
+    tables.push({ entry: at, tag: String.fromCharCode(font[at], font[at + 1], font[at + 2], font[at + 3]), offset: view.getUint32(at + 8), length: view.getUint32(at + 12) });
+  }
+  const byOffset = [...tables].sort((a, b) => a.offset - b.offset);
+  if (byOffset.at(-1)?.tag !== "glyf" || byOffset.length < 2) return font;
+  const order = [byOffset.at(-1), ...byOffset.slice(0, -1)];
+  const padded = (length) => (length + 3) & ~3;
+  const start = 12 + count * 16;
+  const out = new Uint8Array(start + order.reduce((sum, table) => sum + padded(table.length), 0));
+  out.set(font.subarray(0, start));
+  const outView = new DataView(out.buffer);
+  let offset = start;
+  for (const table of order) {
+    out.set(font.subarray(table.offset, table.offset + table.length), offset);
+    outView.setUint32(table.entry + 8, offset);
+    offset += padded(table.length);
+  }
+  const head = tables.find((table) => table.tag === "head");
+  if (head) {
+    const at = outView.getUint32(head.entry + 8) + 8;
+    outView.setUint32(at, 0);
+    let sum = 0;
+    for (let index = 0; index < out.length; index += 4) sum = (sum + outView.getUint32(index)) >>> 0;
+    outView.setUint32(at, (0xB1B0AFBA - sum) >>> 0);
+  }
+  return out;
+}
+
+/**
+ * The subset engine a fonts handle carries as `subsets` (RR-65): `subsetDataUrl(font, codePoints)` returns the data URL of
+ * the embedded face `font` cut to the code points, or its own data URL when the face may not be subset (license, Reserved
+ * Font Name, fsType), HarfBuzz cannot subset it, or the subset is not smaller. Faces are found in the registry by family,
+ * weight and style; results are cached per face and code point set.
+ */
+export function fontSubsets(registry, subsetter) {
+  const permitted = new Map();
+  const cache = new Map();
+  const bytesOf = (font) => {
+    const faces = registry.exportFaces(), described = registry.describeFaces();
+    const index = described.findIndex((face) => face.family === font.family && face.weight === font.weight && Boolean(face.italic) === Boolean(font.italic));
+    return index >= 0 ? faces[index].data : null;
+  };
+  return Object.freeze({
+    subsetDataUrl(font, codePoints) {
+      const points = [...new Set(codePoints)].sort((a, b) => a - b);
+      const key = `${font.family}|${font.weight}|${font.italic ? 1 : 0}|${font.dataUrl.length}|${points.join(",")}`;
+      if (cache.has(key)) return cache.get(key);
+      const data = bytesOf(font);
+      let url = font.dataUrl;
+      if (data) {
+        let allowed = permitted.get(data);
+        if (allowed === undefined) { allowed = subsetPermitted(data); permitted.set(data, allowed); }
+        const subset = allowed ? subsetter.subset(data, points) : null;
+        if (subset && subset.length < data.length) url = `${font.dataUrl.slice(0, font.dataUrl.indexOf(",") + 1)}${base64(subset)}`;
+      }
+      if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value);
+      cache.set(key, url);
+      return url;
+    },
+  });
+}
+
+function base64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 0x8000) binary += String.fromCharCode(...bytes.subarray(index, index + 0x8000));
+  return btoa(binary);
+}

package/dist/fonts-browser.d.ts

@@ -81,6 +81,17 @@ export declare function loadFonts(
     document?: Document;
     fetch?: typeof fetch;
     signal?: AbortSignal;
+    /**
+     * RR-65: harfbuzzjs's `harfbuzz-subset.wasm` (the URL the host serves it from, its bytes or a compiled WebAssembly.Module). With
+     * it the handle carries `subsets`, and every SVG `renderSvg` draws with this handle embeds each face cut to the characters the
+     * slide draws. Without it a browser handle embeds whole faces (the Node handle always subsets).
+     */
+    subsetWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
+    /**
+     * RR-64: harfbuzzjs's `harfbuzz.wasm` (its URL, bytes or a compiled WebAssembly.Module). With it `textAsPaths` shapes outlines with
+     * HarfBuzz, as the browser shapes text; without it a browser handle shapes them with fontkit (the Node handle always uses HarfBuzz).
+     */
+    shapeWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
     crypto?: { subtle: SubtleCrypto };
     /** Script faces to load once the registry exists: "auto" (with `presentation`), "all" or ISO 15924 codes. Needs `scriptBaseUrl`. */
     scripts?: ScriptSelection | "auto";

package/dist/fonts-browser.js

@@ -3,6 +3,8 @@ import { lazyFontEntries, lazyFontList, normalizeExtraLazyFonts } from "./lazy-f
 import { lazyFacesNeeded } from "./lazy-fonts.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { textOutlines } from "./text-paths.js";
+import { createSubsetter, fontSubsets } from "./font-subset.js";
+import { instantiateShaper } from "./hb-shape.js";
 import { analyzePresentationScripts, nextFallbackPackage, scriptFontPackages, scriptPackageEntries, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontEntries, scriptFontPackages } from "./script-font-pack.js";
 export { lazyFontEntries, lazyFontList, splitStartupFaces } from "./lazy-font-list.js";
@@ -280,8 +282,32 @@ const MAX_ENSURE_ROUNDS = 4;
  * (`substitutionPolicy`, `aliases`, `fallbackFamily`, `themeFonts`, `strictGlyphs`) are as for the registry (see `fonts-browser.d.ts`).
  * `dispose()` removes every face from the document.
  */
-export async function loadFonts({ faces = [], ...options } = {}) {
-  const registry = await loadRegistry(faces, options);
+// RR-65: the host's copy of harfbuzzjs's `harfbuzz-subset.wasm` (a URL it serves, the bytes or a compiled module), instantiated
+// asynchronously here (a browser may refuse to compile a large module synchronously on the main thread).
+async function browserSubsetter(source, fetchImpl, signal) {
+  if (source instanceof WebAssembly.Module) return createSubsetter(await WebAssembly.instantiate(source, {}));
+  if (source instanceof ArrayBuffer || ArrayBuffer.isView(source)) return createSubsetter((await WebAssembly.instantiate(source, {})).instance);
+  if (typeof source !== "string" && !(source instanceof URL)) throw new OPFFontError("invalid-font-source", "subsetWasm must be the URL of harfbuzz-subset.wasm, its bytes or a compiled WebAssembly.Module.");
+  const response = await (fetchImpl ?? globalThis.fetch)(String(source), { signal });
+  if (!response.ok) throw new OPFFontError("font-resource-unavailable", `harfbuzz-subset.wasm could not be fetched (${response.status}).`, { url: String(source) });
+  return createSubsetter((await WebAssembly.instantiate(await response.arrayBuffer(), {})).instance);
+}
+
+// RR-64 phase 2: the host's copy of harfbuzzjs's `harfbuzz.wasm`, instantiated asynchronously, so outlines are shaped by HarfBuzz.
+async function browserShaper(source, fetchImpl, signal) {
+  return instantiateShaper(source instanceof WebAssembly.Module || source instanceof ArrayBuffer || ArrayBuffer.isView(source) ? source : await fetchWasm(source, fetchImpl, signal, "harfbuzz.wasm"));
+}
+
+async function fetchWasm(source, fetchImpl, signal, name) {
+  if (typeof source !== "string" && !(source instanceof URL)) throw new OPFFontError("invalid-font-source", `${name} must be given as a URL, its bytes or a compiled WebAssembly.Module.`);
+  const response = await (fetchImpl ?? globalThis.fetch)(String(source), { signal });
+  if (!response.ok) throw new OPFFontError("font-resource-unavailable", `${name} could not be fetched (${response.status}).`, { url: String(source) });
+  return response.arrayBuffer();
+}
+
+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)]);
   // 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;
@@ -295,7 +321,9 @@ export async function loadFonts({ faces = [], ...options } = {}) {
     get embeddedFonts() { if (stale) { embedded = registry.embeddedFonts; stale = false; } return embedded; },
     registry,
     // RR-64: the outline engine `renderSvg(deck, { fonts, textAsPaths: true })` draws text with, over this registry's faces.
-    outlines: textOutlines({ registry }),
+    outlines: textOutlines({ registry, shaper }),
+    // RR-65: with `subsetWasm`, the subset engine that cuts each face an SVG embeds to the characters the slide draws.
+    ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),
     manifest: BUNDLED_FONT_MANIFEST,
     get substitutions() { return registry.substitutions; },
     /**

package/dist/fonts-node.js

@@ -7,6 +7,8 @@ import { createFontRegistry, OPFFontError } from "./font-registry.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { lazyFontList } from "./lazy-font-list.js";
 import { textOutlines } from "./text-paths.js";
+import { createSubsetter, fontSubsets } from "./font-subset.js";
+import { createShaper } from "./hb-shape.js";
 export { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { analyzePresentationScripts, autoScriptSelection, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontPackages } from "./script-font-pack.js";
@@ -247,6 +249,23 @@ async function ensureFonts(registry, loaded, presentation, {onDiagnostic, render
   return {scripts: loaded.packages.slice(before), lazy: [], uncovered: selection.uncovered ? [...selection.uncovered] : []};
 }
 
+// RR-65: hb-subset from the pinned harfbuzzjs package (MIT), compiled once per process. The module has no imports, so it is
+// instantiated synchronously and renderSvg stays synchronous. A copy that cannot be loaded leaves the handle without `subsets`
+// (whole faces, as before RR-65): a byte saving never stops fonts from loading.
+let subsetterPromise;
+function nodeSubsetter() {
+  subsetterPromise ??= readFile(require.resolve("harfbuzzjs/dist/harfbuzz-subset.wasm")).then(createSubsetter, () => null).catch(() => null);
+  return subsetterPromise;
+}
+
+// RR-64 phase 2: HarfBuzz's shaper (harfbuzz.wasm of the same package) for text drawn as outlines, so the outlines are shaped as
+// a browser shapes the text. Without it outlines are shaped with fontkit.
+let shaperPromise;
+function nodeShaper() {
+  shaperPromise ??= readFile(require.resolve("harfbuzzjs/dist/harfbuzz.wasm")).then(createShaper, () => null).catch(() => null);
+  return shaperPromise;
+}
+
 /**
  * The fonts handle: one set of verified font inputs for layout, SVG, editor, PPTX and Node raster export. Pass it as `{ fonts }` to
  * `renderSvg`, `renderSlideSvg`, `svgToPng`, `svgToPdf`, core `paginate` and `validate`, and `toPptx`.
@@ -266,6 +285,7 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
   // The embedded list is base64 of every face: computed on first use, and again after `ensure` added faces.
   let embeddedFonts, fontFiles = [...registry.fontFiles];
   const refresh = () => { embeddedFonts = undefined; fontFiles = [...registry.fontFiles]; };
+  const [subsetter, shaper] = await Promise.all([nodeSubsetter(), nodeShaper()]);
   return {
     textMeasurement: registry.textMeasurement,
     get embeddedFonts() { return (embeddedFonts ??= selectEmbedded()); },
@@ -274,7 +294,9 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
     loadSystemFonts: false,
     registry,
     // RR-64: the outline engine `renderSvg(deck, { fonts, textAsPaths: true })` draws text with, over this registry's faces.
-    outlines: textOutlines({ registry }),
+    outlines: textOutlines({ registry, shaper }),
+    // RR-65: the subset engine that cuts each face an SVG embeds to the characters the slide draws.
+    ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),
     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. */

package/dist/fonts.d.ts

@@ -51,7 +51,11 @@ export interface RenderFonts {
   loadSystemFonts?: boolean;
   /** The outline engine `textAsPaths: true` draws text with (RR-64); a `loadFonts` handle carries one over its registry's faces. */
   outlines?: TextOutlines;
+  /** The subset engine (RR-65): each face an SVG embeds is cut to the characters the slide draws. The Node `loadFonts` handle carries one; a browser handle with `subsetWasm`. */
+  subsets?: FontSubsets;
 }
+/** Cuts an embedded face to code points (RR-65), with hb-subset; a face whose license, Reserved Font Name or fsType does not allow it keeps its own data URL. */
+export interface FontSubsets { subsetDataUrl(font: EmbeddedFont, codePoints: Iterable<number>): string }
 /** Draws a slide's text as glyph outlines (RR-64). Read by `renderSvg`; hosts pass the handle and `textAsPaths: true`. */
 export interface TextOutlines { outlineSlideText(content: string[], options: object): { content: string[]; defs: string } }
 /** What `fonts.ensure(presentation)` loaded: the script packages and vendored faces that were missing, and drawn CJK characters no face covers. */

package/dist/hb-shape.js

@@ -0,0 +1,121 @@
+// RR-64 phase 2: HarfBuzz shaping for text drawn as outlines. Browsers shape with HarfBuzz, and fontkit differs from it on some
+// scripts (Thai tone marks, Bengali and Khmer conjunct forms, Myanmar medials, Telugu offsets, Hebrew points, Japanese combining
+// sound marks), so outlines shaped by HarfBuzz are what the browser draws. This drives `harfbuzz.wasm` of the pinned harfbuzzjs
+// package (MIT) through HarfBuzz's C API. The module needs only five small host functions, so it is instantiated synchronously
+// from its bytes and the renderer stays synchronous. Glyphs come back in the shape `pdf-fonts.js` `shape()` returns: left to
+// right, `{gid, codePoints, advance, xOffset, yOffset}` in font units.
+
+const HB_MEMORY_MODE_READONLY = 1;
+const HB_DIRECTION = { ltr: 4, rtl: 5 };
+const INFO_SIZE = 20, POSITION_SIZE = 20, FEATURE_SIZE = 16;
+
+// The five host functions the module imports, bound to the instance's memory once it exists.
+function hostImports() {
+  const state = { memory: null };
+  const imports = {
+    env: {
+      // Emscripten grows the heap through the host: grow the memory to the requested size.
+      emscripten_resize_heap: (requested) => {
+        try {
+          const missing = (requested >>> 0) - state.memory.buffer.byteLength;
+          if (missing > 0) state.memory.grow(Math.ceil(missing / 65536));
+          return 1;
+        } catch { return 0; }
+      },
+      _abort_js: () => { throw new Error("HarfBuzz aborted."); },
+      _setitimer_js: () => 0,
+      _emscripten_runtime_keepalive_clear: () => {},
+    },
+    wasi_snapshot_preview1: { proc_exit: (code) => { throw new Error(`HarfBuzz exited (${code}).`); } },
+  };
+  return { imports, state };
+}
+
+/** A synchronous HarfBuzz shaper over `harfbuzz.wasm` (its bytes or a compiled WebAssembly.Module): Node. */
+export function createShaper(wasm) {
+  const { imports, state } = hostImports();
+  return shaperOver(new WebAssembly.Instance(wasm instanceof WebAssembly.Module ? wasm : new WebAssembly.Module(wasm), imports), state);
+}
+
+/** The same shaper, instantiated asynchronously (a browser may refuse to compile a large module synchronously). */
+export async function instantiateShaper(wasm) {
+  const { imports, state } = hostImports();
+  const result = await WebAssembly.instantiate(wasm, imports);
+  return shaperOver(result instanceof WebAssembly.Instance ? result : result.instance, state);
+}
+
+function shaperOver(instance, state) {
+  const hb = instance.exports;
+  const memory = state.memory = hb.memory;
+  hb.__wasm_call_ctors?.();
+  const fonts = new Map();
+  const utf8 = new TextEncoder();
+  const string = (text) => {
+    const bytes = utf8.encode(text), pointer = hb.malloc(bytes.length + 1);
+    const view = new Uint8Array(memory.buffer, pointer, bytes.length + 1);
+    view.set(bytes);
+    view[bytes.length] = 0;
+    return { pointer, length: bytes.length };
+  };
+  // One HarfBuzz font per face, kept for the shaper's lifetime (faces are few and shaped again and again).
+  const fontFor = (key, data) => {
+    let font = fonts.get(key);
+    if (font) return font;
+    const pointer = hb.malloc(data.length);
+    new Uint8Array(memory.buffer, pointer, data.length).set(data);
+    const blob = hb.hb_blob_create(pointer, data.length, HB_MEMORY_MODE_READONLY, 0, 0);
+    const face = hb.hb_face_create(blob, 0);
+    font = hb.hb_font_create(face);
+    fonts.set(key, font);
+    return font;
+  };
+  return {
+    /** Shape `text` with the face (`key` names it, `data` is its bytes); `features` is an object of OpenType feature booleans. */
+    shape(key, data, text, { direction = "ltr", language, features } = {}) {
+      const font = fontFor(key, data);
+      const buffer = hb.hb_buffer_create();
+      const units = text.length, textPointer = hb.malloc(units * 2 + 2);
+      const view = new Uint16Array(memory.buffer, textPointer, units);
+      for (let index = 0; index < units; index++) view[index] = text.charCodeAt(index);
+      const allocated = [textPointer];
+      try {
+        hb.hb_buffer_add_utf16(buffer, textPointer, units, 0, units);
+        hb.hb_buffer_set_direction(buffer, HB_DIRECTION[direction] ?? HB_DIRECTION.ltr);
+        if (language) { const tag = string(language); allocated.push(tag.pointer); hb.hb_buffer_set_language(buffer, hb.hb_language_from_string(tag.pointer, tag.length)); }
+        hb.hb_buffer_guess_segment_properties(buffer);
+        const entries = Object.entries(features ?? {});
+        let featurePointer = 0;
+        if (entries.length) {
+          featurePointer = hb.malloc(entries.length * FEATURE_SIZE);
+          allocated.push(featurePointer);
+          entries.forEach(([tag, on], index) => { const spec = string(`${on ? "+" : "-"}${tag}`); allocated.push(spec.pointer); hb.hb_feature_from_string(spec.pointer, spec.length, featurePointer + index * FEATURE_SIZE); });
+        }
+        hb.hb_shape(font, buffer, featurePointer, entries.length);
+        const lengthPointer = hb.malloc(4);
+        allocated.push(lengthPointer);
+        const infos = hb.hb_buffer_get_glyph_infos(buffer, lengthPointer);
+        const count = new Uint32Array(memory.buffer, lengthPointer, 1)[0];
+        const positions = hb.hb_buffer_get_glyph_positions(buffer, 0);
+        const data32 = new DataView(memory.buffer);
+        const glyphs = [];
+        for (let index = 0; index < count; index++) {
+          const info = infos + index * INFO_SIZE, position = positions + index * POSITION_SIZE;
+          glyphs.push({ gid: data32.getUint32(info, true), cluster: data32.getUint32(info + 8, true), advance: data32.getInt32(position, true), xOffset: data32.getInt32(position + 8, true), yOffset: data32.getInt32(position + 12, true) });
+        }
+        // The characters of each cluster go to its first glyph in output order; later glyphs of the cluster carry none.
+        const starts = [...new Set(glyphs.map((glyph) => glyph.cluster))].sort((a, b) => a - b);
+        const seen = new Set();
+        for (const glyph of glyphs) {
+          if (seen.has(glyph.cluster)) { glyph.codePoints = []; continue; }
+          seen.add(glyph.cluster);
+          const end = starts[starts.indexOf(glyph.cluster) + 1] ?? units;
+          glyph.codePoints = [...text.slice(glyph.cluster, end)].map((character) => character.codePointAt(0));
+        }
+        return glyphs.map(({ gid, codePoints, advance, xOffset, yOffset }) => ({ gid, codePoints, advance, xOffset, yOffset }));
+      } finally {
+        hb.hb_buffer_destroy(buffer);
+        for (const pointer of allocated) hb.free(pointer);
+      }
+    },
+  };
+}

package/dist/index.d.ts

@@ -64,12 +64,24 @@ export interface RenderSvgOptions {
    * `true` draws every `<text>` as glyph outlines (RR-64): `<use>` of outlines kept once per slide in `<defs>`, so the SVG needs
    * no font and looks the same in every viewer (about 40 KB a slide over the core example decks, against 0.5 to 4 MB of embedded
    * faces). Needs the fonts handle `loadFonts()` returns (`text-as-paths-needs-fonts` otherwise). The text is no longer text: it
-   * cannot be selected, searched or edited in place, and each outlined element is a `role="img"` group labelled with its text for
-   * assistive technology. Each element keeps its `data-opf-*` trace. Text in a colour or bitmap font stays text
-   * (`text-as-paths-kept-text`). Use it for thumbnails, previews and portable SVG files, not for an editing surface or the
-   * vector PDF (which keeps real text from `<text>` SVG). Default false.
+   * cannot be edited in place. The glyphs are shaped by HarfBuzz (the browser's shaper; the Node handle always, a browser handle
+   * given `shapeWasm`), are hidden from assistive technology, and each outlined line is also invisible real text pinned to the
+   * drawn width, so screen readers, selection, copy and find-in-page get the words. Each element keeps its `data-opf-*` trace.
+   * A run stays text, reported as `text-as-paths-fallback` with a `reason`, when its font is a colour or bitmap font
+   * (`"colour-font"`), its face's fsType restricts embedding (`"restricted"`), or it has no pinned width and HarfBuzz and the
+   * layout's measurement disagree on it (`"shaping"`). Use it for thumbnails, previews and portable SVG files, not for an editing
+   * surface or the vector PDF (which keeps real text from `<text>` SVG). Default false.
    */
   textAsPaths?: boolean;
+  /**
+   * `false` embeds whole faces (RR-65). By default, with a fonts handle that carries `subsets` (the Node `loadFonts` handle, a browser
+   * handle given `subsetWasm`), each face an SVG embeds is cut to the characters the slide draws, keeping every layout feature, so the
+   * browser draws it exactly like the whole face (over the core example decks a slide's SVG falls from 2.4 MB to 59 KB on average).
+   * Faces whose license does not allow a modified version under their own name (Carlito, Raleway, Lora, Playfair Display, PT Serif,
+   * Merriweather Sans, Source Sans 3), whose fsType forbids subsetting, or that a host supplied, are always embedded whole. Set it to
+   * false for an SVG whose text will be edited outside the renderer.
+   */
+  subsetFonts?: boolean;
   /** `"chain"` (default): a character the resolved face lacks is drawn with the first bundled face that has it, and reported as `font-glyph-fallback`. `"none"`: exact faces, a missing glyph raises `missing-glyph`. */
   glyphFallback?: "chain" | "none";
   /** Unscaled reference-pixel clearance around supplied vector text outlines; default 1. */

package/dist/pdf-text.js

@@ -166,7 +166,7 @@ function buildRuns(chunk, env, styleIds, faceCache, linkIds, ownerIds) {
   for (const char of chunk.chars) { levels.push(embedding.levels[unit]); unit += char.ch.length; }
   const mirrored = bidi.getMirroredCharactersMap(text, embedding.levels);
   const runs = [];
-  const chunkInfo = { logical: chunk.chars.filter((char) => !IGNORED.test(char.ch)).map((char) => char.ch).join("") };
+  const chunkInfo = { logical: chunk.chars.filter((char) => !IGNORED.test(char.ch)).map((char) => char.ch).join(""), rtl: baseDirection === "rtl" || /^[⁧‫‮]/.test(text) };
   let current = null;
   unit = 0;
   chunk.chars.forEach((char, index) => {
@@ -179,7 +179,8 @@ function buildRuns(chunk, env, styleIds, faceCache, linkIds, ownerIds) {
     const owner = env.splitByOwner ? linkId(ownerIds, { node: char.owner }) : 0;
     const key = `${resolved.styleId}|${resolved.face.id}|${level}|${char.scope?.id ?? 0}|${linkId(linkIds, char.link)}|${[...char.decoration].sort().join(",")}|${owner}`;
     if (!current || current.key !== key) {
-      current = { chunk: chunkInfo, key, face: resolved.face, style: char.style, level, scope: char.scope, link: char.link, decoration: char.decoration, owner: char.owner, chars: [], text: "", logical: "", weight: resolved.weight, italic: resolved.italic };
+      // `start`: the run's first character in logical order, so a reader can put runs back in reading order (RR-64).
+      current = { chunk: chunkInfo, start: index, key, face: resolved.face, style: char.style, level, scope: char.scope, link: char.link, decoration: char.decoration, owner: char.owner, chars: [], text: "", logical: "", weight: resolved.weight, italic: resolved.italic };
       runs.push(current);
     }
     current.logical += char.ch;
@@ -244,7 +245,9 @@ function shapeRun(run, env) {
   const size = parseFloat(style["font-size"]) || 16;
   const direction = run.level % 2 === 1 ? "rtl" : "ltr";
   const language = openTypeLanguage(style.lang ?? style["xml:lang"]);
-  const glyphs = shape(run.face, run.text, { features: featuresOf(style), language, direction });
+  // RR-64: outlined text is shaped by HarfBuzz (env.shape), the browser's shaper; the vector PDF keeps fontkit.
+  // HarfBuzz takes the BCP 47 tag (`lang`); fontkit the OpenType language system (`language`).
+  const glyphs = (env.shape ?? shape)(run.face, run.text, { features: featuresOf(style), language, lang: style.lang ?? style["xml:lang"], direction });
   const scale = size / run.face.upem;
   const letterSpacing = parseLength(style["letter-spacing"], { fontSize: size }) ?? 0;
   const wordSpacing = parseLength(style["word-spacing"], { fontSize: size }) ?? 0;

package/dist/pdf-vector.js

@@ -744,6 +744,9 @@ class Converter {
       run.fill = await this.paint(run.style.fill, run.style, ctx, box, "fill");
       run.stroke = await this.paint(run.style.stroke, run.style, ctx, box, "stroke");
     }
+    // Text with neither fill nor stroke draws nothing (an outlined slide's invisible readable layer, RR-64): it adds no font,
+    // no glyph and no structure to the PDF.
+    if (!runs.some((run) => run.fill || run.stroke)) return;
     // Runs are drawn in visual (left to right) order. Right-to-left runs are marked /ReversedChars so extractors read
     // their characters back to front, and a cluster whose glyph-to-Unicode map cannot give its text (a ligature, a
     // letter split into base and dots, a mirrored bracket) carries /ActualText; a left-to-right run the map cannot

package/dist/svg.d.ts

@@ -64,12 +64,24 @@ export interface RenderSvgOptions {
    * `true` draws every `<text>` as glyph outlines (RR-64): `<use>` of outlines kept once per slide in `<defs>`, so the SVG needs
    * no font and looks the same in every viewer (about 40 KB a slide over the core example decks, against 0.5 to 4 MB of embedded
    * faces). Needs the fonts handle `loadFonts()` returns (`text-as-paths-needs-fonts` otherwise). The text is no longer text: it
-   * cannot be selected, searched or edited in place, and each outlined element is a `role="img"` group labelled with its text for
-   * assistive technology. Each element keeps its `data-opf-*` trace. Text in a colour or bitmap font stays text
-   * (`text-as-paths-kept-text`). Use it for thumbnails, previews and portable SVG files, not for an editing surface or the
-   * vector PDF (which keeps real text from `<text>` SVG). Default false.
+   * cannot be edited in place. The glyphs are shaped by HarfBuzz (the browser's shaper; the Node handle always, a browser handle
+   * given `shapeWasm`), are hidden from assistive technology, and each outlined line is also invisible real text pinned to the
+   * drawn width, so screen readers, selection, copy and find-in-page get the words. Each element keeps its `data-opf-*` trace.
+   * A run stays text, reported as `text-as-paths-fallback` with a `reason`, when its font is a colour or bitmap font
+   * (`"colour-font"`), its face's fsType restricts embedding (`"restricted"`), or it has no pinned width and HarfBuzz and the
+   * layout's measurement disagree on it (`"shaping"`). Use it for thumbnails, previews and portable SVG files, not for an editing
+   * surface or the vector PDF (which keeps real text from `<text>` SVG). Default false.
    */
   textAsPaths?: boolean;
+  /**
+   * `false` embeds whole faces (RR-65). By default, with a fonts handle that carries `subsets` (the Node `loadFonts` handle, a browser
+   * handle given `subsetWasm`), each face an SVG embeds is cut to the characters the slide draws, keeping every layout feature, so the
+   * browser draws it exactly like the whole face (over the core example decks a slide's SVG falls from 2.4 MB to 59 KB on average).
+   * Faces whose license does not allow a modified version under their own name (Carlito, Raleway, Lora, Playfair Display, PT Serif,
+   * Merriweather Sans, Source Sans 3), whose fsType forbids subsetting, or that a host supplied, are always embedded whole. Set it to
+   * false for an SVG whose text will be edited outside the renderer.
+   */
+  subsetFonts?: boolean;
   /** `"chain"` (default): a character the resolved face lacks is drawn with the first bundled face that has it, and reported as `font-glyph-fallback`. `"none"`: exact faces, a missing glyph raises `missing-glyph`. */
   glyphFallback?: "chain" | "none";
   /** Unscaled reference-pixel clearance around supplied vector text outlines; default 1. */

package/dist/svg.js

@@ -22,6 +22,8 @@ import { disabledFeaturesStyle } from "./font-compatibility.js";
 import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { isDatasetChart, isDatasetTable, renderCatalogChart } from "./charts.js";
 import { renderCaption, renderFootnotes } from "./annotations.js";
+import { drawnFaces } from "./drawn-faces.js";
+import { dataUrlFsType, embeddingAllowed } from "./font-fstype.js";
 
 export const packageName = "@openpresentation/opf-render";
 
@@ -641,11 +643,14 @@ function bindSlide(presentation, index, context) {
 // `embeddedFonts` list). The renderer reads the two as plain options from here on. `embedFonts: false` (RR-61) keeps the
 // measurement and drops the faces, for a host whose page already holds them.
 // `textAsPaths: true` (RR-64) draws text as glyph outlines with the handle's `outlines` engine (a `loadFonts` handle carries one).
+// `subsetFonts: false` (RR-65) embeds whole faces; by default a handle with a subset engine (`fonts.subsets`) cuts each embedded
+// face to the characters the slide draws.
 function normalizeOptions(options) {
-  const { fonts, embedFonts, textAsPaths, ...rest } = options ?? {};
+  const { fonts, embedFonts, textAsPaths, subsetFonts, ...rest } = options ?? {};
+  if (subsetFonts !== undefined && typeof subsetFonts !== "boolean") throw new OPFRenderError("invalid-render-options", "subsetFonts must be true or false.", { option: "subsetFonts" });
   if (textAsPaths !== undefined && typeof textAsPaths !== "boolean") throw new OPFRenderError("invalid-render-options", "textAsPaths must be true or false.", { option: "textAsPaths" });
   if (textAsPaths && typeof fonts?.outlines?.outlineSlideText !== "function") throw new OPFRenderError("text-as-paths-needs-fonts", "textAsPaths needs the fonts handle loadFonts() returns (from /fonts-node or /fonts-browser), passed as `fonts`.", { option: "textAsPaths" });
-  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: embedFonts === false ? undefined : fonts?.embeddedFonts, ...(textAsPaths ? { outlines: fonts.outlines } : {}) };
+  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: embedFonts === false ? undefined : fonts?.embeddedFonts, ...(textAsPaths ? { outlines: fonts.outlines } : {}), ...(subsetFonts !== false && fonts?.subsets ? { subsets: fonts.subsets } : {}) };
 }
 
 /**
@@ -722,7 +727,7 @@ function renderResolvedSlide(resolved, slideIndex, options) {
     content = outlined.content;
     glyphs = outlined.defs;
   }
-  const children = [glyphs, renderEmbeddedFonts(embeddedFontsFor(options.embeddedFonts, content)), ...content].filter(Boolean);
+  const children = [glyphs, renderEmbeddedFonts(embeddedFontsFor(options.embeddedFonts, content, options.subsets, diagnostic => reportDiagnostic(diagnostic, options))), ...content].filter(Boolean);
   // FF-44: Chromium (123+) trims adjacent fullwidth punctuation by default (CSS text-spacing-trim: normal; a sequence such as
   // 「」。 is up to 10 percent narrower), but measurement and PowerPoint advance every such character by its full width, so the browser
   // would stretch the glyphs back to the pinned textLength. space-all keeps the drawn advances equal to the measured ones. Only slides
@@ -1861,10 +1866,11 @@ function codeSyntax(item, layout, bound, options) {
 // the SVG names is one the browser can never select, so leaving it out changes no pixel. Only a face flagged embed:"always" is
 // embedded in every SVG. RR-59: each drawn style is checked on its own, so a family keeps an exactly matched face and, for
 // a drawn style none of its faces matches (a weight the family lacks), every face the browser could choose from.
-function embeddedFontsFor(fonts = [], content) {
+function embeddedFontsFor(fonts = [], content, subsets, report = () => {}) {
   if (!fonts.length) return fonts;
   fonts.forEach(assertEmbeddableFont);
-  const drawn = drawnFaces(content.join("\n"));
+  const characters = subsets ? new Map() : undefined;
+  const drawn = drawnFaces(content.join("\n"), characters);
   const wanted = font => {
     const triples = drawn.get(String(font.family).toLowerCase());
     if (!triples) return false;
@@ -1874,33 +1880,28 @@ function embeddedFontsFor(fonts = [], content) {
       return matching.length ? matching.includes(font) : true;
     });
   };
-  return fonts.filter(font => font?.embed === "always" || wanted(font));
-}
-
-const FONT_WEIGHT_KEYWORDS = { normal: "400", bold: "700" };
-/** family (lowercase) to the set of "weight|style" pairs the markup draws text in. */
-function drawnFaces(markup) {
-  const drawn = new Map();
-  const tokens = /<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|[^<]+/g;
-  const stack = [{ families: [], weight: "400", style: "normal", text: false }];
-  const attribute = (attributes, name) => { const found = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(attributes); return found ? found[1] ?? found[2] : undefined; };
-  for (const [token, close, name, attributes, selfClose] of markup.matchAll(tokens)) {
-    const top = stack.at(-1);
-    if (name === undefined) {
-      if (top.text && /\S/.test(token)) for (const family of top.families) { const set = drawn.get(family) ?? new Set(); set.add(`${top.weight}|${top.style}`); drawn.set(family, set); }
-      continue;
-    }
-    if (close) { if (stack.length > 1) stack.pop(); continue; }
-    const family = attribute(attributes, "font-family"), weight = attribute(attributes, "font-weight"), style = attribute(attributes, "font-style");
-    const next = {
-      families: family === undefined ? top.families : family.split(",").map(item => item.trim().replace(/^&quot;|&quot;$|^["']|["']$/g, "").toLowerCase()).filter(Boolean),
-      weight: weight === undefined ? top.weight : FONT_WEIGHT_KEYWORDS[weight.trim()] ?? weight.trim(),
-      style: style === undefined ? top.style : /italic|oblique/.test(style) ? "italic" : "normal",
-      text: top.text || name === "text",
-    };
-    if (!selfClose) stack.push(next);
-  }
-  return drawn;
+  const drawnOrAlways = fonts.filter(font => font?.embed === "always" || wanted(font));
+  const used = drawnOrAlways.filter(embeddable);
+  const refused = drawnOrAlways.filter(font => !embeddable(font));
+  if (refused.length) report({ code: "font-embedding-restricted", faces: refused.map(font => ({ fontFamily: font.family, weight: font.weight, italic: Boolean(font.italic), fsType: embeddingChecked.get(font).fsType })),
+    message: `${[...new Set(refused.map(font => `'${font.family}'`))].join(", ")} forbid${refused.length === 1 ? "s" : ""} embedding (OS/2 fsType), so the SVG names ${refused.length === 1 ? "it" : "them"} without the font data; a viewer without the font draws the generic family.` });
+  // RR-65: each face cut to the characters the slide draws in its family (the handle's subset engine decides whether the face
+  // may be subset at all). A face no text draws (embed: "always") stays whole.
+  if (!subsets) return used;
+  return used.map(font => {
+    const points = characters.get(String(font.family).toLowerCase());
+    return points?.size ? { ...font, dataUrl: subsets.subsetDataUrl(font, points) } : font;
+  });
+}
+
+// RR-76: a face whose OS/2 fsType forbids embedding (restricted, or bitmap-only: an SVG carries outlines) is never written as
+// @font-face data. The SVG still names its family, so a viewer without the font draws the generic family; a diagnostic says
+// why. The check reads only the font's table directory and its fsType bytes, once per face object and data URL.
+const embeddingChecked = new WeakMap();
+function embeddable(font) {
+  let checked = embeddingChecked.get(font);
+  if (!checked || checked.dataUrl !== font.dataUrl) { const fsType = dataUrlFsType(font.dataUrl); checked = { dataUrl: font.dataUrl, fsType, allowed: embeddingAllowed(fsType) }; embeddingChecked.set(font, checked); }
+  return checked.allowed;
 }
 
 // Every supplied face is checked, drawn or not, so a bad entry fails on any slide. The data URI check is remembered per face

package/dist/text-paths.js

@@ -11,10 +11,11 @@
 // the font's own metrics. Text drawn with a colour or bitmap font (COLR, CBDT, sbix, SVG tables) stays <text>, reported as
 // `text-as-paths-kept-text`, and the SVG then embeds that face as usual.
 
-import { FontLibrary } from "./pdf-fonts.js";
-import { layoutText } from "./pdf-text.js";
-import { ROOT_STYLE, attributesOf, inheritStyle, parseLength } from "./pdf-style.js";
-import { decodeEntities, escapeAttribute, parseXml } from "./pdf-xml.js";
+import { FontLibrary, shape as fontkitShape } from "./pdf-fonts.js";
+import { featuresOf, layoutText } from "./pdf-text.js";
+import { ROOT_STYLE, attributesOf, inheritStyle, parseFontFamilies, parseLength } from "./pdf-style.js";
+import { openTypeLanguage } from "./script-fonts.js";
+import { decodeEntities, escapeAttribute, escapeText, parseXml } from "./pdf-xml.js";
 
 const TOKENS = /<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|[^<]+/g;
 const ATTRIBUTE = /([^\s=/>"']+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
@@ -58,15 +59,20 @@ export function outlineLibrary(fonts) {
 
 function newLibrary(fonts) {
   const fallback = fonts?.registry?.fallbackFamily ?? "Roboto";
-  return new FontLibrary({ genericFamilies: () => [fallback] });
+  const library = new FontLibrary({ genericFamilies: () => [fallback] });
+  library.restricted = new Set();
+  return library;
 }
 
-// The face is matched by the family, weight and style the registry gives it, the ones the SVG names.
+// The face is matched by the family, weight and style the registry gives it, the ones the SVG names. A CFF face can be outlined
+// (only the PDF cannot subset it); a face whose fsType restricts embedding is never outlined: its text stays text.
 function addFace(library, data, family, described) {
   const face = library.addData(data, "fonts", family);
   if (!face || face.outlineStyled) return;
   if (Number.isInteger(described?.weight)) face.weight = described.weight;
   if (typeof described?.italic === "boolean") face.italic = described.italic;
+  if (face.unusable === "pdf-font-unsupported-format" && face.font) face.embeddable = true;
+  if (face.unusable === "pdf-font-embedding-restricted") for (const name of face.names) library.restricted.add(name);
   face.outlineStyled = true;
 }
 
@@ -82,23 +88,30 @@ function decodeBase64(text) {
  * `rootStyle` holds what the <svg> element gives its children (lang), `report(diagnostic)` receives what cannot be outlined
  * and `fail(code, message)` builds the error thrown when no face draws a text. Returns the new content and the <defs> markup.
  */
-export function outlineSlideText(content, { library, rootStyle = {}, report = () => {}, fail }) {
+export function outlineSlideText(content, { library, shaper, rootStyle = {}, report = () => {}, fail }) {
   const defs = new Map();
   const reported = new Set();
   const env = {
     fonts: library,
     defaults: [],
     splitByOwner: true,
+    // HarfBuzz, the browser's shaper, when the handle carries one (RR-64 phase 2); fontkit otherwise.
+    ...(shaper ? { shape: (face, text, options) => shaper.shape(face.hash, face.data, text, { ...options, language: options.lang }) } : {}),
     // The renderer reports its own font substitutions and missing glyphs while it lays the slide out.
     diagnostic: () => {},
     missing: () => {},
     unavailable: (families) => fail("text-as-paths-font-unavailable", `No font face can outline text in ${families.length ? `'${families.join("', '")}'` : "the requested family"}; pass the fonts handle the slide was laid out with.`),
   };
   const base = inheritStyle(ROOT_STYLE, rootStyle);
-  const keep = (family) => {
-    if (reported.has(family)) return;
-    reported.add(family);
-    report({ code: "text-as-paths-kept-text", fontFamily: family, message: `'${family}' is a colour or bitmap font, which has no plain outlines; its text stays text and the SVG embeds the face.` });
+  const REASONS = {
+    "colour-font": "is a colour or bitmap font, which has no plain outlines",
+    restricted: "forbids embedding (OS/2 fsType), so its outlines are not written",
+    shaping: "shapes differently in HarfBuzz and in the layout's measurement on text with no pinned width",
+  };
+  const keep = (family, reason) => {
+    if (reported.has(`${family}|${reason}`)) return;
+    reported.add(`${family}|${reason}`);
+    report({ code: "text-as-paths-fallback", reason, fontFamily: family, message: `'${family}' ${REASONS[reason]}; that text stays text and the SVG embeds its face.` });
   };
   const outlined = content.map((markup) => typeof markup === "string" && markup.includes("<text") ? outlineMarkup(markup, base, env, defs, keep) : markup);
   const definitions = [...defs].map(([id, d]) => `<path id="${id}" d="${d}"/>`).join("");
@@ -150,14 +163,14 @@ function outlineText(source, parentStyle, env, defs, keep) {
   const node = parseXml(`<svg>${source}</svg>`)?.children.find((child) => child.name === "text");
   if (!node) return source;
   const { runs } = layoutText(node, env, parentStyle, null);
-  const colour = runs.find((run) => COLOUR_TABLES.some((table) => run.face.font.directory?.tables?.[table]));
-  if (colour) { keep([...colour.face.names][0]); return source; }
   const attrs = Object.entries(node.attrs).filter(([key]) => !TEXT_ONLY.has(key));
-  const hidden = node.attrs["aria-hidden"] === "true", words = logicalText(runs);
-  const label = hidden || !words ? [] : [["role", "img"], ["aria-label", words]];
-  const groups = [];
+  const hidden = node.attrs["aria-hidden"] === "true";
+  const groups = [], outlined = [];
   for (const run of runs) {
-    const drawn = drawRun(run, defs);
+    const reason = fallbackReason(run, env);
+    if (reason) keep([...run.face.names][0], reason);
+    else outlined.push(run);
+    const drawn = reason ? keptRun(run) : drawRun(run, defs);
     if (!drawn) continue;
     const owner = run.owner !== node && run.owner ? run.owner : null;
     const last = groups.at(-1);
@@ -168,14 +181,53 @@ function outlineText(source, parentStyle, env, defs, keep) {
     const trace = owner ? Object.entries(owner.attrs).filter(([key]) => key.startsWith("data-")) : [];
     return trace.length ? element("g", trace, parts.join("")) : parts.join("");
   }).join("");
-  return element("g", [...attrs, ...label], body);
+  // RR-64 phase 3: the glyphs are hidden from assistive technology and the words are real text again, invisible, one <text> per
+  // line in reading order, pinned to the drawn width: a screen reader reads text (FA-30), and selection, copy and find work.
+  return element("g", attrs, body + (hidden ? "" : readableText(outlined)));
+}
+
+// The invisible text layer of the outlined runs (runs that stayed text are text already): per line, the runs in logical order, at
+// the line's left edge (its right edge for a right-to-left line), in the generic family (no face is embedded for it), sized like
+// the first run and stretched to the runs' drawn width.
+function readableText(runs) {
+  const lines = [];
+  for (const run of runs) { let line = lines.find((item) => item.chunk === run.chunk); if (!line) lines.push(line = { chunk: run.chunk, runs: [] }); line.runs.push(run); }
+  return lines.map(({ chunk, runs: parts }) => {
+    const words = [...parts].sort((a, b) => a.start - b.start).map((run) => run.logical).join("");
+    if (!/\S/.test(words)) return "";
+    const left = Math.min(...parts.map((run) => run.x)), width = parts.reduce((sum, run) => sum + run.width, 0), first = parts[0];
+    return element("text", [["x", fixed(chunk.rtl ? left + width : left)], ["y", fixed(first.y)], ["font-family", "sans-serif"], ["font-size", fixed(first.size)], ["fill", "none"],
+      ["direction", chunk.rtl ? "rtl" : undefined], ["xml:space", "preserve"], ["textLength", fixed(width)], ["lengthAdjust", "spacingAndGlyphs"], ["lang", first.style.lang]], escapeText(words));
+  }).join("");
+}
+
+// Why a run stays text, or null: a colour or bitmap font; a family whose fsType restricts embedding (the run was laid out with
+// another face); or, with HarfBuzz shaping, a run with no pinned width whose HarfBuzz advance differs from the fontkit advance
+// the layout measured by more than 0.1 px (inside a textLength the run is scaled to the measured width, as the browser does).
+function fallbackReason(run, env) {
+  if (COLOUR_TABLES.some((table) => run.face.font.directory?.tables?.[table])) return "colour-font";
+  for (const family of parseFontFamilies(run.style["font-family"])) {
+    if (env.fonts.restricted?.has(family.toLowerCase())) return "restricted";
+    if (run.face.names.has(family.toLowerCase())) break;
+  }
+  if (env.shape && !run.scope) {
+    const direction = run.level % 2 === 1 ? "rtl" : "ltr", language = openTypeLanguage(run.style.lang ?? run.style["xml:lang"]);
+    const measured = fontkitShape(run.face, run.text, { features: featuresOf(run.style), language, direction }).reduce((sum, glyph) => sum + glyph.advance, 0);
+    const shaped = run.glyphs.reduce((sum, glyph) => sum + glyph.advance, 0);
+    if (Math.abs(measured - shaped) * run.scale > 0.1) return "shaping";
+  }
+  return null;
 }
 
-// The text in reading order: runs are placed in visual order, so a right-to-left chunk is read from its logical text.
-function logicalText(runs) {
-  const chunks = [];
-  for (const run of runs) if (!chunks.includes(run.chunk)) chunks.push(run.chunk);
-  return chunks.map((chunk) => chunk.logical).join(" ").replace(/\s+/g, " ").trim();
+// A run that stays text, where layoutText placed it: its own family, size and paint, its width pinned with textLength.
+function keptRun(run) {
+  const style = run.style, rtl = run.level % 2 === 1;
+  const attrs = [["x", fixed(rtl ? run.x + run.width : run.x)], ["y", fixed(run.y)], ["font-family", style["font-family"]], ["font-size", fixed(run.size)],
+    ["font-weight", style["font-weight"]], ["font-style", style["font-style"] === "normal" ? undefined : style["font-style"]], ["fill", style.fill],
+    ["fill-opacity", style["fill-opacity"] === "1" ? undefined : style["fill-opacity"]], ["direction", rtl ? "rtl" : undefined], ["xml:space", "preserve"],
+    ["textLength", fixed(run.width)], ["lengthAdjust", "spacingAndGlyphs"], ["lang", style.lang]];
+  const text = `<text${attrs.filter(([, value]) => value !== undefined && value !== null && value !== "").map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("")}>${escapeAttribute(run.logical)}</text>`;
+  return run.link ? element("a", Object.entries(run.link.node?.attrs ?? { href: run.link.href }), text) : text;
 }
 
 function drawRun(run, defs) {
@@ -204,9 +256,9 @@ function drawRun(run, defs) {
   }
   if (style.visibility && style.visibility !== "visible") paint.push(["visibility", style.visibility]);
   const glyphs = uses.length ? `<g transform="matrix(${precise(scale * scaleX)} 0 0 ${precise(-scale)} ${fixed(run.x)} ${fixed(run.y)})">${uses.join("")}</g>` : "";
-  const drawn = element("g", paint, glyphs + decorations.join(""));
-  // A link inside the text keeps its element's attributes (href, rel, target).
-  return run.link ? element("a", Object.entries(run.link.node?.attrs ?? { href: run.link.href }), drawn) : drawn;
+  const drawn = element("g", [...paint, ["aria-hidden", "true"]], glyphs + decorations.join(""));
+  // A link inside the text keeps its element's attributes (href, rel, target) and is named by its words.
+  return run.link ? element("a", [...Object.entries(run.link.node?.attrs ?? { href: run.link.href }), ["aria-label", run.logical]], drawn) : drawn;
 }
 
 // Underline, line-through and overline in the text colour, from the font's own metrics (the vector PDF draws the same).
@@ -272,7 +324,7 @@ export function textOutlines(fonts) {
     outlineSlideText: (content, options) => {
       const library = outlineLibrary(fonts);
       if (!library) throw options.fail("text-as-paths-needs-fonts", "textAsPaths needs font faces to outline: pass the handle loadFonts() returns as `fonts`.");
-      return outlineSlideText(content, { ...options, library });
+      return outlineSlideText(content, { ...options, library, shaper: fonts.shaper });
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-render",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Deterministic local OPF renderer for SVG, PNG, and PDF output.",
   "license": "MIT",
   "type": "module",
@@ -142,6 +142,7 @@
     "@openpresentation/opf": "^0.17.0",
     "bidi-js": "1.1.0",
     "fontkit": "^2.0.4",
+    "harfbuzzjs": "1.6.2",
     "pako": "1.0.11"
   },
   "peerDependencies": {
@@ -387,7 +388,6 @@
     "@resvg/resvg-js": "2.6.2",
     "axe-core": "4.13.0",
     "esbuild": "0.28.2",
-    "harfbuzzjs": "1.6.2",
     "pdf-lib": "1.17.1",
     "pdfjs-dist": "6.3.289",
     "playwright": "1.63.0",