@openpresentation/opf-render 0.15.0 → 0.17.0

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";
@@ -25,10 +26,24 @@ async function verifiedFile(file, expected, details) {
 // The default Latin, Cyrillic and Greek glyph-fallback face (the office pack always loads it, fallback-only).
 const FALLBACK_PACKAGE = "@expo-google-fonts/noto-sans";
 
+// RR-63: every `@expo-google-fonts/*` package is an optional peer dependency, so a host installs only the faces it uses. A request that
+// needs packages that are not installed fails once, naming all of them and the install command, instead of one package at a time.
+function requireInstalled(packages, what) {
+  const missing = packages.filter(pkg => {
+    if (pkg.vendored) return false;
+    try { require.resolve(`${pkg.name}/package.json`); return false; } catch { return true; }
+  });
+  if (!missing.length) return;
+  const install = `npm install ${missing.map(pkg => `${pkg.name}@${pkg.version}`).join(" ")}`;
+  throw new OPFFontError("font-resource-unavailable", `${what} needs font packages that are not installed (optional peer dependencies of @openpresentation/opf-render): run \`${install}\`.`, {packages: missing.map(pkg => pkg.name), install});
+}
+
 // `skipped`: an optional npm package that is not installed is recorded there instead of failing (scripts: 'auto').
 // `fallbackOnly`: the faces serve glyph fallback and requests by their own name, never a replacement for another family.
-async function loadPackages(packages, skipped, {fallbackOnly = false} = {}) {
+// `what`: how the request is named in the error for a package that is not installed, for example "The 'office' font pack".
+async function loadPackages(packages, skipped, {fallbackOnly = false, what = "This font request"} = {}) {
   const entries = [], fontFiles = [];
+  if (!skipped) requireInstalled(packages, what);
   for (const pkg of packages) {
     if (pkg.vendored) {
       // FF-31: vendored faces ship inside this package (pkg.vendored, for example fonts/carlito), hash-pinned like the npm packs. The open pack is
@@ -53,7 +68,7 @@ async function loadPackages(packages, skipped, {fallbackOnly = false} = {}) {
       installed = JSON.parse(await readFile(manifestPath, "utf8"));
     } catch (error) {
       if (skipped) { skipped.push({package: pkg.name, version: pkg.version, scripts: [...pkg.scripts]}); continue; }
-      throw new OPFFontError("font-resource-unavailable", `Install ${pkg.name}@${pkg.version} to use this offline font pack.`, {package:pkg.name, cause:error.code});
+      throw new OPFFontError("font-resource-unavailable", `Install ${pkg.name}@${pkg.version} to use ${what}.`, {package:pkg.name, cause:error.code});
     }
     if (installed.version !== pkg.version) throw new OPFFontError("font-version-mismatch", `Expected ${pkg.name}@${pkg.version}; reinstall the pinned package.`, {package:pkg.name, expected:pkg.version, actual:installed.version});
     const directory = path.dirname(manifestPath);
@@ -73,7 +88,7 @@ async function loadPackages(packages, skipped, {fallbackOnly = false} = {}) {
 const renamedAliases = () => Object.fromEntries(BUNDLED_FONT_MANIFEST.packages.filter(item => item.pack === "open" && item.renamedFrom).map(item => [item.renamedFrom, item.faces[0].family]));
 // The vendored faces this registry holds that are embed "used": a host that serves fonts itself lists them to copy their files.
 const lazyOf = registry => lazyFontList().filter(face => registry.describeFaces().some(held => held.family === face.family && held.weight === face.weight && held.italic === face.italic));
-const loadPack = pack => loadPackages(BUNDLED_FONT_MANIFEST.packages.filter(item => item.pack === pack));
+const loadPack = pack => loadPackages(BUNDLED_FONT_MANIFEST.packages.filter(item => item.pack === pack), undefined, {what: `The '${pack}' font pack`});
 
 /**
  * Adds the script pack. `scripts` is 'all', ISO 15924 codes, or 'auto' (FF-19): detect the scripts the
@@ -86,7 +101,7 @@ async function withScripts(loaded, scripts, {presentation, onDiagnostic, renderO
   // A package the registry already loaded (the default Noto Sans fallback) is never loaded twice.
   const notLoaded = list => list.filter(pkg => !loaded.packages?.includes(pkg.name));
   if (scripts !== "auto") {
-    const extra = await loadPackages(notLoaded(scriptFontPackages(scripts)));
+    const extra = await loadPackages(notLoaded(scriptFontPackages(scripts)), undefined, {what: `The requested script fonts (${Array.isArray(scripts) ? scripts.join(", ") : scripts})`});
     return {...loaded, entries:[...loaded.entries, ...embedUsed(extra.entries)], fontFiles:[...loaded.fontFiles, ...extra.fontFiles], packages:[...(loaded.packages ?? []), ...extra.packages]};
   }
   if (presentation === null || typeof presentation !== "object") throw new OPFFontError("invalid-font-scripts", "scripts: 'auto' needs the presentation whose text decides the scripts.", {scripts});
@@ -160,6 +175,11 @@ async function withFaces(loaded, faces) {
  */
 async function buildRegistry(pack, {scripts, faces, presentation, onDiagnostic, renderOptions, ...options}) {
   let loaded, registryOptions = options;
+  // RR-63: name every npm font package the pack needs at once, before loading any of them.
+  if (pack === "base" || pack === "office") {
+    const packs = pack === "base" ? ["base"] : ["office", ...(options.includeBaseFonts === false ? [] : ["base"])];
+    requireInstalled([...BUNDLED_FONT_MANIFEST.packages.filter(item => packs.includes(item.pack)), ...(pack === "office" ? scriptFontPackages(["Latn"]) : [])], `The '${pack}' font pack`);
+  }
   if (pack === "office") {
     const {entries, fontFiles, packages} = await loadPack("office");
     for (const [include, name] of [[options.includeOpenFonts, "open"], [options.includeBaseFonts, "base"]]) {
@@ -177,7 +197,7 @@ async function buildRegistry(pack, {scripts, faces, presentation, onDiagnostic,
     // an explicit list does; a presentation that does not select Latn keeps it fallback-only.
     const requested = scripts === "auto" && presentation !== null && typeof presentation === "object" ? scriptFontPackages(autoScriptSelection(presentation, renderOptions).scripts).map(pkg => pkg.name)
       : scripts === undefined || scripts === "auto" || (Array.isArray(scripts) && !scripts.length) ? [] : scriptFontPackages(scripts).map(pkg => pkg.name);
-    const fallback = await loadPackages(scriptFontPackages(["Latn"]).filter(pkg => !requested.includes(pkg.name)), undefined, {fallbackOnly:true});
+    const fallback = await loadPackages(scriptFontPackages(["Latn"]).filter(pkg => !requested.includes(pkg.name)), undefined, {fallbackOnly:true, what: "The 'office' font pack (its default glyph-fallback face)"});
     fontFiles.push(...fallback.fontFiles);
     entries.push(...fallback.entries);
     packages.push(...fallback.packages);
@@ -253,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

@@ -8,8 +8,8 @@ export type { FontPolicyEntry } from "@openpresentation/opf/font-policy";
 export { isSymbolEncodedFamily, mapSymbolText, symbolCodeOf } from "@openpresentation/opf/symbol-font-encodings";
 export { scriptFontRole } from "@openpresentation/opf/composition";
 export type { ScriptRole } from "@openpresentation/opf/composition";
-export interface FontFaceInput { data: Uint8Array; family?: string; weight?: number; italic?: boolean; postscriptName?: string; license?: string; /** Serves glyph fallback and requests by its own family only; never a replacement for another family. */ fallbackOnly?: boolean; /** "used" embeds the face in an SVG only when the slide's text names its family (the open pack, FF-31). Default "always". */ embed?: "always" | "used"; /** ISO 15924 scripts a designated script replacement face serves (FF-19). */ scripts?: string[] }
-export interface EmbeddedFont { family: string; weight: number; italic?: boolean; dataUrl: string; license?: string; embed?: "used" }
+export interface FontFaceInput { data: Uint8Array; family?: string; weight?: number; italic?: boolean; postscriptName?: string; license?: string; /** Serves glyph fallback and requests by its own family only; never a replacement for another family. */ fallbackOnly?: boolean; /** Every face is embedded in an SVG only when the slide's text draws it (RR-61). "used" also leaves the face out of the eager `registry.embeddedFonts` list (the open pack, FF-31); "always" embeds it in every SVG. */ embed?: "always" | "used"; /** ISO 15924 scripts a designated script replacement face serves (FF-19). */ scripts?: string[] }
+export interface EmbeddedFont { family: string; weight: number; italic?: boolean; dataUrl: string; license?: string; /** "always": written into every SVG; otherwise only into an SVG whose text draws the face (RR-61). */ embed?: "always" | "used" }
 export type FontCompatibility = "exact" | "metric" | "visual" | "generic";
 export interface FontReplacementMeasurement { replacement:string; meanAbsWidthDelta:number; meanWidthDelta:number; maxAbsWidthDelta:number; styles:number; reference:string }
 export interface FontResolution {
@@ -41,7 +41,7 @@ export declare const EXPERIMENTAL_FONT_CANDIDATES: readonly Readonly<{requestedF
 export interface RenderFonts {
   /** Measures text with the real faces. Without it layout uses core's portable estimate. */
   textMeasurement?: TextMeasurement;
-  /** Faces `renderSvg` writes into each SVG as @font-face data; a face flagged `embed: "used"` only when a slide draws its family. */
+  /** Faces `renderSvg` may write into an SVG as @font-face data: each only into the SVGs whose text draws it (its family, weight and style), unless flagged `embed: "always"` (RR-61). */
   embeddedFonts?: readonly EmbeddedFont[];
   /** Font files the Node raster and PDF conversions draw with. */
   fontFiles?: readonly string[];
@@ -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

@@ -54,10 +54,22 @@ export interface RenderSvgOptions {
   skipHidden?: boolean;
   /**
    * The fonts the deck is laid out and drawn with: the handle `loadFonts()` returns (from `@openpresentation/opf-render/fonts-node` or
-   * `/fonts-browser`), or any object with a `textMeasurement` and, to embed faces in each SVG, an `embeddedFonts` list. Without it layout uses
+   * `/fonts-browser`), or any object with a `textMeasurement` and, to embed faces, an `embeddedFonts` list (each SVG carries only the faces its text draws). Without it layout uses
    * core's portable width estimate and the SVG names the design fonts without embedding them.
    */
   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/pdf-vector.js

@@ -724,6 +724,8 @@ class Converter {
         result = { resource, object, width: info.width, height: info.height };
       }
     } catch (error) {
+      // A missing converter is the host's install, not a bad picture: say so instead of writing a PDF without its pictures.
+      if (error?.code === "converter-missing") throw error;
       this.unsupported("pdf-image-skipped", `An embedded image could not be decoded and is not drawn: ${error instanceof Error ? error.message : String(error)}`, { path: tracePath });
     }
     this.images.set(digest, result);

package/dist/pdf.d.ts

@@ -0,0 +1,2 @@
+export { svgToPdf } from "./index.js";
+export type { SvgToPdfOptions, PdfDiagnostic, PdfMetadata } from "./index.js";

package/dist/pdf.js

@@ -0,0 +1,4 @@
+// RR-63: the PDF format entry (Node). The default vector `svgToPdf` needs no converter for text and shapes; it loads the optional peer
+// `sharp` for pictures and `@resvg/resvg-js` for the rare element it rasterizes, and `mode: "raster"` also loads `pdf-lib`. A converter
+// that is not installed rejects with `OPFRenderError` code `converter-missing`. For a page use `@openpresentation/opf-render/export-browser`.
+export { svgToPdf } from "./raster.js";

package/dist/player.d.ts

@@ -7,7 +7,8 @@ import type { RenderSvgOptions } from "./svg.js";
  */
 export declare class DeckError extends Error {
   readonly code: string;
-  constructor(code: string, message: string, options?: { cause?: unknown });
+  readonly details?: {source: string; status?: number; contentType?: string};
+  constructor(code: string, message: string, options?: { cause?: unknown; source?: string; status?: number; contentType?: string });
 }
 
 /** The slide that is showing, in the sequence that plays (hidden slides are not counted). `notes` is plain text. */

package/dist/png.d.ts

@@ -0,0 +1,2 @@
+export { svgToPng } from "./index.js";
+export type { SvgToPngOptions } from "./index.js";

package/dist/png.js

@@ -0,0 +1,4 @@
+// RR-63: the PNG format entry (Node). `svgToPng` loads the optional peers `@resvg/resvg-js` (and `sharp` for WebP and rotated JPEG
+// pictures) on first use and rejects with `OPFRenderError` code `converter-missing` when they are not installed. For a page use
+// `@openpresentation/opf-render/export-browser`.
+export { svgToPng } from "./raster.js";

package/dist/preview-fonts-node.js

@@ -1,7 +1,7 @@
 // RR-28: fill a self-hosted font root (the layout of `preview-fonts.js`) from the installed packages, for hosts that serve
 // `<opf-deck fonts="/opf-fonts/">`. Node only. Every file is copied unmodified and checked against its pinned SHA-256 and
 // every license notice travels with it (LICENSES.txt). Nothing is downloaded: the faces come from this package's `fonts`
-// directory and the installed `@expo-google-fonts/*` packages.
+// directory and the installed `@expo-google-fonts/*` packages (optional peer dependencies of this package: install the ones you copy).
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
@@ -50,7 +50,7 @@ export function copyPreviewFonts({ outDir, scripts = false, cwd, manifest = BUND
     const sourceDirectory = pkg.vendored ? within(rendererRoot, pkg.vendored) : resolvePackageDirectory(pkg.name, cwd);
     if (!sourceDirectory || !fs.existsSync(sourceDirectory)) {
       if (pkg.pack === "scripts") { missing.push(pkg.name); continue; }
-      throw new Error(`${pkg.name} is not installed: reinstall @openpresentation/opf-render.`);
+      throw new Error(`${pkg.name} is not installed: it is an optional peer dependency of @openpresentation/opf-render, so run "npm install ${pkg.name}@${pkg.version}".`);
     }
     if (!pkg.vendored) {
       const installed = JSON.parse(fs.readFileSync(path.join(sourceDirectory, "package.json"), "utf8"));

package/dist/raster-images.js

@@ -1,4 +1,5 @@
 import {OPFRenderError} from './svg.js';
+import {isConverterMissing,loadConverter} from './converters.js';
 
 // Resvg does not decode WebP or apply JPEG EXIF orientation, and draws no text of an SVG used as an image (its nested
 // document has no fonts). Replace only affected embedded image hrefs in the private
@@ -27,6 +28,7 @@ export async function prepareRasterImages(svg, {nestedSvg} = {}) {
       const replacement = href[0].slice(0, href[0].indexOf(href[1]) + 1) + png + href[1];
       tag = tag.slice(0, href.index) + replacement + tag.slice(href.index + href[0].length);
     } catch (error) {
+      if (isConverterMissing(error)) throw error;
       throw new OPFRenderError('image-conversion-failed', 'Embedded raster image could not be prepared for PNG/PDF output.', {path, cause:error instanceof Error ? error.message : String(error)});
     }
     output += svg.slice(end, match.index) + tag;
@@ -74,7 +76,7 @@ async function prepareRasterImage(uri) {
   } else if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8 || bytes[2] !== 0xff) {
     throw new Error('Embedded data is not a JPEG image.');
   }
-  const {default:sharp}=await import('sharp');
+  const {default:sharp}=await loadConverter('sharp');
   const decoder=sharp(bytes,{limitInputPixels:40_000_000,animated:false,failOn:'warning'});
   if (!webp) {
     const {orientation}=await decoder.metadata();

package/dist/raster.js

@@ -3,6 +3,7 @@ import {OPFRenderError,packageName} from './svg.js';
 import {separateLigatures} from './font-compatibility.js';
 import {monochromeColorFonts,rasterFontFiles} from './color-fonts.js';
 import {pinScriptClusters} from './raster-text.js';
+import {loadConverter} from './converters.js';
 const DEFAULT_DIMENSIONS = { width: 1280, height: 720 };
 const DEFAULT_RASTER_SCALE = 1;
 const DEFAULT_RASTER_BACKGROUND = "#FFFFFF";
@@ -100,7 +101,7 @@ async function vectorPdf(inputs, options) {
 // The picture decoder of the Node vector export (the browser entry passes a canvas one). sharp loads on first use.
 function sharpImageCodec() {
   let loaded;
-  const sharp = () => (loaded ??= import("sharp").then((module) => module.default));
+  const sharp = () => (loaded ??= loadConverter("sharp").then((module) => module.default));
   return {
     metadata: async (bytes) => (await sharp())(bytes, { limitInputPixels: 40_000_000, animated: false }).metadata(),
     rgba: async (bytes, { orient }) => {
@@ -162,25 +163,8 @@ async function rasterizeSvg(svgInput, options) {
   }
 }
 
-async function loadResvg() {
-  try {
-    return await import("@resvg/resvg-js");
-  } catch (error) {
-    throw new OPFRenderError("png-renderer-unavailable", "PNG/PDF conversion requires the Node runtime dependency @resvg/resvg-js.", {
-      cause: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-
-async function loadPdfLib() {
-  try {
-    return await import("pdf-lib");
-  } catch (error) {
-    throw new OPFRenderError("pdf-writer-unavailable", "PDF conversion requires the runtime dependency pdf-lib.", {
-      cause: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
+const loadResvg = () => loadConverter("@resvg/resvg-js");
+const loadPdfLib = () => loadConverter("pdf-lib");
 
 async function bundledFontFiles() {
   if (!bundledFontFilesCache) {

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

@@ -54,10 +54,22 @@ export interface RenderSvgOptions {
   skipHidden?: boolean;
   /**
    * The fonts the deck is laid out and drawn with: the handle `loadFonts()` returns (from `@openpresentation/opf-render/fonts-node` or
-   * `/fonts-browser`), or any object with a `textMeasurement` and, to embed faces in each SVG, an `embeddedFonts` list. Without it layout uses
+   * `/fonts-browser`), or any object with a `textMeasurement` and, to embed faces, an `embeddedFonts` list (each SVG carries only the faces its text draws). Without it layout uses
    * core's portable width estimate and the SVG names the design fonts without embedding them.
    */
   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. */