@openpresentation/opf-render 0.16.0 → 0.17.1

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

@@ -60,6 +60,28 @@ 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 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

@@ -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.
@@ -165,7 +166,7 @@ function buildRuns(chunk, env, styleIds, faceCache, linkIds) {
   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) => {
@@ -174,9 +175,12 @@ 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 };
+      // `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;
@@ -241,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/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,28 @@ 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 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";
 
@@ -540,7 +542,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 +550,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 +642,15 @@ 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).
+// `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, ...rest } = options ?? {};
-  return { ...rest, textMeasurement: fonts?.textMeasurement, embeddedFonts: embedFonts === false ? undefined : fonts?.embeddedFonts };
+  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 } : {}), ...(subsetFonts !== false && fonts?.subsets ? { subsets: fonts.subsets } : {}) };
 }
 
 /**
@@ -657,7 +668,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 +711,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 +720,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, 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
@@ -1732,12 +1750,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 +1799,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) };
 }
@@ -1826,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;
@@ -1839,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
@@ -1959,16 +1995,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;
     };