@openpresentation/opf-render 0.17.0 → 0.18.0

package/dist/fonts-browser.d.ts

@@ -6,7 +6,7 @@ import type {
   FontsHandle,
 } from "./fonts.js";
 import type { AutoScriptSelection, BundledFontPackage, LazyFont, ScriptSelection } from "./fonts-node.js";
-import type { RenderSvgOptions } from "./svg.js";
+import type { ToSvgOptions } from "./svg.js";
 export type { LazyFont } from "./fonts-node.js";
 export type { AutoScriptSelection } from "./fonts-node.js";
 export { detectPresentationScripts, autoScriptSelection } from "./fonts-node.js";
@@ -26,17 +26,17 @@ export interface BrowserFontRegistry extends FontRegistry {
    * family the policy would not resolve, nor for a weight or style nothing draws), once each, from `lazyFontsBaseUrl`.
    * Fetches and verifies every file, then adds the faces to the document and the registry together; on failure nothing
    * changes and the call can be retried. Call it before measuring a document, and again after edits: an edit that adds a
-   * bold or italic run loads just that face. Besides `signal`, the call takes the `renderSvg` options the document resolves
+   * bold or italic run loads just that face. Besides `signal`, the call takes the `toSvg` options the document resolves
    * with (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with the error
-   * `renderSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
+   * `toSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensureLazyFonts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<LazyFont[]>;
+  ensureLazyFonts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<LazyFont[]>;
   /**
    * Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means
-   * `ensureLazyFonts` fetches nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...)
-   * over the loader's `renderOptions`. Throws what `renderSvg` throws for a document that does not resolve.
+   * `ensureLazyFonts` fetches nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...)
+   * over the loader's `renderOptions`. Throws what `toSvg` throws for a document that does not resolve.
    */
-  pendingLazyFonts(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): LazyFont[];
+  pendingLazyFonts(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): LazyFont[];
 
   /** Load script faces for ISO 15924 codes (or "all") from `scriptBaseUrl`. Resolves with the newly loaded package names. */
   loadScripts(scripts: ScriptSelection, options?: { signal?: AbortSignal }): Promise<string[]>;
@@ -49,15 +49,15 @@ export interface BrowserFontRegistry extends FontRegistry {
    * OPFFontError whose `details` are `{ loaded: string[]; failed: {package, code, message}[] }`. A failed call (fetch, hash, FontFace load) leaves nothing loaded and can be retried; after
    * `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensureScripts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<AutoScriptSelection & { loaded: string[]; uncovered: string[] }>;
+  ensureScripts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<AutoScriptSelection & { loaded: string[]; uncovered: string[] }>;
   /** Synchronous: package names the presentation needs that are not loaded yet. Empty means `ensureScripts` fetches nothing, so a host can render immediately. Text decides, so a document is analyzed without resolving its layouts; `renderOptions.catalogs` matter for font schemes only the host's catalogs have (FF-41). */
-  pendingScripts(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  pendingScripts(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
   /** Names of the script-pack packages loaded so far. */
   readonly loadedScriptPackages: string[];
 }
 /**
  * The fonts handle of a browser: the faces you list, registered with the document, and on demand the script and vendored faces a deck
- * draws. Pass it as `{ fonts }` to `renderSvg`, `renderSlideSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor.
+ * draws. Pass it as `{ fonts }` to `toSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor.
  * The registry behind it keeps the lower-level loaders (`ensureLazyFonts`, `ensureScripts`, `loadScripts`, `pendingLazyFonts`, `pendingScripts`).
  */
 export interface BrowserFontsHandle extends FontsHandle {
@@ -66,13 +66,13 @@ export interface BrowserFontsHandle extends FontsHandle {
   dispose(): void;
   /**
    * Load the vendored and script faces the presentation draws (each hash-verified, all or nothing), repeating while loading changes what
-   * is needed. Cheap when nothing is needed. Besides `signal`, the call takes the `renderSvg` options the document resolves with
-   * (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with what `renderSvg` throws for it; after
+   * is needed. Cheap when nothing is needed. Besides `signal`, the call takes the `toSvg` options the document resolves with
+   * (`catalogs`, ...) over the loader's `renderOptions`. A document that does not resolve rejects with what `toSvg` throws for it; after
    * `dispose()` it rejects with `font-registry-disposed`.
    */
-  ensure(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): Promise<EnsureResult>;
-  /** Synchronous: the vendored files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `renderSvg` throws for a document that does not resolve. */
-  pending(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  ensure(presentation: unknown, options?: { signal?: AbortSignal } & Partial<ToSvgOptions>): Promise<EnsureResult>;
+  /** Synchronous: the vendored files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `toSvg` throws for a document that does not resolve. */
+  pending(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
 }
 export declare function loadFonts(
   options?: FontRegistryOptions & {
@@ -81,6 +81,17 @@ export declare function loadFonts(
     document?: Document;
     fetch?: typeof fetch;
     signal?: AbortSignal;
+    /**
+     * RR-65: harfbuzzjs's `harfbuzz-subset.wasm` (the URL the host serves it from, its bytes or a compiled WebAssembly.Module). With
+     * it the handle carries `subsets`, and every SVG `toSvg` draws with this handle embeds each face cut to the characters the
+     * slide draws. Without it a browser handle embeds whole faces (the Node handle always subsets).
+     */
+    subsetWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
+    /**
+     * RR-64: harfbuzzjs's `harfbuzz.wasm` (its URL, bytes or a compiled WebAssembly.Module). With it `text: "paths"` shapes outlines with
+     * HarfBuzz, as the browser shapes text; without it a browser handle shapes them with fontkit (the Node handle always uses HarfBuzz).
+     */
+    shapeWasm?: string | URL | ArrayBuffer | ArrayBufferView | WebAssembly.Module;
     crypto?: { subtle: SubtleCrypto };
     /** Script faces to load once the registry exists: "auto" (with `presentation`), "all" or ISO 15924 codes. Needs `scriptBaseUrl`. */
     scripts?: ScriptSelection | "auto";
@@ -100,11 +111,11 @@ export declare function loadFonts(
      */
     extraLazyFonts?: readonly ExtraLazyFont[];
     /**
-     * FF-41: the `renderSvg` options the documents resolve with (`catalogs` above all), the default for `pendingLazyFonts`,
+     * FF-41: the `toSvg` options the documents resolve with (`catalogs` above all), the default for `pendingLazyFonts`,
      * `ensureLazyFonts`, `pendingScripts` and `ensureScripts`. A layout or font scheme id that only the host's catalogs have
      * resolves the same way here as it does when the host renders. A call's own options win.
      */
-    renderOptions?: Partial<RenderSvgOptions>;
+    renderOptions?: Partial<ToSvgOptions>;
   },
 ): Promise<BrowserFontsHandle>;
 export declare function scriptFontPackages(scripts: ScriptSelection): BundledFontPackage[];
@@ -127,10 +138,10 @@ export interface ExtraLazyFont { family: string; weight: number; italic?: boolea
 export declare function splitStartupFaces<T extends { family: string; weight: number; italic?: boolean }>(faces: readonly T[], options?: { startup?: (face: T) => boolean }): { startup: T[]; rest: T[] };
 /**
  * The font families a presentation's slides resolve (heading, body and code roles of every slide). `options` are the
- * `renderSvg` options the document resolves with (`catalogs`, ...). A document that does not resolve throws what `renderSvg`
+ * `toSvg` options the document resolves with (`catalogs`, ...). A document that does not resolve throws what `toSvg`
  * throws for it (FF-41: it no longer returns an empty set). This is the role families, not what is drawn: see `presentationFaces`.
  */
-export declare function presentationFamilies(presentation: unknown, options?: Partial<RenderSvgOptions>): Set<string>;
+export declare function presentationFamilies(presentation: unknown, options?: Partial<ToSvgOptions>): Set<string>;
 /** A face request or a drawn face: a family, a weight and a style. */
 export interface FaceRequest { family: string; weight: number; italic: boolean }
 /**
@@ -140,16 +151,16 @@ export interface FaceRequest { family: string; weight: number; italic: boolean }
  * faces are the styles as the document names them. With `registry` (`{faces, policy, aliases, fallbackFamily}`: the faces a
  * registry holds or could hold and its substitution options) every style resolves as that registry resolves it, in the two
  * steps drawing takes (role family, then weight within it), and the result is the faces the registry paints.
- * `options` are the `renderSvg` options the document resolves with; a document that does not resolve throws what `renderSvg`
+ * `options` are the `toSvg` options the document resolves with; a document that does not resolve throws what `toSvg`
  * throws for it.
  */
-export declare function presentationFaces(presentation: unknown, options?: Partial<RenderSvgOptions>, registry?: { faces: Iterable<FaceRequest>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): FaceRequest[];
+export declare function presentationFaces(presentation: unknown, options?: Partial<ToSvgOptions>, registry?: { faces: Iterable<FaceRequest>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): FaceRequest[];
 /**
  * The vendored faces (of `lazy`) a presentation draws that the registry does not hold. `held` is `registry.describeFaces()`,
  * `loaded` the lazy files already loaded; `policy`, `aliases` and `fallbackFamily` are the registry's. Face level: only the
  * drawn faces, so an edit adding a bold run adds one face.
  */
-export declare function lazyFacesNeeded(presentation: unknown, renderOptions: Partial<RenderSvgOptions> | undefined, context: { lazy: readonly LazyFont[]; held: Iterable<FaceRequest>; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): LazyFont[];
+export declare function lazyFacesNeeded(presentation: unknown, renderOptions: Partial<ToSvgOptions> | undefined, context: { lazy: readonly LazyFont[]; held: Iterable<FaceRequest>; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): LazyFont[];
 /**
  * The vendored faces a list of requests needs that the registry does not hold, following the registry's own order and
  * `policy` (default "visual"): the family itself, an alias target, the declared replacement, then its alternates.

package/dist/fonts-browser.js

@@ -3,6 +3,8 @@ import { lazyFontEntries, lazyFontList, normalizeExtraLazyFonts } from "./lazy-f
 import { lazyFacesNeeded } from "./lazy-fonts.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { textOutlines } from "./text-paths.js";
+import { createSubsetter, fontSubsets } from "./font-subset.js";
+import { instantiateShaper } from "./hb-shape.js";
 import { analyzePresentationScripts, nextFallbackPackage, scriptFontPackages, scriptPackageEntries, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontEntries, scriptFontPackages } from "./script-font-pack.js";
 export { lazyFontEntries, lazyFontList, splitStartupFaces } from "./lazy-font-list.js";
@@ -95,7 +97,7 @@ async function loadRegistry(entries, options = {}) {
   // Script faces (FF-19) are loaded lazily, once a document needs them, and only for the scripts it uses.
   const scriptPackages = new Set();
   let queue = Promise.resolve(), disposed = false;
-  // FF-41: the `renderSvg` options a document resolves with (`catalogs`, ...). `options.renderOptions` are the defaults; a call's own
+  // FF-41: the `toSvg` options a document resolves with (`catalogs`, ...). `options.renderOptions` are the defaults; a call's own
   // options (everything but `signal`) are added over them, so a host that passes its canvas options gets the same resolution here.
   const renderOptionsFor = (callOptions) => { const { signal: _signal, ...own } = callOptions ?? {}; return { ...options.renderOptions, ...own }; };
   const gone = () => new OPFFontError("font-registry-disposed", "The font registry was disposed.");
@@ -149,7 +151,7 @@ async function loadRegistry(entries, options = {}) {
      * fallback needs for characters the loaded faces lack. Cheap when nothing new is needed; call it after edits and
      * render again afterwards. Resolves with the detected scripts, the packages loaded by this call, the scripts no
      * pinned font serves and `uncovered`, drawn CJK characters no loaded face covers (the renderer reports
-     * `missing-glyph` for them). Besides `signal`, the call takes the `renderSvg` options the document resolves with
+     * `missing-glyph` for them). Besides `signal`, the call takes the `toSvg` options the document resolves with
      * (`catalogs`, ...) over the loader's `renderOptions`. Each package loads all or nothing. If some package fails, the others still load: the
      * call then rejects with an OPFFontError (the first failure's code) whose `details` hold `loaded` (packages this
      * call did load) and `failed` (`{package, code, message}` per failed package); nothing is lost and a later call
@@ -174,7 +176,7 @@ async function loadRegistry(entries, options = {}) {
       }
       return { ...selection, loaded: loadedNow, uncovered: uncoveredCjkCharacters(analysis, { covers }) };
     },
-    /** Synchronous: script-pack packages the presentation needs that are not loaded yet. Empty means `ensureScripts` would fetch nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...). */
+    /** Synchronous: script-pack packages the presentation needs that are not loaded yet. Empty means `ensureScripts` would fetch nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...). */
     pendingScripts(presentation, renderOptions) {
       const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(renderOptions));
       const primary = scriptFontPackages(scriptSelectionOf(analysis).scripts).map((item) => item.name).filter((name) => !scriptPackages.has(name));
@@ -192,7 +194,7 @@ async function loadRegistry(entries, options = {}) {
   const policy = options.substitutionPolicy ?? "none";
   const aliasTargets = new Map(Object.entries(options.aliases ?? {}).map(([from, to]) => [from.toLowerCase(), to]));
   // Face level (FF-41): the faces the document draws, resolved as the registry resolves them with every vendored face loaded.
-  // A document that does not resolve throws what `renderSvg` throws for it.
+  // A document that does not resolve throws what `toSvg` throws for it.
   const neededLazy = (presentation, callOptions) => lazyFacesNeeded(presentation, renderOptionsFor(callOptions), { lazy, held: registry.describeFaces(), loaded: lazyLoaded, policy, aliases: aliasTargets, fallbackFamily: options.fallbackFamily });
   const lazyBaseUrl = () => {
     if (typeof options.lazyFontsBaseUrl !== "string" || !options.lazyFontsBaseUrl)
@@ -208,8 +210,8 @@ async function loadRegistry(entries, options = {}) {
      * policy (nothing is downloaded for a family the policy would not resolve), once each. All or nothing: on any failure
      * (fetch, hash, FontFace.load, registry) the document and registry are unchanged and the call can be retried. Cheap when
      * nothing is needed. Call it before measuring a document, and again after edits that change fonts. Resolves with the faces
-     * added. Besides `signal`, the call takes the `renderSvg` options the document resolves with (`catalogs`, ...) over the
-     * loader's `renderOptions`; a document that does not resolve rejects with what `renderSvg` throws for it.
+     * added. Besides `signal`, the call takes the `toSvg` options the document resolves with (`catalogs`, ...) over the
+     * loader's `renderOptions`; a document that does not resolve rejects with what `toSvg` throws for it.
      */
     ensureLazyFonts(presentation, callOptions = {}) {
       const result = queue.then(async () => {
@@ -245,7 +247,7 @@ async function loadRegistry(entries, options = {}) {
       queue = result.catch(() => {});
       return result;
     },
-    /** Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. `renderOptions` are the `renderSvg` options the document resolves with (`catalogs`, ...). */
+    /** Synchronous: the vendored faces the presentation draws under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. `renderOptions` are the `toSvg` options the document resolves with (`catalogs`, ...). */
     pendingLazyFonts: (presentation, renderOptions) => neededLazy(presentation, renderOptions),
   });
   /** Names of the script-pack packages loaded so far. */
@@ -275,13 +277,37 @@ const MAX_ENSURE_ROUNDS = 4;
 /**
  * The fonts handle for a browser: the faces you list (`faces`, each `{ url | data, family, weight, italic, sha256 }`, fetched and
  * hash-verified, then registered with the document) and, on demand, the script and vendored faces a deck draws. Pass it as `{ fonts }` to
- * `renderSvg`, `renderSlideSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor. `scripts`, `scriptBaseUrl`,
+ * `toSvg`, `<opf-deck>` and the player, core `paginate` and `validate`, and the editor. `scripts`, `scriptBaseUrl`,
  * `lazyFontsBaseUrl`, `extraLazyFonts`, `renderOptions`, `signal`, `document`, `fetch`, `crypto` and the registry options
  * (`substitutionPolicy`, `aliases`, `fallbackFamily`, `themeFonts`, `strictGlyphs`) are as for the registry (see `fonts-browser.d.ts`).
  * `dispose()` removes every face from the document.
  */
-export async function loadFonts({ faces = [], ...options } = {}) {
-  const registry = await loadRegistry(faces, options);
+// RR-65: the host's copy of harfbuzzjs's `harfbuzz-subset.wasm` (a URL it serves, the bytes or a compiled module), instantiated
+// asynchronously here (a browser may refuse to compile a large module synchronously on the main thread).
+async function browserSubsetter(source, fetchImpl, signal) {
+  if (source instanceof WebAssembly.Module) return createSubsetter(await WebAssembly.instantiate(source, {}));
+  if (source instanceof ArrayBuffer || ArrayBuffer.isView(source)) return createSubsetter((await WebAssembly.instantiate(source, {})).instance);
+  if (typeof source !== "string" && !(source instanceof URL)) throw new OPFFontError("invalid-font-source", "subsetWasm must be the URL of harfbuzz-subset.wasm, its bytes or a compiled WebAssembly.Module.");
+  const response = await (fetchImpl ?? globalThis.fetch)(String(source), { signal });
+  if (!response.ok) throw new OPFFontError("font-resource-unavailable", `harfbuzz-subset.wasm could not be fetched (${response.status}).`, { url: String(source) });
+  return createSubsetter((await WebAssembly.instantiate(await response.arrayBuffer(), {})).instance);
+}
+
+// RR-64 phase 2: the host's copy of harfbuzzjs's `harfbuzz.wasm`, instantiated asynchronously, so outlines are shaped by HarfBuzz.
+async function browserShaper(source, fetchImpl, signal) {
+  return instantiateShaper(source instanceof WebAssembly.Module || source instanceof ArrayBuffer || ArrayBuffer.isView(source) ? source : await fetchWasm(source, fetchImpl, signal, "harfbuzz.wasm"));
+}
+
+async function fetchWasm(source, fetchImpl, signal, name) {
+  if (typeof source !== "string" && !(source instanceof URL)) throw new OPFFontError("invalid-font-source", `${name} must be given as a URL, its bytes or a compiled WebAssembly.Module.`);
+  const response = await (fetchImpl ?? globalThis.fetch)(String(source), { signal });
+  if (!response.ok) throw new OPFFontError("font-resource-unavailable", `${name} could not be fetched (${response.status}).`, { url: String(source) });
+  return response.arrayBuffer();
+}
+
+export async function loadFonts({ faces = [], subsetWasm, shapeWasm, ...options } = {}) {
+  const [registry, subsetter, shaper] = await Promise.all([loadRegistry(faces, options), subsetWasm === undefined ? null : browserSubsetter(subsetWasm, options.fetch, options.signal),
+    shapeWasm === undefined ? null : browserShaper(shapeWasm, options.fetch, options.signal)]);
   // The embedded list is base64 of every eager face: compute it once, and again only when faces were added.
   let embedded, stale = true;
   const addFaces = registry.addFaces;
@@ -294,15 +320,17 @@ 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 }),
+    // RR-64: the outline engine `toSvg(deck, { fonts, text: "paths" })` draws text with, over this registry's faces.
+    outlines: textOutlines({ registry, shaper }),
+    // RR-65: with `subsetWasm`, the subset engine that cuts each face an SVG embeds to the characters the slide draws.
+    ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),
     manifest: BUNDLED_FONT_MANIFEST,
     get substitutions() { return registry.substitutions; },
     /**
      * Load the vendored and script faces the presentation draws, each hash-verified, all or nothing, and repeat while loading
      * changes what is needed (a script face can need a vendored one). Cheap when nothing is needed. Besides `signal`, the call
-     * takes the `renderSvg` options the document resolves with (`catalogs`, ...) over the loader's `renderOptions`. A document that
-     * does not resolve rejects with what `renderSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
+     * takes the `toSvg` options the document resolves with (`catalogs`, ...) over the loader's `renderOptions`. A document that
+     * does not resolve rejects with what `toSvg` throws for it. After `dispose()` it rejects with `font-registry-disposed`.
      */
     async ensure(presentation, callOptions = {}) {
       const lazy = [], scripts = [];
@@ -316,7 +344,7 @@ export async function loadFonts({ faces = [], ...options } = {}) {
       }
       return { scripts, lazy, uncovered };
     },
-    /** Synchronous: the files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `renderSvg` throws for a document that does not resolve. */
+    /** Synchronous: the files and script packages `ensure` would fetch. Empty means a render can start now. Throws what `toSvg` throws for a document that does not resolve. */
     pending,
     dispose: () => registry.dispose(),
   };

