@openpresentation/opf-render 0.16.0 → 0.17.0

package/README.md

@@ -156,6 +156,8 @@ Installed size, measured on Windows with `npm install --ignore-scripts`, unpacke
 
 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).
+
 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).
 
 ```js
@@ -489,6 +491,8 @@ renderSvg(template, { variables: { client: 'Globex', revenue: 1250000 } });
 
 A template previews with each unfilled variable's `example` and reports `variable-example-used` through `onDiagnostic` (a built-in variable such as `{{speaker.name}}` whose document field is missing reports `variable-builtin-missing`; built-ins read the document's own `speaker`, `organization` and `name`, and a template preview keeps an absent one visible); a variable with no example keeps its `{{id}}` text. A normal deck with an unfilled required variable throws `OPFRenderError` with code `unfilled-variables`, and a value of the wrong kind throws `invalid-variables`. `resolvePresentation(...).presentation` is the concrete deck. `variables: false` draws the document as authored, with tokens and `var:` references visible (the editor canvas's view of a template, so inline edits never overwrite a token). Decks without content variables are untouched. See [templates and variables](https://github.com/OpenPresentation/opf/blob/main/docs/templates-and-variables.md).
 
+Slide-scoped built-ins (FA-31): `{{slide.number}}`, `{{slide.section}}` and `{{deck.slideCount}}` work in any string of a slide (titles, body text, table cells, notes) and in header and footer `text`. The deck-wide pass leaves them as written; the renderer draws each slide from core's substituted slide (`resolveSlideContext(...).slide`), numbered by its position in the deck you render (run core `paginate` first and the numbers and the count are the paginated ones), so the body and the footer show the same number. A zone's `text` is one furniture part (`data-opf-furniture-field="text"`); the former `organization`, `speaker`, `section` and `slideNumber` flags are gone, so write `{{organization.name}}` or `{{slide.number}}` in the `text`.
+
 ### Symbol-encoded families: Symbol, Wingdings, Webdings (FF-45)
 
 Symbol, Wingdings, Wingdings 2, Wingdings 3 and Webdings keep their glyphs at the 224 codes 0x20..0xFF of a Microsoft Symbol cmap, not at Unicode code points, and none of them may be bundled. A run or design font in one of them no longer fails with `font-encoding-required`: each character is normalised to its code (the private-use character U+F0xx that Office writes for Insert > Symbol and `a:sym` runs, or the Windows-1252 character of the code, so "l" and U+F06C are the same Wingdings bullet) and mapped through core's reversible, version-specific tables (`@openpresentation/opf` `spec/reference/symbol-font-encodings.json`, read through `@openpresentation/opf/symbol-font-encodings`, not copied here; `mapSymbolText('Wingdings', 'l')` gives U+26AB) to the Unicode equivalent, which the first loaded face of the family's chain draws: `SYMBOL_PREVIEW_FACES` is Noto Sans Symbols 2, Noto Sans Symbols, Noto Sans Math, Noto Sans for the dingbat fonts and Noto Sans (Greek letters, digits, punctuation) first for Symbol. The three symbol packages are optional peers of the script pack under the key `Zsym` (`scripts: ['Zsym']`; `scripts: 'auto'` selects it when a run, `design.fonts` or a font scheme names one of the families; `fonts.ensure(presentation)`): `@expo-google-fonts/noto-sans-symbols-2`, `noto-sans-symbols` and `noto-sans-math`, OFL-1.1, together about 1.2 MiB. Every code the tables map (1059 of 1120: Symbol 189, Wingdings 222, Wingdings 2 217, Wingdings 3 208, Webdings 223) draws a real glyph when the pack is loaded; the 61 codes without a Unicode equivalent (the Wingdings 0xFF Windows logo, unassigned codes) draw the placeholder U+25A1. Each glyph is one positioned tspan at the advance of the verified Windows font (Wingdings 5.01, Wingdings 2 and 3 1.55, Webdings 5.01, Symbol 5.01), in measurement and drawing alike, so line breaks and bullet gaps follow PowerPoint; the open glyph keeps its shape and is compressed to its code's advance only when wider, never stretched. Characters that are not codes (a CJK letter in a Wingdings run) draw as themselves. Without the pack, Symbol's Greek letters, digits and punctuation draw with the office pack's Noto Sans, the other codes draw U+FFFD, and the `font-glyph-fallback` diagnostic (`codes`, `placeholder`) names the pack; a registry with no chain face and no `fallbackFamily` throws `font-encoding-required`, naming it too. `resolveFont` and `resolveStyle` report `symbolEncoding` with the substitute face, so exporters keep writing the chosen family and the original characters, and the PPTX names Wingdings with its codes. The symbol faces also end the glyph fallback chain. Appearance is the open face's, not Microsoft's; native PowerPoint verification of the exported runs is separate (FF-46).

package/dist/deck-runtime.js

@@ -2,6 +2,7 @@
 // decides which slides play (hidden ones do not), renders each slide once with the renderer's own SVG output (renderSlideSvg:
 // there is no second layout engine) behind a face-level font gate, and synchronizes windows over a BroadcastChannel.
 // Nothing here fetches anything but the font files the host's font root serves.
+import { resolveSlideVariables } from "@openpresentation/opf";
 import { renderSlideSvg } from "./svg.js";
 
 /** Error raised for a deck that cannot be read, rendered or loaded. */
@@ -49,7 +50,10 @@ export function presentableIndexes(document, { includeHidden = false } = {}) {
 
 /** Facts about one slide for a counter, a label, a thumbnail or the speaker view. `notes` is plain text only. */
 export function slideInfo(document, index) {
-  const slide = isObject(document?.slides?.[index]) ? document.slides[index] : {};
+  const authored = isObject(document?.slides?.[index]) ? document.slides[index] : {};
+  // FA-31: the strings a counter, label or speaker view shows hold this slide's number, section and the deck's slide count, as the drawn slide does.
+  const { title: shownTitle, subtitle, tag, notes, section } = resolveSlideVariables({ title: authored.title, subtitle: authored.subtitle, tag: authored.tag, notes: authored.notes, section: authored.section }, { slideNumber: Math.max(1, index + 1), slideCount: Math.max(1, document?.slides?.length ?? 1) });
+  const slide = { ...authored, title: shownTitle, subtitle, tag, notes, section };
   const title = plainText(slide.title).trim() || plainText(slide.subtitle).trim() || plainText(slide.tag).trim();
   return {
     index,

package/dist/font-registry.js

@@ -1,6 +1,6 @@
 import { create } from "fontkit";
 import { FONT_COMPATIBILITY, disabledFeaturesFor } from "./font-compatibility.js";
-import { adjustedFontSize, openTypeLanguage, scriptFontAliases, sizeAdjustFor } from "./script-fonts.js";
+import { adjustedFontSize, createScriptFonts, openTypeLanguage, scriptFontAliases, sizeAdjustFor } from "./script-fonts.js";
 import { fontPolicyFor } from "@openpresentation/opf/font-policy";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { SYMBOL_SCRIPT, isSymbolEncodedFamily, symbolEncodingFamily, symbolPreviewFaces } from "./symbol-fonts.js";
@@ -289,9 +289,12 @@ export function createFontRegistry(entries, options = {}) {
     const {value,scale}=metrics(text,size,style,true),bounds=value.outline,drawn=adjustedFontSize(size,scale===1?undefined:scale);
     return bounds===null?null:{x:bounds.x*drawn,y:bounds.y*drawn,width:bounds.width*drawn,height:bounds.height*drawn};
   };
+  // resolveFont lets exporters tell a substitute from the chosen family (FF-31). forScripts (opf#485) is the script planner core
+  // validate asks for each slide's measurement, so its layout checks measure script runs in the faces this renderer draws.
+  const textMeasurement={measure,resolveStyle,outlineBounds,resolveFont:style=>resolve(style).resolution};
+  textMeasurement.forScripts=profile=>createScriptFonts(profile,textMeasurement).textMeasurement;
   return {
-    // resolveFont lets exporters tell a substitute from the chosen family (FF-31).
-    textMeasurement: {measure,resolveStyle,outlineBounds,resolveFont:style=>resolve(style).resolution},
+    textMeasurement,
     resolveFont(style) { return resolve(style).resolution; },
     clearSubstitutions() { substitutions.clear(); },
     get substitutions() { return [...substitutions.values()]; },

package/dist/fonts-browser.js

@@ -2,6 +2,7 @@ import { createFontRegistry, OPFFontError } from "./font-registry.js";
 import { lazyFontEntries, lazyFontList, normalizeExtraLazyFonts } from "./lazy-font-list.js";
 import { lazyFacesNeeded } from "./lazy-fonts.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
+import { textOutlines } from "./text-paths.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";
@@ -293,6 +294,8 @@ export async function loadFonts({ faces = [], ...options } = {}) {
     textMeasurement: registry.textMeasurement,
     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 }),
     manifest: BUNDLED_FONT_MANIFEST,
     get substitutions() { return registry.substitutions; },
     /**

package/dist/fonts-node.js

@@ -6,6 +6,7 @@ import { createHash } from "node:crypto";
 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";
 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";
@@ -272,6 +273,8 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
     useBundledFonts: false,
     loadSystemFonts: false,
     registry,
+    // RR-64: the outline engine `renderSvg(deck, { fonts, textAsPaths: true })` draws text with, over this registry's faces.
+    outlines: textOutlines({ registry }),
     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

@@ -49,7 +49,11 @@ export interface RenderFonts {
   useBundledFonts?: boolean;
   /** Whether the raster conversion loads system fonts. Default false (the output never depends on the machine). */
   loadSystemFonts?: boolean;
+  /** The outline engine `textAsPaths: true` draws text with (RR-64); a `loadFonts` handle carries one over its registry's faces. */
+  outlines?: TextOutlines;
 }
+/** 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. */
 export interface EnsureResult { scripts: string[]; lazy: LazyFont[]; uncovered: string[] }
 /** The fonts handle `loadFonts()` returns from `/fonts-node` and `/fonts-browser`: pass it as `{ fonts }` to every deck-level function. */
@@ -58,6 +62,8 @@ export interface FontsHandle extends RenderFonts {
   readonly embeddedFonts: EmbeddedFont[];
   /** The face registry behind the handle (shaping, resolution, lazy and script loading). */
   readonly registry: FontRegistry;
+  /** The outline engine for `textAsPaths: true` (RR-64), over this registry's faces, including faces `ensure` loads later. */
+  readonly outlines: TextOutlines;
   /** The pinned manifest of the bundled font packages. */
   readonly manifest: { readonly version: number; readonly packages: readonly object[] };
   /** The substitutions made so far (a requested family drawn with another face), as `registry.substitutions`. */

package/dist/index.d.ts

@@ -60,6 +60,16 @@ export interface RenderSvgOptions {
   fonts?: RenderFonts;
   /** `false` writes no `@font-face` data into the SVG (RR-61): the fonts handle still measures and the SVG still names the families, for a host whose page already has the faces (a browser `loadFonts` handle adds them to the document). Default true: each SVG embeds the faces of `fonts.embeddedFonts` its own text draws. */
   embedFonts?: boolean;
+  /**
+   * `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.
+   */
+  textAsPaths?: 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