package/dist/fonts-node.d.ts

@@ -1,5 +1,5 @@
 import type {FontRegistry,FontRegistryOptions,FontFaceInput,FontsHandle,EnsureResult,ScriptFontProfile} from "./fonts.js";
-import type {RenderSvgOptions} from "./svg.js";
+import type {ToSvgOptions} from "./svg.js";
 /** A caller-supplied face (FF-31), for example a licensed copy of the real font. Node callers may pass a file path. */
 export type CallerFontFace = FontFaceInput | (Omit<FontFaceInput, "data"> & {path: string});
 /** "all" or ISO 15924 codes (`Jpan`, `Hans`, `Hant`, `Kore`, `Arab`, `Hebr`, `Deva`, `Thai`, ...). */
@@ -16,9 +16,9 @@ export interface AutoScriptSelection {
 /** Script-pack packages that `scripts: "auto"` loaded or found not installed. */
 export interface AppliedScriptSelection extends AutoScriptSelection { packages: string[]; notInstalled: string[]; /** Drawn CJK characters no loaded face covers (glyph fallback stopped at its cap). */ uncovered?: string[] }
 /** Script keys whose faces a preview of the presentation needs: text decides, the document language only tells Han scripts apart. */
-/** `options` may also carry the `renderSvg` options the document resolves with (`catalogs`): a font scheme that exists only in the host's catalogs and names a script font selects that font's script (FF-41). */
-export declare function detectPresentationScripts(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<RenderSvgOptions>): string[];
-export declare function autoScriptSelection(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<RenderSvgOptions>): AutoScriptSelection;
+/** `options` may also carry the `toSvg` options the document resolves with (`catalogs`): a font scheme that exists only in the host's catalogs and names a script font selects that font's script (FF-41). */
+export declare function detectPresentationScripts(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<ToSvgOptions>): string[];
+export declare function autoScriptSelection(presentation: unknown, options?: { profile?: ScriptFontProfile } & Partial<ToSvgOptions>): AutoScriptSelection;
 export interface ScriptPackOptions {
   /** Caller-supplied faces, loaded first so a licensed real font resolves as an exact face (FF-31). */
   faces?: readonly CallerFontFace[];
@@ -30,8 +30,8 @@ export interface ScriptPackOptions {
   scripts?: ScriptSelection | "auto";
   /** The presentation whose text decides `scripts: "auto"`. */
   presentation?: unknown;
-  /** The `renderSvg` options the presentation resolves with (`catalogs`, ...), for the font schemes `scripts: "auto"` reads (FF-41). */
-  renderOptions?: Partial<RenderSvgOptions>;
+  /** The `toSvg` options the presentation resolves with (`catalogs`, ...), for the font schemes `scripts: "auto"` reads (FF-41). */
+  renderOptions?: Partial<ToSvgOptions>;
   /** Receives `script-font-unavailable` and `script-font-not-installed` for `scripts: "auto"`. */
   onDiagnostic?: (diagnostic: {code: string; message: string; script?: string; package?: string; scripts?: string[]}) => void;
 }
@@ -74,7 +74,7 @@ export declare function scriptFontPackages(scripts: ScriptSelection): BundledFon
 export interface NodeFontsHandle extends FontsHandle {
   readonly registry: NodeFontRegistry;
   readonly manifest: BundledFontManifest;
-  /** Every font file the handle holds, for `svgToPng` and `svgToPdf`; includes the script faces `ensure` loaded. */
+  /** Every font file the handle holds, for `toPng` and `toPdf`; includes the script faces `ensure` loaded. */
   readonly fontFiles: string[];
   /** The files are already in `fontFiles`, so a conversion adds no bundled faces. */
   readonly useBundledFonts: false;
@@ -86,9 +86,9 @@ export interface NodeFontsHandle extends FontsHandle {
    * the new faces. A package that is not installed or a script no pinned font serves is reported once through `onDiagnostic`.
    * Resolves with the packages this call added (`scripts`; `lazy` is empty: Node loads every vendored face with its pack).
    */
-  ensure(presentation: unknown, options?: { onDiagnostic?: ScriptPackOptions["onDiagnostic"]; renderOptions?: Partial<RenderSvgOptions> }): Promise<EnsureResult>;
+  ensure(presentation: unknown, options?: { onDiagnostic?: ScriptPackOptions["onDiagnostic"]; renderOptions?: Partial<ToSvgOptions> }): Promise<EnsureResult>;
   /** Synchronous: the script packages the presentation needs that are not loaded yet. */
-  pending(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): string[];
+  pending(presentation: unknown, renderOptions?: Partial<ToSvgOptions>): string[];
 }
 export interface LoadFontsOptions extends FontRegistryOptions, ScriptPackOptions {
   /** `base` (default): the bundled Roboto faces. `office`: the metric and visual substitutes for the Office families plus the open families font schemes select. `none`: only the `faces` you supply. */

package/dist/fonts-node.js

@@ -7,6 +7,8 @@ import { createFontRegistry, OPFFontError } from "./font-registry.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { lazyFontList } from "./lazy-font-list.js";
 import { textOutlines } from "./text-paths.js";
+import { createSubsetter, fontSubsets } from "./font-subset.js";
+import { createShaper } from "./hb-shape.js";
 export { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { analyzePresentationScripts, autoScriptSelection, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontPackages } from "./script-font-pack.js";
@@ -93,7 +95,7 @@ const loadPack = pack => loadPackages(BUNDLED_FONT_MANIFEST.packages.filter(item
 /**
  * Adds the script pack. `scripts` is 'all', ISO 15924 codes, or 'auto' (FF-19): detect the scripts the
  * `presentation` draws and load only their faces. Auto never fails on a missing optional package or a
- * script no pinned font serves; it reports them through `onDiagnostic` and `selection`. `renderOptions` are the host's `renderSvg`
+ * script no pinned font serves; it reports them through `onDiagnostic` and `selection`. `renderOptions` are the host's `toSvg`
  * options (see `analyzePresentationScripts`).
  */
 async function withScripts(loaded, scripts, {presentation, onDiagnostic, renderOptions} = {}) {
@@ -247,9 +249,26 @@ async function ensureFonts(registry, loaded, presentation, {onDiagnostic, render
   return {scripts: loaded.packages.slice(before), lazy: [], uncovered: selection.uncovered ? [...selection.uncovered] : []};
 }
 
+// RR-65: hb-subset from the pinned harfbuzzjs package (MIT), compiled once per process. The module has no imports, so it is
+// instantiated synchronously and toSvg stays synchronous. A copy that cannot be loaded leaves the handle without `subsets`
+// (whole faces, as before RR-65): a byte saving never stops fonts from loading.
+let subsetterPromise;
+function nodeSubsetter() {
+  subsetterPromise ??= readFile(require.resolve("harfbuzzjs/dist/harfbuzz-subset.wasm")).then(createSubsetter, () => null).catch(() => null);
+  return subsetterPromise;
+}
+
+// RR-64 phase 2: HarfBuzz's shaper (harfbuzz.wasm of the same package) for text drawn as outlines, so the outlines are shaped as
+// a browser shapes the text. Without it outlines are shaped with fontkit.
+let shaperPromise;
+function nodeShaper() {
+  shaperPromise ??= readFile(require.resolve("harfbuzzjs/dist/harfbuzz.wasm")).then(createShaper, () => null).catch(() => null);
+  return shaperPromise;
+}
+
 /**
  * The fonts handle: one set of verified font inputs for layout, SVG, editor, PPTX and Node raster export. Pass it as `{ fonts }` to
- * `renderSvg`, `renderSlideSvg`, `svgToPng`, `svgToPdf`, core `paginate` and `validate`, and `toPptx`.
+ * `toSvg`, `toPng`, `toPdf`, core `paginate` and `validate`, and `toPptx`.
  *
  * Bundled, openly licensed faces only: no system font discovery and no network requests. `pack`: `base` (default, Roboto),
  * `office` (the Office substitutes and the open families) or `none` (only the `faces` you supply). Everything else
@@ -266,6 +285,7 @@ export async function loadFonts({pack = "base", embedScriptFonts = false, ...opt
   // The embedded list is base64 of every face: computed on first use, and again after `ensure` added faces.
   let embeddedFonts, fontFiles = [...registry.fontFiles];
   const refresh = () => { embeddedFonts = undefined; fontFiles = [...registry.fontFiles]; };
+  const [subsetter, shaper] = await Promise.all([nodeSubsetter(), nodeShaper()]);
   return {
     textMeasurement: registry.textMeasurement,
     get embeddedFonts() { return (embeddedFonts ??= selectEmbedded()); },
@@ -273,8 +293,10 @@ 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 }),
+    // RR-64: the outline engine `toSvg(deck, { fonts, text: "paths" })` draws text with, over this registry's faces.
+    outlines: textOutlines({ registry, shaper }),
+    // RR-65: the subset engine that cuts each face an SVG embeds to the characters the slide draws.
+    ...(subsetter ? { subsets: fontSubsets(registry, subsetter) } : {}),
     manifest: BUNDLED_FONT_MANIFEST,
     get substitutions() { return registry.substitutions; },
     /** Load the script faces the presentation's text needs (see `ensureFonts`); `embeddedFonts` and `fontFiles` then include them. */

package/dist/fonts.d.ts

@@ -34,14 +34,14 @@ export interface FontRegistryOptions {
 export declare const FONT_COMPATIBILITY: readonly Readonly<{requestedFamily:string;substitutes:readonly string[];compatibility:"metric"|"visual";weights?:readonly number[];weight?:number;source?:string;measured?:FontReplacementMeasurement;decision?:string;metricModeFallback?:true;licenseClass?:FontPolicyEntry['licenseClass'];note:string}>[];
 export declare const EXPERIMENTAL_FONT_CANDIDATES: readonly Readonly<{requestedFamily:string;substitute:string;source:string;note:string}>[];
 /**
- * What the deck-level functions read from their `fonts` option: `renderSvg`, `renderSlideSvg` and `<opf-deck>` take the measurement and
- * the faces to embed; `svgToPng` and `svgToPdf` (Node) take the font files; core `paginate`, `validate` and `resolveSlideContext` take the
+ * What the deck-level functions read from their `fonts` option: `toSvg` and `<opf-deck>` take the measurement and
+ * the faces to embed; `toPng` and `toPdf` (Node) take the font files; core `paginate`, `validate` and `resolveSlideContext` take the
  * measurement. The object `loadFonts()` returns is a `FontsHandle`, which extends this; any object with these fields works.
  */
 export interface RenderFonts {
   /** Measures text with the real faces. Without it layout uses core's portable estimate. */
   textMeasurement?: TextMeasurement;
-  /** 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). */
+  /** Faces `toSvg` 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,10 +49,14 @@ 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. */
+  /** The outline engine `text: "paths"` draws text with (RR-64); a `loadFonts` handle carries one over its registry's faces. */
   outlines?: TextOutlines;
+  /** The subset engine (RR-65): each face an SVG embeds is cut to the characters the slide draws. The Node `loadFonts` handle carries one; a browser handle with `subsetWasm`. */
+  subsets?: FontSubsets;
 }
-/** Draws a slide's text as glyph outlines (RR-64). Read by `renderSvg`; hosts pass the handle and `textAsPaths: true`. */
+/** Cuts an embedded face to code points (RR-65), with hb-subset; a face whose license, Reserved Font Name or fsType does not allow it keeps its own data URL. */
+export interface FontSubsets { subsetDataUrl(font: EmbeddedFont, codePoints: Iterable<number>): string }
+/** Draws a slide's text as glyph outlines (RR-64). Read by `toSvg`; hosts pass the handle and `text: "paths"`. */
 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[] }
@@ -62,7 +66,7 @@ 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. */
+  /** The outline engine for `text: "paths"` (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[] };

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);
+      }
+    },
+  };
+}