@@ -59,7 +59,7 @@ export function layoutText(textNode, env, parentStyle, link) {
     const preserve = own["xml:space"] === "preserve" || /^pre/.test(own["white-space"] ?? "");
     for (const child of node.children) {
       if (child.text !== undefined) {
-        for (const character of child.text.replace(/[\r\n\t]/g, " ")) chars.push({ ch: character, style: own, scope: nextScope, decoration: nextDecoration, link: activeLink, preserve });
+        for (const character of child.text.replace(/[\r\n\t]/g, " ")) chars.push({ ch: character, style: own, scope: nextScope, decoration: nextDecoration, link: activeLink, preserve, owner: node });
       } else if (isElement(child)) {
         if (child.name === "tspan" || child.name === "textPath" || child.name === "tref") walk(child, own, nextScope, nextDecoration, activeLink);
         else if (child.name === "a") {
@@ -89,7 +89,8 @@ export function layoutText(textNode, env, parentStyle, link) {
   const styleIds = new Map();
   const faceCache = new Map();
   const linkIds = new Map();
-  const runsByChunk = chunks.map((chunk) => buildRuns(chunk, env, styleIds, faceCache, linkIds));
+  const ownerIds = new Map();
+  const runsByChunk = chunks.map((chunk) => buildRuns(chunk, env, styleIds, faceCache, linkIds, ownerIds));
 
   // textLength: the renderer gives lines and tabs an exact width; reproduce it per scope over all its runs.
   const scopeWidth = new Map();
@@ -155,7 +156,7 @@ function collapseWhitespace(chars) {
   for (const char of kept) chars.push(char);
 }
 
-function buildRuns(chunk, env, styleIds, faceCache, linkIds) {
+function buildRuns(chunk, env, styleIds, faceCache, linkIds, ownerIds) {
   const text = chunk.chars.map((char) => char.ch).join("");
   const baseDirection = chunk.chars[0].style.direction === "rtl" ? "rtl" : "ltr";
   // Levels per UTF-16 unit; characters take the level of their first unit.
@@ -174,9 +175,11 @@ function buildRuns(chunk, env, styleIds, faceCache, linkIds) {
     if (IGNORED.test(char.ch)) return;
     const level = levels[index];
     const resolved = pickFace(char, env, styleIds, faceCache);
-    const key = `${resolved.styleId}|${resolved.face.id}|${level}|${char.scope?.id ?? 0}|${linkId(linkIds, char.link)}|${[...char.decoration].sort().join(",")}`;
+    // RR-64: outlined text keeps each element's trace, so with `env.splitByOwner` a run never spans two elements.
+    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, chars: [], text: "", logical: "", weight: resolved.weight, italic: resolved.italic };
+      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 };
       runs.push(current);
     }
     current.logical += char.ch;

package/dist/script-font-pack.js

@@ -54,28 +54,23 @@ export function scriptPackageEntries(packages, {baseUrl}) {
 // Everywhere: the schema URL, embedded assets, catalog records, speaker notes, ids, image alt text and sources,
 // links, metadata and typed `extensions` passthrough. On the presentation: name (aria-label fallback), description,
 // filename, author, audience, purpose, tone, takeaway, duration, tags, narrative, language and version.
-// On a slide: beat. The organization (name), the speaker (name and title) and a slide's section are drawn only as
-// generated header/footer furniture (`organization: true` / `speaker: true` / `section: true` in a design), so they count
-// only when a design asks for them; built-in variables copy their values into slide strings before this runs. Everything else is drawn text: titles, text blocks, list items, runs, table cells, chart labels,
-// categories and series names, code, quotes, metrics, timelines, furniture text.
+// On a slide: beat. The organization (name), the speaker (name and title) and a slide's section are drawn only through the
+// built-in variables that read them ({{organization.name}}, {{speaker.title}}, {{slide.section}}, FA-31), so they count
+// only when a string the preview draws holds such a token. Everything else is drawn text: titles, text blocks, list items,
+// runs, table cells, chart labels, categories and series names, code, quotes, metrics, timelines, header and footer text.
 const UNDRAWN_KEYS = Object.freeze(["$schema", "assets", "catalogs", "notes", "id", "alt", "altText", "src", "url", "href", "link", "metadata", "extensions"]);
 const UNDRAWN_ROOT_KEYS = Object.freeze(["name", "description", "filename", "author", "authors", "creator", "audience", "purpose", "tone", "takeaway", "duration", "tags", "narrative", "language", "license", "version", "keywords"]);
 const UNDRAWN_SLIDE_KEYS = Object.freeze(["beat"]);
 const UNDRAWN_VALUE = /^(?:https?|data|blob|pkg|file|mailto):\S*$/i;
 
-/** True when a design in the presentation turns on generated `field` furniture (`organization`, `speaker` or `section`). */
-function furnitureUses(presentation, field) {
-  const designs = [presentation?.design, ...(Array.isArray(presentation?.slides) ? presentation.slides.map(slide => slide?.design) : [])];
-  const pattern = new RegExp(`"${field}"\\s*:\\s*true`);
-  return designs.some(design => design && pattern.test(JSON.stringify(design)));
-}
+// The built-in variables that copy a document value into drawn text: the inline token and the whole-field reference
+// (a logo or photo reference draws a picture, not text).
+const ORGANIZATION_TOKEN = /\{\{\s*organization\.|var:organization\.(?!logo\b)/;
+const SPEAKER_TOKEN = /\{\{\s*speaker\.|var:speaker\.(?!photo\b|image\b|avatar\b)/;
+const SECTION_TOKEN = /\{\{\s*slide\.section\s*[|}]/;
 
-/** The strings a preview of this presentation draws. */
-export function* drawnStrings(presentation) {
-  const undrawn = new Set(UNDRAWN_KEYS), undrawnRoot = new Set(UNDRAWN_ROOT_KEYS), undrawnSlide = new Set(UNDRAWN_SLIDE_KEYS);
-  if (!furnitureUses(presentation, "organization")) undrawnRoot.add("organization");
-  if (!furnitureUses(presentation, "speaker")) undrawnRoot.add("speaker");
-  if (!furnitureUses(presentation, "section")) undrawnSlide.add("section");
+/** The strings under `presentation`, skipping the keys in the three sets (root keys, slide keys, and everywhere). */
+function* walkStrings(presentation, undrawn, undrawnRoot, undrawnSlide) {
   function* visit(item, level) {
     if (typeof item === "string") { if (!UNDRAWN_VALUE.test(item)) yield item; }
     else if (Array.isArray(item)) for (const child of item) yield* visit(child, level === "slides" ? "slide" : level === "root" ? "deep" : level);
@@ -89,6 +84,18 @@ export function* drawnStrings(presentation) {
   yield* visit(presentation, "root");
 }
 
+/** The strings a preview of this presentation draws. */
+export function* drawnStrings(presentation) {
+  const undrawn = new Set(UNDRAWN_KEYS), undrawnRoot = new Set([...UNDRAWN_ROOT_KEYS, "organization", "speaker"]), undrawnSlide = new Set([...UNDRAWN_SLIDE_KEYS, "section"]);
+  // The organization, the speaker and a slide's section draw only where a drawn string reads them with a built-in variable.
+  for (const text of walkStrings(presentation, undrawn, undrawnRoot, undrawnSlide)) {
+    if (ORGANIZATION_TOKEN.test(text)) undrawnRoot.delete("organization");
+    if (SPEAKER_TOKEN.test(text)) undrawnRoot.delete("speaker");
+    if (SECTION_TOKEN.test(text)) undrawnSlide.delete("section");
+  }
+  yield* walkStrings(presentation, undrawn, undrawnRoot, undrawnSlide);
+}
+
 /**
  * The script profile of a presentation: core `resolveScriptFonts` output, exactly what the renderer plans
  * with. When it throws, the renderer ignores the document language, so the profile is empty and Han text is

package/dist/svg.d.ts

@@ -60,6 +60,16 @@ export interface RenderSvgOptions {
   fonts?: RenderFonts;
   /** `false` writes no `@font-face` data into the SVG (RR-61): the fonts handle still measures and the SVG still names the families, for a host whose page already has the faces (a browser `loadFonts` handle adds them to the document). Default true: each SVG embeds the faces of `fonts.embeddedFonts` its own text draws. */
   embedFonts?: boolean;
+  /**
+   * `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.
+   */
+  textAsPaths?: 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

@@ -540,7 +540,7 @@ function resolveContext(presentation, index, context) {
   }
 }
 
-function bindSlide(presentation, slide, index, context) {
+function bindSlide(presentation, index, context) {
   const slidePath = `slides.${index}`;
   // Core resolves the slide's canvas, layout, theme, colour scheme, font scheme and family names the one way every engine must
   // (slide design, deck design, theme, engine default), from the records the document embeds and the catalogs the host
@@ -548,6 +548,9 @@ function bindSlide(presentation, slide, index, context) {
   // `layout` composes automatically; one whose reference resolves nowhere does too, with an `unresolved-reference` diagnostic,
   // or the render fails under `strictReferences`.
   const slideContext = resolveContext(presentation, index, context);
+  // FA-31: every string the slide draws (titles, body text, table cells, notes) is the substituted slide: {{slide.number}}, {{slide.section}} and
+  // {{deck.slideCount}} hold this slide's number, its section and the deck's slide count, the same values the furniture draws. Core resolved them.
+  const slide = slideContext.slide;
   const layout = slideContext.options.layout;
   const placeholders = Array.isArray(layout?.placeholders) ? layout.placeholders : [];
   const titleBindings = [];
@@ -637,9 +640,12 @@ function bindSlide(presentation, slide, index, context) {
 // `options.fonts` is the handle `loadFonts()` returns (or any object with a `textMeasurement` and, to embed faces in the SVG, an
 // `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).
 function normalizeOptions(options) {
-  const { fonts, embedFonts, ...rest } = options ?? {};
-  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: embedFonts === false ? undefined : fonts?.embeddedFonts };
+  const { fonts, embedFonts, textAsPaths, ...rest } = options ?? {};
+  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 } : {}) };
 }
 
 /**
@@ -657,7 +663,7 @@ function resolveDeck(input, options) {
   }
 
   const context = { presentation, options };
-  const slides = presentation.slides.map((slide, index) => bindSlide(presentation, slide, index, context));
+  const slides = presentation.slides.map((_, index) => bindSlide(presentation, index, context));
 
   return {
     presentation,
@@ -700,7 +706,7 @@ function renderResolvedSlide(resolved, slideIndex, options) {
   const { width, height } = bound.design.dimensions;
   // The title may be TextRun[] (FA-10): the accessible name is its plain text.
   const title = (Array.isArray(bound.slide.title) ? flattenText(bound.slide.title) : bound.slide.title) ?? resolved.presentation.name ?? `Slide ${slideIndex + 1}`;
-  const content = [
+  let content = [
     renderBackground(bound, width, height, options),
     renderBranding(bound, resolved.presentation, width, height, options),
     ...renderSlideContent(bound, width, height, options),
@@ -709,7 +715,14 @@ function renderResolvedSlide(resolved, slideIndex, options) {
     renderFurniture(bound, resolved.presentation, width, height, options, "header"),
     renderFurniture(bound, resolved.presentation, width, height, options, "footer")
   ].filter(Boolean);
-  const children = [renderEmbeddedFonts(embeddedFontsFor(options.embeddedFonts, content)), ...content].filter(Boolean);
+  // RR-64: text as glyph outlines. The used-face rule below then embeds only the faces of text that stays text.
+  let glyphs = "";
+  if (options.outlines) {
+    const outlined = options.outlines.outlineSlideText(content, { rootStyle: lang ? { lang } : {}, report: diagnostic => reportDiagnostic(diagnostic, options), fail: (code, message) => new OPFRenderError(code, message, { slideIndex }) });
+    content = outlined.content;
+    glyphs = outlined.defs;
+  }
+  const children = [glyphs, renderEmbeddedFonts(embeddedFontsFor(options.embeddedFonts, content)), ...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
@@ -1732,12 +1745,30 @@ function nestedReset(style, run) {
   return parent && !disabledFeaturesStyle([run.stack ?? run.family].flat()[0]) ? RESET_POLICY_FEATURES : undefined;
 }
 
-function scriptLine(text, style, bound, type, { rtl = false, placement, trace, fontSize } = {}) {
+// RR-59 (#175): bidi rule L1 resets white space at the end of a line (with the isolate marks around it) to the paragraph level. A run
+// drawn as its own text chunk (a <text>, or a tspan with its own x) is such a line, and its paragraph is left to right, so the trailing
+// space of a right-to-left isolate drew at the run's right edge instead of its left, where it separates the run from the next one: at an
+// Arabic/Latin boundary the gap closed up (PowerPoint keeps it). A positioned run of a right-to-left line therefore draws without its
+// trailing white space, its glyphs starting after that white space's measured advance. Returns the white space ("" when there is none,
+// or when the text is all white space).
+function rtlTrailingSpace(text) {
+  const found = /\S(\s+)$/u.exec(text);
+  return found ? found[1] : "";
+}
+
+/**
+ * `runPlacement` ({x, width, fontSize}) positions the runs like `placement`, but only when the text plans into more than one run
+ * (RR-59, #175): a list entry's line has no placed origin from core, and drawn as one chunk of nested tspans resvg shapes the whole
+ * chunk with the outer face first and, when a fallback face covers every character, replaces every glyph with that face's (the Latin
+ * phrase of an Arabic item took a wider fallback face and ran into the bullet).
+ */
+function scriptLine(text, style, bound, type, { rtl = false, placement, runPlacement, trace, fontSize } = {}) {
   const value = String(text ?? "");
   const scripts = (style?.lang && bound.scriptFontsFor?.(style.lang)) || bound.scriptFonts;
   rtl = rtl && value !== "";
   const isolate = content => rtl ? `${RIGHT_TO_LEFT_ISOLATE}${content}${POP_DIRECTIONAL_ISOLATE}` : content;
   const runs = value && scripts ? scripts.plan(value, style) : [{ text: value, own: true }];
+  if (!placement && runPlacement && runs.length > 1) placement = runPlacement;
   // RR-38: PowerPoint's baseline of a line in Arabic Typesetting sits above core's (one em below the line top): the caller moves it up by `baselineShift` em.
   const shiftOf = list => { const shift = baselineShift(list); return shift ? { baselineShift: shift } : {}; };
   // FF-45: symbol runs (Wingdings, Symbol, Webdings codes drawn as their Unicode equivalents) are always positioned when the
@@ -1763,16 +1794,20 @@ function scriptLine(text, style, bound, type, { rtl = false, placement, trace, f
     advance += width;
     const start = offset;
     offset += run.symbol ? run.symbol.source.length : run.text.length;
+    // RR-59: a right-to-left run's trailing white space sits at its left edge (see rtlTrailingSpace); the glyphs draw after it.
+    const trail = rtl && !run.symbol ? rtlTrailingSpace(run.text) : "";
+    const drawn = trail ? run.text.slice(0, -trail.length) : run.text;
+    const gap = trail ? Math.min(width, Math.max(0, width - scripts.runWidths([{ ...run, text: drawn }], placement.fontSize, style)[0] * factor)) : 0;
     // A symbol glyph keeps the open face's shape: it is compressed to its code's advance only when wider, never stretched.
-    const pinned = run.symbol ? natural[index] > width + 1e-6 : width > 0;
+    const pinned = run.symbol ? natural[index] > width + 1e-6 : width - gap > 0;
     return tag("tspan", {
-      x: stableNumber(placement.x + left),
-      textLength: pinned ? stableNumber(width) : undefined, lengthAdjust: pinned ? "spacingAndGlyphs" : undefined,
+      x: stableNumber(placement.x + left + gap),
+      textLength: pinned ? stableNumber(width - gap) : undefined, lengthAdjust: pinned ? "spacingAndGlyphs" : undefined,
       "font-family": run.own ? undefined : fontStack(run.family, type),
       "font-size": adjusted(run),
       style: run.own ? undefined : nestedReset(style, run),
-      ...(trace ? trace(start, offset) : {})
-    }, isolate(escapeText(run.text)));
+      ...(trace ? trace(start, offset - trail.length) : {})
+    }, isolate(escapeText(drawn)));
   }).join("");
   return { content, positioned: true, ...shiftOf(runs) };
 }
@@ -1959,16 +1994,29 @@ function renderRichLines(value,fit,box,bound,config) {
       ? (linked ? bound.design.colors.hyperlink : config.fill)
       : resolveColorRef(run.color, bound, config.fill);
     let fixedAdvance=(fragment.kind==='tab'||placed)&&fragment.width>0;
+    // RR-59 (#175): measured fragments of a line core did not place (a list entry) keep their measured origin; a mixed-script one
+    // positions its runs (scriptLine runPlacement) as a placed line does.
+    const measuredLine=!asFlow&&!naturalFlow&&fragment.kind!=='tab'&&fragment.width>0;
+    // A right-to-left fragment draws without its trailing white space, after that white space's measured advance (rtlTrailingSpace).
+    const trail=rtl&&measuredLine&&fragment.kind!=='marker'?rtlTrailingSpace(fragment.text):'';
+    let gap=0;
+    if(trail){
+      const measure=textWidthMeasurer(fragment.style,config.options.textMeasurement),full=measure(fragment.text,fragment.fontSize);
+      gap=full>0?Math.min(fragment.width,Math.max(0,fragment.width*(1-measure(fragment.text.slice(0,-trail.length),fragment.fontSize)/full))):0;
+      if(!asFlow)position.x=stableNumber(originX+fragmentX+gap);
+    }
+    const drawnText=trail?fragment.text.slice(0,-trail.length):fragment.text,drawnWidth=fragment.width-gap;
     // FA-13: an inline code run falls back to a monospace face, and a run with its own language declares it.
     const runLang=fragment.kind!=='tab'&&fragment.style.lang?(bound.scriptFontsFor?.(fragment.style.lang)?.profile.bcp47??fragment.style.lang):undefined;
-    const scripted=fragment.kind==='tab'?{content:escapeText(fragment.text)}:scriptLine(fragment.text,fragment.style,bound,run.code===true?'monospace':bound.design.fontScheme.type,{rtl:rtl&&!asFlow,
-      placement:fixedAdvance&&!asFlow?{x:originX+fragmentX,width:fragment.width,fontSize:fragment.fontSize}:undefined,fontSize:fragment.fontSize});
+    const scripted=fragment.kind==='tab'?{content:escapeText(fragment.text)}:scriptLine(drawnText,fragment.style,bound,run.code===true?'monospace':bound.design.fontScheme.type,{rtl:rtl&&!asFlow,
+      placement:fixedAdvance&&!asFlow?{x:originX+fragmentX+gap,width:drawnWidth,fontSize:fragment.fontSize}:undefined,
+      runPlacement:measuredLine&&!fixedAdvance?{x:originX+fragmentX+gap,width:drawnWidth,fontSize:fragment.fontSize}:undefined,fontSize:fragment.fontSize});
     if(scripted.positioned)fixedAdvance=false;
     const content=`${edges.first?RIGHT_TO_LEFT_ISOLATE:''}${scripted.content}${edges.last?POP_DIRECTIONAL_ISOLATE:''}`;
     // RR-34: a citation/footnote marker is generated text (no source range): it is traced as a marker
     // segment without text offsets, so editors never read it as part of the run, and it is not linked.
     const marker=fragment.kind==='marker';
-    const rendered=tag(asFlow?'tspan':'text',{...(runLang?{lang:runLang,'xml:lang':runLang}:{}),...(config.options.trace?marker?{'data-opf-segment':'marker','data-opf-marker':fragment.text}:{'data-opf-text-start':runOffsets[fragment.runIndex]+fragment.start,'data-opf-text-end':runOffsets[fragment.runIndex]+fragment.end,'data-opf-segment':fragment.kind}:{}),...position,'xml:space':'preserve','text-rendering':asFlow?undefined:'geometricPrecision',textLength:fixedAdvance?stableNumber(fragment.width):undefined,lengthAdjust:fixedAdvance?'spacingAndGlyphs':undefined,'font-family':scripted.family??fontStack(fragment.style.fontFamily,run.code===true?'monospace':bound.design.fontScheme.type),'font-size':stableNumber(adjustedFontSize(fragment.fontSize,scripted.sizeAdjust)),'font-weight':fragment.style.fontWeight,'font-style':fragment.style.italic?'italic':asFlow?'normal':undefined,'text-decoration':marker?undefined:[run.underline||linked?'underline':'',run.strikethrough?'line-through':''].filter(Boolean).join(' ')||undefined,fill:runFill},content);
+    const rendered=tag(asFlow?'tspan':'text',{...(runLang?{lang:runLang,'xml:lang':runLang}:{}),...(config.options.trace?marker?{'data-opf-segment':'marker','data-opf-marker':fragment.text}:{'data-opf-text-start':runOffsets[fragment.runIndex]+fragment.start,'data-opf-text-end':runOffsets[fragment.runIndex]+fragment.end-trail.length,'data-opf-segment':fragment.kind}:{}),...position,'xml:space':'preserve','text-rendering':asFlow?undefined:'geometricPrecision',textLength:fixedAdvance?stableNumber(drawnWidth):undefined,lengthAdjust:fixedAdvance?'spacingAndGlyphs':undefined,'font-family':scripted.family??fontStack(fragment.style.fontFamily,run.code===true?'monospace':bound.design.fontScheme.type),'font-size':stableNumber(adjustedFontSize(fragment.fontSize,scripted.sizeAdjust)),'font-weight':fragment.style.fontWeight,'font-style':fragment.style.italic?'italic':asFlow?'normal':undefined,'text-decoration':marker?undefined:[run.underline||linked?'underline':'',run.strikethrough?'line-through':''].filter(Boolean).join(' ')||undefined,fill:runFill},content);
     if(linked)return tag('a',{href:run.link,target:'_blank',rel:'noopener noreferrer'},rendered);
     return rendered;
     };

package/dist/text-paths.js

@@ -0,0 +1,278 @@
+// RR-64: `textAsPaths: true` draws every <text> of a slide as glyph outlines, so the SVG needs no font. The renderer has
+// already decided every line, position and width (x, y, text-anchor, textLength); the vector PDF export's SVG text layout
+// (layoutText: text chunks, bidirectional runs, per-character fallback, fontkit shaping, textLength) turns that into positioned
+// glyph runs, and this module writes each glyph as a <use> of its outline. Outlines are 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 resolve to another
+// face's glyph. Everything outside the <text> elements is left byte for byte as the renderer wrote it.
+//
+// A <text> becomes a <g> that keeps the element's own attributes except the text-only ones (so its transform, opacity and
+// data-opf-* trace stay), labelled with its text for assistive technology unless it is aria-hidden; a tspan with a trace keeps
+// it on a nested <g>; a link becomes an <a> around its runs; underline and line-through are rectangles in the text colour from
+// 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";
+
+const TOKENS = /<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|[^<]+/g;
+const ATTRIBUTE = /([^\s=/>"']+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+// Attributes that only mean something on text: the outline group does not carry them.
+const TEXT_ONLY = new Set(["x", "y", "dx", "dy", "rotate", "textLength", "lengthAdjust", "text-anchor", "text-rendering", "xml:space", "font-family", "font-size",
+  "font-weight", "font-style", "font-variant", "font-stretch", "font-feature-settings", "font-variant-ligatures", "letter-spacing", "word-spacing", "text-decoration",
+  "dominant-baseline", "alignment-baseline", "baseline-shift", "direction", "unicode-bidi", "writing-mode"]);
+const COLOUR_TABLES = ["COLR", "CBDT", "sbix", "SVG "];
+const libraries = new WeakMap();
+
+/**
+ * The outline font library of a fonts handle: every face of its registry (`registry.exportFaces()`), or the faces of its
+ * `embeddedFonts` list. Built once per registry and extended when the registry gains faces (`ensure`, `addFaces`). Null when
+ * the handle holds no font bytes.
+ */
+export function outlineLibrary(fonts) {
+  const registry = fonts?.registry;
+  if (typeof registry?.exportFaces === "function") {
+    const exported = registry.exportFaces();
+    const described = typeof registry.describeFaces === "function" ? registry.describeFaces() : [];
+    let entry = libraries.get(registry);
+    if (!entry) { entry = { library: newLibrary(fonts), added: 0 }; libraries.set(registry, entry); }
+    // Registries only ever append faces.
+    for (let index = entry.added; index < exported.length; index++) addFace(entry.library, exported[index].data, exported[index].family, described[index]);
+    entry.added = exported.length;
+    return entry.library;
+  }
+  const list = fonts?.embeddedFonts;
+  if (!Array.isArray(list) || !list.length) return null;
+  let library = libraries.get(list);
+  if (!library) {
+    library = newLibrary(fonts);
+    for (const font of list) {
+      const match = /^data:font\/[a-z0-9]+;base64,([A-Za-z0-9+/=]+)$/.exec(String(font?.dataUrl ?? ""));
+      if (match) addFace(library, decodeBase64(match[1]), font.family, font);
+    }
+    libraries.set(list, library);
+  }
+  return library;
+}
+
+function newLibrary(fonts) {
+  const fallback = fonts?.registry?.fallbackFamily ?? "Roboto";
+  return new FontLibrary({ genericFamilies: () => [fallback] });
+}
+
+// The face is matched by the family, weight and style the registry gives it, the ones the SVG names.
+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;
+  face.outlineStyled = true;
+}
+
+function decodeBase64(text) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(text, "base64"));
+  const binary = atob(text), bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+
+/**
+ * Replace the <text> elements of the slide's content strings by glyph outlines. `library` comes from `outlineLibrary`,
+ * `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 }) {
+  const defs = new Map();
+  const reported = new Set();
+  const env = {
+    fonts: library,
+    defaults: [],
+    splitByOwner: true,
+    // 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 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("");
+  return { content: outlined, defs: definitions ? `<defs>${definitions}</defs>` : "" };
+}
+
+// Splices each <text> element of `markup`; the style it inherits is folded from its ancestors' attributes.
+function outlineMarkup(markup, base, env, defs, keep) {
+  const ancestors = [];
+  let out = "", from = 0, start = -1, depth = 0, parentStyle = null;
+  for (const match of markup.matchAll(TOKENS)) {
+    const [token, close, name, attributes = "", selfClose] = match;
+    if (name === undefined) continue;
+    if (start >= 0) {
+      if (name === "text") depth += close ? -1 : selfClose ? 0 : 1;
+      if (depth > 0) continue;
+      const end = match.index + token.length;
+      out += markup.slice(from, start) + outlineText(markup.slice(start, end), parentStyle, env, defs, keep);
+      from = end;
+      start = -1;
+      continue;
+    }
+    if (close) { ancestors.pop(); continue; }
+    if (name === "text" && selfClose) {
+      // An empty <text/> (an empty table cell) draws nothing: it becomes an empty group with the element's other attributes.
+      const end = match.index + token.length;
+      out += markup.slice(from, match.index) + outlineText(token, base, env, defs, keep);
+      from = end;
+      continue;
+    }
+    if (name === "text") {
+      start = match.index;
+      depth = 1;
+      parentStyle = ancestors.reduce((style, attrs) => inheritStyle(style, attrs), base);
+      continue;
+    }
+    if (!selfClose) ancestors.push(attributesOf({ attrs: parseAttributes(attributes) }));
+  }
+  return from === 0 ? markup : out + markup.slice(from);
+}
+
+function parseAttributes(text) {
+  const attrs = {};
+  for (const attribute of text.matchAll(ATTRIBUTE)) attrs[attribute[1]] = decodeEntities(attribute[2] ?? attribute[3] ?? "");
+  return attrs;
+}
+
+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 = [];
+  for (const run of runs) {
+    const drawn = drawRun(run, defs);
+    if (!drawn) continue;
+    const owner = run.owner !== node && run.owner ? run.owner : null;
+    const last = groups.at(-1);
+    if (last && last.owner === owner) last.parts.push(drawn);
+    else groups.push({ owner, parts: [drawn] });
+  }
+  const body = groups.map(({ owner, parts }) => {
+    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);
+}
+
+// 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();
+}
+
+function drawRun(run, defs) {
+  const style = run.style, size = run.size, face = run.face, upem = face.upem;
+  const scale = size / upem, extra = run.extraSpacing ?? 0, scaleX = run.scaleX ?? 1;
+  // The run is drawn in font units (y up) under one transform; each glyph is a <use> at its pen position in font units.
+  const uses = [];
+  let pen = 0;
+  for (const glyph of run.glyphs) {
+    const id = glyphId(face, glyph.gid, defs);
+    if (id) {
+      const x = units(pen / scale + glyph.xOffset), y = units(glyph.yOffset);
+      uses.push(`<use href="#${id}"${x === "0" ? "" : ` x="${x}"`}${y === "0" ? "" : ` y="${y}"`}/>`);
+    }
+    pen += glyph.advance * scale + glyph.spacing + extra;
+  }
+  const decorations = [...run.decoration].map((kind) => decorationRect(kind, run, scale));
+  if (!uses.length && !decorations.length) return "";
+  const paint = [["fill", style.fill]];
+  if (style["fill-opacity"] !== undefined && style["fill-opacity"] !== "1") paint.push(["fill-opacity", style["fill-opacity"]]);
+  if (style.stroke && style.stroke !== "none") {
+    // Glyphs are drawn at the em scale, so the stroke width is given in font units.
+    const width = parseLength(style["stroke-width"], { fontSize: size }) ?? 1;
+    paint.push(["stroke", style.stroke], ["stroke-width", precise(width / scale)]);
+    if (style["stroke-opacity"] !== undefined && style["stroke-opacity"] !== "1") paint.push(["stroke-opacity", style["stroke-opacity"]]);
+  }
+  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;
+}
+
+// Underline, line-through and overline in the text colour, from the font's own metrics (the vector PDF draws the same).
+function decorationRect(kind, run, scale) {
+  const font = run.face.font, upem = run.face.upem;
+  let position, thickness;
+  if (kind === "underline") { position = -(font.underlinePosition || -upem * 0.1) * scale; thickness = (font.underlineThickness || upem * 0.05) * scale; }
+  else if (kind === "line-through") { position = -(font["OS/2"]?.yStrikeoutPosition || upem * 0.3) * scale; thickness = (font["OS/2"]?.yStrikeoutSize || upem * 0.05) * scale; }
+  else { position = -font.ascent * scale; thickness = (font.underlineThickness || upem * 0.05) * scale; }
+  return `<rect x="${fixed(run.x)}" y="${fixed(run.y + position - thickness / 2)}" width="${fixed(run.width)}" height="${fixed(thickness)}" stroke="none"/>`;
+}
+
+// The outline of a glyph, once per slide, in font units (y up); null for a glyph that draws nothing (a space).
+function glyphId(face, gid, defs) {
+  const id = `opf-g-${face.hash.slice(0, 12)}-${gid}`;
+  if (defs.has(id)) return id;
+  const d = outlinePath(face.font.getGlyph(gid).path.commands);
+  if (!d) return null;
+  defs.set(id, d);
+  return id;
+}
+
+// Relative commands, each delta taken from the previous rounded point, so rounding to a tenth of a unit never drifts.
+function outlinePath(commands) {
+  const parts = [];
+  let x = 0, y = 0, startX = 0, startY = 0, draws = false;
+  for (const { command, args } of commands) {
+    const letter = { moveTo: "m", lineTo: "l", quadraticCurveTo: "q", bezierCurveTo: "c", closePath: "z" }[command];
+    if (!letter) continue;
+    if (letter === "z") { parts.push("z"); x = startX; y = startY; continue; }
+    const points = [];
+    for (let index = 0; index < args.length; index += 2) points.push([round(args[index]), round(args[index + 1])]);
+    parts.push(letter + numbers(points.flatMap(([px, py]) => [px - x, py - y])));
+    [x, y] = points.at(-1);
+    if (letter === "m") { startX = x; startY = y; } else draws = true;
+  }
+  return draws ? parts.join("") : "";
+}
+
+function round(value) { return Math.round(value * 10) / 10; }
+// Numbers joined the short SVG way: no separator before a minus sign.
+function numbers(values) {
+  return values.map((value, index) => { const text = units(Math.round(value * 10) / 10); return index && !text.startsWith("-") ? " " + text : text; }).join("");
+}
+
+function element(name, attrs, body) {
+  const text = attrs.filter(([, value]) => value !== undefined && value !== null).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("");
+  return body ? `<${name}${text}>${body}</${name}>` : `<${name}${text}/>`;
+}
+
+// Font units to a tenth; positions to a thousandth of a pixel; the em scale to six significant digits.
+function units(value) { const text = String(Math.round(value * 10) / 10); return text === "-0" ? "0" : text; }
+function fixed(value) { const text = Number(value).toFixed(3).replace(/\.?0+$/, ""); return text === "-0" ? "0" : text; }
+function precise(value) { return String(Number(Number(value).toPrecision(6))); }
+
+
+/**
+ * The outline engine a fonts handle carries as `outlines` (RR-64): `renderSvg(deck, { fonts, textAsPaths: true })` draws each
+ * slide's text with it. The faces are read from the handle when a slide is outlined, so faces it loads later are used too.
+ */
+export function textOutlines(fonts) {
+  return Object.freeze({
+    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 });
+    },
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-render",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Deterministic local OPF renderer for SVG, PNG, and PDF output.",
   "license": "MIT",
   "type": "module",
@@ -139,7 +139,7 @@
     "test:preview-a11y-browser": "node test/preview-a11y-browser.mjs"
   },
   "dependencies": {
-    "@openpresentation/opf": "^0.16.0",
+    "@openpresentation/opf": "^0.17.0",
     "bidi-js": "1.1.0",
     "fontkit": "^2.0.4",
     "pako": "1.0.11"