@openpresentation/opf-render 0.11.3 → 0.11.5

package/dist/fonts-browser.d.ts

@@ -4,6 +4,7 @@ import type {
   FontRegistryOptions,
 } from "./fonts.js";
 import type { AutoScriptSelection, BundledFontPackage, LazyFont, ScriptSelection } from "./fonts-node.js";
+import type { RenderSvgOptions } from "./svg.js";
 export type { LazyFont } from "./fonts-node.js";
 export type { AutoScriptSelection } from "./fonts-node.js";
 export { detectPresentationScripts, autoScriptSelection } from "./fonts-node.js";
@@ -18,15 +19,22 @@ export interface BrowserFontRegistry extends FontRegistry {
   /** Every vendored face a host can load on demand: family, style, package-relative file and pinned sha256. */
   readonly lazyFonts: readonly LazyFont[];
   /**
-   * Load the vendored faces (for example Intos for the default Aptos scheme) the presentation's font families resolve to
-   * under the registry's `substitutionPolicy` (nothing is downloaded for a family the policy would not resolve), 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. After
-   * `dispose()` it rejects with `font-registry-disposed`.
+   * Load the vendored faces (for example Intos Display 700 and Intos 400 for a plain deck in the default Aptos scheme) the
+   * presentation draws, resolved as the registry resolves them under its `substitutionPolicy` (nothing is downloaded for a
+   * 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
+   * 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`.
+   */
+  ensureLazyFonts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): 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(presentation: unknown, options?: { signal?: AbortSignal }): Promise<LazyFont[]>;
-  /** Synchronous: the vendored faces the presentation needs under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. */
-  pendingLazyFonts(presentation: unknown): LazyFont[];
+  pendingLazyFonts(presentation: unknown, renderOptions?: Partial<RenderSvgOptions>): 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[]>;
@@ -39,9 +47,9 @@ 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 }): 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. */
-  pendingScripts(presentation: unknown): string[];
+  ensureScripts(presentation: unknown, options?: { signal?: AbortSignal } & Partial<RenderSvgOptions>): 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[];
   /** Names of the script-pack packages loaded so far. */
   readonly loadedScriptPackages: string[];
 }
@@ -60,6 +68,12 @@ export declare function loadBrowserFontRegistry(
     scriptBaseUrl?: string;
     /** Where the host serves this package's `fonts` directory, so vendored faces (Intos, the open families) load on demand from `<base>/<package-relative file>` (fonts/intos/..., fonts/<family>/...). */
     lazyFontsBaseUrl?: string;
+    /**
+     * FF-41: the `renderSvg` 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>;
   },
 ): Promise<BrowserFontRegistry>;
 export declare function scriptFontPackages(scripts: ScriptSelection): BundledFontPackage[];
@@ -72,10 +86,37 @@ export declare function scriptFontEntries(
 export declare function lazyFontList(): readonly LazyFont[];
 /** Hash-pinned browser entries for the vendored faces, served by the host from `baseUrl` at their package-relative paths. */
 export declare function lazyFontEntries(options: { baseUrl: string }, list?: readonly LazyFont[]): (BrowserFontInput & { url: string; family: string; weight: number; italic: boolean; sha256: string; package: string })[];
-/** The font families a presentation's slides resolve (heading, body and code roles); empty for a document that does not resolve. */
-export declare function presentationFamilies(presentation: unknown): Set<string>;
 /**
- * The vendored faces a set of resolved families needs that the registry does not hold, following the registry's own order and
+ * 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`
+ * 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>;
+/** A face request or a drawn face: a family, a weight and a style. */
+export interface FaceRequest { family: string; weight: number; italic: boolean }
+/**
+ * The faces a preview of the presentation draws (FF-41), sorted by family, style and weight: the renderer's own layout and
+ * painting with a recording measurement, so heading and body roles, bold and italic runs, tables, furniture, chart labels and
+ * the code role (only where code is drawn), per-slide overrides and script slots are all followed. Without `registry` the
+ * 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`
+ * 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[];
+/**
+ * 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[];
+/**
+ * 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.
+ * Entries are face requests (`presentationFaces`), resolved as the registry resolves them with every vendored face loaded
+ * over `held` (`registry.describeFaces()`), so only the faces asked for are returned and a partially loaded family still
+ * loads its missing faces; or family names, which mean every face of the family. Without `held` a face request falls back to
+ * family level with `hasFamily`.
  */
-export declare function lazyFontsFor(families: Iterable<string>, context: { lazy: readonly LazyFont[]; hasFamily(family: string): boolean; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string> }): LazyFont[];
+export declare function lazyFontsFor(entries: Iterable<string | { family: string; weight?: number; italic?: boolean }>, context: { lazy: readonly LazyFont[]; held?: Iterable<FaceRequest>; hasFamily?: (family: string) => boolean; loaded?: ReadonlySet<string>; policy?: "none" | "metric" | "visual"; aliases?: ReadonlyMap<string, string>; fallbackFamily?: string }): LazyFont[];

package/dist/fonts-browser.js

@@ -1,10 +1,10 @@
 import { createFontRegistry, OPFFontError } from "./fonts.js";
 import { lazyFontEntries, lazyFontList } from "./lazy-font-list.js";
-import { lazyFontsFor, presentationFamilies } from "./lazy-fonts.js";
+import { lazyFacesNeeded } from "./lazy-fonts.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 } from "./lazy-font-list.js";
-export { lazyFontsFor, presentationFamilies } from "./lazy-fonts.js";
+export { lazyFacesNeeded, lazyFontsFor, presentationFaces, presentationFamilies } from "./lazy-fonts.js";
 
 async function verifyDigest(entry, data, subtle) {
   if (entry.sha256 === undefined) return;
@@ -91,6 +91,9 @@ export async function loadBrowserFontRegistry(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
+  // 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.");
   const baseUrl = () => {
     if (typeof options.scriptBaseUrl !== "string" || !options.scriptBaseUrl)
@@ -142,14 +145,15 @@ export async function loadBrowserFontRegistry(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). Each package loads all or nothing. If some package fails, the others still load: the
+     * `missing-glyph` for them). Besides `signal`, the call takes the `renderSvg` 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
      * retries only the failures. `signal` aborts this call's fetches.
      */
     async ensureScripts(presentation, callOptions) {
       if (disposed) throw gone();
-      const analysis = analyzePresentationScripts(presentation), selection = scriptSelectionOf(analysis);
+      const analysis = analyzePresentationScripts(presentation, undefined, renderOptionsFor(callOptions)), selection = scriptSelectionOf(analysis);
       const loadedNow = [], failed = [];
       const attempt = async (item) => {
         try { loadedNow.push(...(await loadPackageList([item], callOptions))); }
@@ -166,9 +170,9 @@ export async function loadBrowserFontRegistry(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. */
-    pendingScripts(presentation) {
-      const analysis = analyzePresentationScripts(presentation);
+    /** 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`, ...). */
+    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));
       if (primary.length) return primary;
       const next = nextFallbackPackage(analysis, { covers, loaded: scriptPackages });
@@ -181,8 +185,9 @@ export async function loadBrowserFontRegistry(entries, options = {}) {
   const lazy = lazyFontList(), lazyLoaded = new Set();
   const policy = options.substitutionPolicy ?? "none";
   const aliasTargets = new Map(Object.entries(options.aliases ?? {}).map(([from, to]) => [from.toLowerCase(), to]));
-  const hasFamily = (family) => registry.describeFaces().some((face) => face.family.toLowerCase() === String(family).toLowerCase());
-  const neededLazy = (presentation) => lazyFontsFor(presentationFamilies(presentation), { lazy, hasFamily, loaded: lazyLoaded, policy, aliases: aliasTargets });
+  // 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.
+  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)
       throw new OPFFontError("invalid-font-source", "Loading vendored fonts requires lazyFontsBaseUrl, where the host serves the package's fonts directory.");
@@ -192,16 +197,19 @@ export async function loadBrowserFontRegistry(entries, options = {}) {
     /** Every vendored face a host can load on demand: family, style, package-relative file and pinned sha256. */
     lazyFonts: lazy,
     /**
-     * Load the vendored faces the presentation's font families resolve to under the registry's substitution 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.
+     * Load the vendored faces the presentation draws (FF-41: only the faces, by family, weight and style, that the renderer
+     * draws; a bold or italic run added by an edit adds just that face) as the registry resolves them under its substitution
+     * 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.
      */
     ensureLazyFonts(presentation, callOptions = {}) {
       const result = queue.then(async () => {
         if (disposed) throw gone();
         callOptions.signal?.throwIfAborted?.();
-        const pending = neededLazy(presentation);
+        const pending = neededLazy(presentation, callOptions);
         if (!pending.length) return [];
         const fetched = (await fetchFaces(lazyFontEntries({ baseUrl: lazyBaseUrl() }, pending), callOptions.signal)).map((entry) => ({ ...entry, embed: "used" }));
         let browserFaces;
@@ -229,8 +237,8 @@ export async function loadBrowserFontRegistry(entries, options = {}) {
       queue = result.catch(() => {});
       return result;
     },
-    /** Synchronous: the vendored faces the presentation needs under the registry's policy that are not loaded yet. Empty means `ensureLazyFonts` fetches nothing. */
-    pendingLazyFonts: (presentation) => neededLazy(presentation),
+    /** 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`, ...). */
+    pendingLazyFonts: (presentation, renderOptions) => neededLazy(presentation, renderOptions),
   });
   /** Names of the script-pack packages loaded so far. */
   Object.defineProperty(registry, "loadedScriptPackages", { get: () => [...scriptPackages], enumerable: true });

package/dist/fonts-node.d.ts

@@ -1,4 +1,5 @@
 import type {FontRegistry,FontRegistryOptions,EmbeddedFont,FontFaceInput,ScriptFontProfile} from "./fonts.js";
+import type {RenderSvgOptions} 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`, ...). */
@@ -15,8 +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. */
-export declare function detectPresentationScripts(presentation: unknown, options?: { profile?: ScriptFontProfile }): string[];
-export declare function autoScriptSelection(presentation: unknown, options?: { profile?: ScriptFontProfile }): AutoScriptSelection;
+/** `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;
 export interface ScriptPackOptions {
   /** Caller-supplied faces, loaded first so a licensed real font resolves as an exact face (FF-31). */
   faces?: readonly CallerFontFace[];
@@ -28,6 +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>;
   /** 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;
 }

package/dist/fonts-node.js

@@ -7,7 +7,7 @@ import { createFontRegistry, OPFFontError } from "./fonts.js";
 import { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
 import { lazyFontList } from "./lazy-font-list.js";
 export { BUNDLED_FONT_MANIFEST } from "./font-manifest.js";
-import { analyzePresentationScripts, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
+import { analyzePresentationScripts, autoScriptSelection, nextFallbackPackage, scriptFontPackages, scriptSelectionOf, uncoveredCjkCharacters } from "./script-font-pack.js";
 export { autoScriptSelection, detectPresentationScripts, scriptFontPackages } from "./script-font-pack.js";
 // Script faces are embedded in a standalone SVG only when the slide's text uses their family.
 const embedUsed = entries => entries.map(entry => ({...entry, embed: "used"}));
@@ -78,9 +78,10 @@ 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`.
+ * script no pinned font serves; it reports them through `onDiagnostic` and `selection`. `renderOptions` are the host's `renderSvg`
+ * options (see `analyzePresentationScripts`).
  */
-async function withScripts(loaded, scripts, {presentation, onDiagnostic} = {}) {
+async function withScripts(loaded, scripts, {presentation, onDiagnostic, renderOptions} = {}) {
   if (scripts === undefined || (Array.isArray(scripts) && !scripts.length)) return loaded;
   // 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));
@@ -89,7 +90,7 @@ async function withScripts(loaded, scripts, {presentation, onDiagnostic} = {}) {
     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});
-  const selection = scriptSelectionOf(analyzePresentationScripts(presentation)), skipped = [];
+  const selection = scriptSelectionOf(analyzePresentationScripts(presentation, undefined, renderOptions)), skipped = [];
   const extra = await loadPackages(notLoaded(scriptFontPackages(selection.scripts)), skipped);
   for (const script of selection.unavailable) onDiagnostic?.({code: "script-font-unavailable", script, message: `No pinned open font serves script '${script}'; that text uses the design font.`});
   for (const item of skipped) onDiagnostic?.({code: "script-font-not-installed", package: item.package, scripts: item.scripts, message: `Install ${item.package}@${item.version} to preview ${item.scripts.join(", ")} text with its designated open font.`});
@@ -102,12 +103,12 @@ async function withScripts(loaded, scripts, {presentation, onDiagnostic} = {}) {
  * has (Japanese-only kanji in a Simplified Chinese run, hanja) needs the next CJK face along the fallback chain.
  * Adds those packages to the registry and its fontFiles until every such character is covered or the chain ends.
  */
-async function completeFallback(registry, presentation, loaded, onDiagnostic) {
+async function completeFallback(registry, presentation, loaded, onDiagnostic, renderOptions) {
   const selection = loaded.selection;
   if (!selection) return;
   const seen = new Set([...selection.packages, ...selection.notInstalled]);
   for (;;) {
-    const analysis = analyzePresentationScripts(presentation), covers = character => registry.scriptFacesCover(character);
+    const analysis = analyzePresentationScripts(presentation, undefined, renderOptions), covers = character => registry.scriptFacesCover(character);
     const next = nextFallbackPackage(analysis, {covers, loaded: seen});
     if (!next) {
       const uncovered = uncoveredCjkCharacters(analysis, {covers, limit: 8});
@@ -152,17 +153,17 @@ async function withFaces(loaded, faces) {
 }
 
 /** Bundled, openly licensed faces. No system font discovery or network requests. */
-export async function loadBundledFontRegistry({scripts, faces, presentation, onDiagnostic, ...options} = {}) {
-  const {entries, fontFiles, selection} = await withFaces(await withScripts(await loadPack("base"), scripts, {presentation, onDiagnostic}), faces);
+export async function loadBundledFontRegistry({scripts, faces, presentation, onDiagnostic, renderOptions, ...options} = {}) {
+  const {entries, fontFiles, selection} = await withFaces(await withScripts(await loadPack("base"), scripts, {presentation, onDiagnostic, renderOptions}), faces);
   const registry = Object.assign(createFontRegistry(entries,options),{fontFiles, ...(selection ? {scriptSelection: selection} : {})});
   registry.lazyFonts = lazyOf(registry);
-  await completeFallback(registry, presentation, {fontFiles, selection}, onDiagnostic);
+  await completeFallback(registry, presentation, {fontFiles, selection}, onDiagnostic, renderOptions);
   return registry;
 }
 
 /** Office substitutes plus the open families that font schemes select (FF-31),
  * optionally alongside the base Roboto pack. `includeOpenFonts: false` leaves the open families out. */
-export async function loadOfficeFontRegistry({scripts, faces, presentation, onDiagnostic, ...options} = {}) {
+export async function loadOfficeFontRegistry({scripts, faces, presentation, onDiagnostic, renderOptions, ...options} = {}) {
   const {entries, fontFiles, packages} = await loadPack("office");
   for (const [include, pack] of [[options.includeOpenFonts, "open"], [options.includeBaseFonts, "base"]]) {
     if (include === false) continue;
@@ -174,17 +175,20 @@ export async function loadOfficeFontRegistry({scripts, faces, presentation, onDi
   // Noto Sans (regular, bold, italic, bold italic) is the default Latin, Cyrillic and Greek fallback face
   // (glyph fallback), so Georgia with Russian text previews without the scripts option. It is embedded in an
   // SVG only when the slide's text draws it (embed "used"); raster output reads it from fontFiles. Unless the
-  // caller asked for it with scripts it is fallback-only, so no other family's preview changes.
-  const requested = scripts === undefined || scripts === "auto" || (Array.isArray(scripts) && !scripts.length) ? [] : scriptFontPackages(scripts).map(pkg => pkg.name);
+  // caller asked for it with scripts it is fallback-only, so no other family's preview changes. "auto" counts as asking for it when the
+  // presentation itself selects Latn (a Sylfaen scheme: Noto Sans is its designated replacement, which a fallback-only face never is), as
+  // 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});
   fontFiles.push(...fallback.fontFiles);
   entries.push(...fallback.entries);
   packages.push(...fallback.packages);
-  const loaded = await withFaces(await withScripts({entries, fontFiles, packages}, scripts, {presentation, onDiagnostic}), faces);
+  const loaded = await withFaces(await withScripts({entries, fontFiles, packages}, scripts, {presentation, onDiagnostic, renderOptions}), faces);
   const aliases = options.includeOpenFonts === false ? options.aliases : {...renamedAliases(), ...options.aliases};
   const registry = Object.assign(createFontRegistry(loaded.entries,{substitutionPolicy:"metric",...options,...(aliases?{aliases}:{})}),{fontFiles:loaded.fontFiles, ...(loaded.selection ? {scriptSelection: loaded.selection} : {})});
   registry.lazyFonts = lazyOf(registry);
-  await completeFallback(registry, presentation, loaded, onDiagnostic);
+  await completeFallback(registry, presentation, loaded, onDiagnostic, renderOptions);
   return registry;
 }
 

package/dist/fonts.js

@@ -45,6 +45,83 @@ function unavailableFontError(family, style, policy) {
   return new OPFFontError("font-unavailable", `No local font face for '${family}'. ${owner} None of its replacements (${candidates.join(", ")}) is loaded${packs.length ? `; load the ${packs.map(pack=>"'"+pack+"'").join(" or ")} font pack` : ""}, or ${hook}. The PPTX names '${family}' either way.`, details);
 }
 /** Local font files only. The caller explicitly chooses aliases and fallback. */
+// fontkit 2.0.4 cannot decode every OpenType lookup: its GSUB type 8 (reverse chaining contextual single substitution) struct lacks the
+// backtrackGlyphCount field, so the lookup fails with "Not a fixed size" when a feature that references it is applied, and it has no processor
+// for the type anyway. Noto Sans Mongolian 3.x has such a lookup under calt and rclt in every script, so every shaping of the face threw (FF-44).
+// A lookup that cannot be decoded is treated as one that applies nothing (no subtables), so the rest of the feature still runs: advances equal
+// a browser's for the face's Latin and Mongolian samples (test/mongolian-shaping.mjs). Applied only after shaping failed, once per font.
+const lookupsGuarded = new WeakSet();
+function skipUndecodableLookups(font) {
+  if (lookupsGuarded.has(font)) return false;
+  lookupsGuarded.add(font);
+  let guarded = false;
+  for (const tag of ["GSUB", "GPOS"]) {
+    let list;
+    try { list = font[tag]?.lookupList; } catch { continue; }
+    if (typeof list?.get !== "function") continue;
+    const get = list.get.bind(list);
+    list.get = index => { try { return get(index); } catch { return { lookupType: 1, flags: {}, subTables: [] }; } };
+    guarded = true;
+  }
+  return guarded;
+}
+
+/**
+ * The face a registry draws for `family` (a validated concrete family: theme tokens are already resolved) in `style`, chosen
+ * from `faces` ({family, familyGroup, weight, italic, fallbackOnly?, scripts?}) under the substitution policy, aliases and
+ * fallback family, or an OPFFontError when none applies. Shared by the registry's resolution and by the lazy loader's face
+ * planning (lazy-fonts.js), so the browser loads exactly the faces Node would draw with everything loaded.
+ */
+export function pickFace(faces, family, style, {policy = "none", aliases = new Map(), fallbackFamily} = {}) {
+  const findFamily = name => faces.filter(face=>face.family.toLowerCase()===name.toLowerCase() || face.familyGroup.toLowerCase()===name.toLowerCase());
+  const weight = style.fontWeight ?? 400;
+  let matching = findFamily(family), compatibility = "exact", rule, targetWeight = weight, styleFallback = false, via = "family";
+  const encodedSymbol = /^(wingdings(?: [23])?|webdings|symbol)$/i.test(family);
+  if (!matching.length && encodedSymbol) throw new OPFFontError("font-encoding-required", `Font '${family}' requires character mapping before substitution.`, {path:style.path,fontFamily:family});
+  if (!matching.length && aliases.has(family.toLowerCase())) {
+    matching = findFamily(aliases.get(family.toLowerCase())); compatibility = "visual"; via = "alias";
+  }
+  if (!matching.length && policy!=="none") {
+    const candidate = FONT_COMPATIBILITY.find(entry=>entry.requestedFamily.toLowerCase()===family.toLowerCase());
+    const tier = candidate?.compatibility==="metric" && !candidate.weights.includes(weight) ? "visual" : candidate?.compatibility;
+    // A declared visual replacement is used in visual mode, and in metric mode only when the
+    // policy keeps it as a metric-mode fallback (Cambria -> Caladea); it is still reported visual.
+    // In metric mode the fallback applies only where the pre-FF-31 metric rule did: the declared
+    // replacement at weights 400 and 700, normal or italic, with an exact face weight.
+    const metricFallback = policy!=="visual" && candidate?.metricModeFallback===true && [400,700].includes(weight);
+    const allowVisual = policy==="visual" || metricFallback;
+    if (candidate && (allowVisual || tier==="metric")) {
+      // A family that names its weight (Segoe UI Semibold, Arial Black) selects that weight in
+      // the replacement; its bold style link still selects bold (FF-31).
+      const wanted = candidate.weight ? (weight>=600 ? Math.max(candidate.weight,700) : candidate.weight) : weight;
+      for (const [index, substitute] of candidate.substitutes.entries()) {
+        // Only the declared replacement can carry the row's metric claim; an alternate is visual.
+        const substituteTier = index===0 ? tier : "visual";
+        if (substituteTier==="visual" && !(policy==="visual" || metricFallback && index===0)) continue;
+        const exactWeight = substituteTier==="metric" || policy!=="visual";
+        const pool = findFamily(substitute).filter(face=>!face.fallbackOnly && (!exactWeight || face.weight===weight));
+        let available = pool.filter(face=>face.italic===!!style.italic);
+        // Visual replacements without the requested style draw the other one and say so.
+        if (!available.length && substituteTier==="visual" && policy==="visual" && pool.length) { available = pool.filter(face=>!face.italic); styleFallback = available.length>0; }
+        if (available.length) { matching=available; compatibility=substituteTier; rule={...candidate, substituteIndex:index}; targetWeight=wanted; via="replacement"; break; }
+      }
+    }
+  }
+  // Equations require an explicit math-aware choice; never fall through to body text.
+  if (!matching.length && /^(cambria math|stix two math|noto sans math)$/i.test(family)) throw new OPFFontError("math-font-required", `Supply '${family}' or an explicit math-font alias.`, {path:style.path});
+  if (!matching.length && fallbackFamily) { matching=findFamily(fallbackFamily); compatibility="generic"; via="fallback"; }
+  if (!matching.length) throw unavailableFontError(family, style, policy);
+  const styled = styleFallback ? matching : matching.filter(face=>face.italic===!!style.italic);
+  // Script replacement faces have no italics; use upright glyphs and advances.
+  if (!styled.length && style.italic && matching.length && matching.every(face=>face.scripts)) { if (compatibility!=="generic") compatibility="visual"; }
+  else matching = styled;
+  if (!matching.length) throw new OPFFontError("font-style-unavailable", `No ${style.italic ? "italic" : "upright"} face for '${family}'.`, {path:style.path});
+  matching.sort((a,b)=>Math.abs(a.weight-targetWeight)-Math.abs(b.weight-targetWeight) || a.weight-b.weight);
+  const face = matching[0];
+  if ((face.weight!==targetWeight || styleFallback) && compatibility!=="generic") compatibility="visual";
+  return {face, compatibility, rule, styleFallback, via};
+}
+
 export function createFontRegistry(entries, options = {}) {
   if (!Array.isArray(entries) || !entries.length) throw new OPFFontError("empty-font-registry", "Supply at least one font file.");
   const makeFace = entry => {
@@ -106,7 +183,6 @@ export function createFontRegistry(entries, options = {}) {
   const policy = options.substitutionPolicy ?? "none";
   if (!["none","metric","visual"].includes(policy)) throw new OPFFontError("invalid-font-policy", "substitutionPolicy must be none, metric, or visual.");
   if (options.fallbackFamily) validFamily(options.fallbackFamily);
-  const findFamily = family => faces.filter(face=>face.family.toLowerCase()===family.toLowerCase() || face.familyGroup.toLowerCase()===family.toLowerCase());
   const resolve = style => {
     const requested = validFamily(style?.fontFamily);
     const weight = style.fontWeight ?? 400;
@@ -117,50 +193,7 @@ export function createFontRegistry(entries, options = {}) {
     const family = themeKey ? options.themeFonts?.[themeKey] : requested;
     if (!family || family.startsWith("+")) throw new OPFFontError("unresolved-theme-font", `Supply a concrete theme family for '${requested}'.`, {path:style.path});
     validFamily(family);
-    let matching = findFamily(family), compatibility = "exact", rule, targetWeight = weight, styleFallback = false, via = "family";
-    const encodedSymbol = /^(wingdings(?: [23])?|webdings|symbol)$/i.test(family);
-    if (!matching.length && encodedSymbol) throw new OPFFontError("font-encoding-required", `Font '${family}' requires character mapping before substitution.`, {path:style.path,fontFamily:family});
-    if (!matching.length && aliases.has(family.toLowerCase())) {
-      matching = findFamily(aliases.get(family.toLowerCase())); compatibility = "visual"; via = "alias";
-    }
-    if (!matching.length && policy!=="none") {
-      const candidate = FONT_COMPATIBILITY.find(entry=>entry.requestedFamily.toLowerCase()===family.toLowerCase());
-      const tier = candidate?.compatibility==="metric" && !candidate.weights.includes(weight) ? "visual" : candidate?.compatibility;
-      // A declared visual replacement is used in visual mode, and in metric mode only when the
-      // policy keeps it as a metric-mode fallback (Cambria -> Caladea); it is still reported visual.
-      // In metric mode the fallback applies only where the pre-FF-31 metric rule did: the declared
-      // replacement at weights 400 and 700, normal or italic, with an exact face weight.
-      const metricFallback = policy!=="visual" && candidate?.metricModeFallback===true && [400,700].includes(weight);
-      const allowVisual = policy==="visual" || metricFallback;
-      if (candidate && (allowVisual || tier==="metric")) {
-        // A family that names its weight (Segoe UI Semibold, Arial Black) selects that weight in
-        // the replacement; its bold style link still selects bold (FF-31).
-        const wanted = candidate.weight ? (weight>=600 ? Math.max(candidate.weight,700) : candidate.weight) : weight;
-        for (const [index, substitute] of candidate.substitutes.entries()) {
-          // Only the declared replacement can carry the row's metric claim; an alternate is visual.
-          const substituteTier = index===0 ? tier : "visual";
-          if (substituteTier==="visual" && !(policy==="visual" || metricFallback && index===0)) continue;
-          const exactWeight = substituteTier==="metric" || policy!=="visual";
-          const faces = findFamily(substitute).filter(face=>!face.fallbackOnly && (!exactWeight || face.weight===weight));
-          let available = faces.filter(face=>face.italic===!!style.italic);
-          // Visual replacements without the requested style draw the other one and say so.
-          if (!available.length && substituteTier==="visual" && policy==="visual" && faces.length) { available = faces.filter(face=>!face.italic); styleFallback = available.length>0; }
-          if (available.length) { matching=available; compatibility=substituteTier; rule={...candidate, substituteIndex:index}; targetWeight=wanted; via="replacement"; break; }
-        }
-      }
-    }
-    // Equations require an explicit math-aware choice; never fall through to body text.
-    if (!matching.length && /^(cambria math|stix two math|noto sans math)$/i.test(family)) throw new OPFFontError("math-font-required", `Supply '${family}' or an explicit math-font alias.`, {path:style.path});
-    if (!matching.length && options.fallbackFamily) { matching=findFamily(options.fallbackFamily); compatibility="generic"; via="fallback"; }
-    if (!matching.length) throw unavailableFontError(family, style, policy);
-    const styled = styleFallback ? matching : matching.filter(face=>face.italic===!!style.italic);
-    // Script replacement faces have no italics; use upright glyphs and advances.
-    if (!styled.length && style.italic && matching.length && matching.every(face=>face.scripts)) { if (compatibility!=="generic") compatibility="visual"; }
-    else matching = styled;
-    if (!matching.length) throw new OPFFontError("font-style-unavailable", `No ${style.italic ? "italic" : "upright"} face for '${family}'.`, {path:style.path});
-    matching.sort((a,b)=>Math.abs(a.weight-targetWeight)-Math.abs(b.weight-targetWeight) || a.weight-b.weight);
-    const face = matching[0];
-    if ((face.weight!==targetWeight || styleFallback) && compatibility!=="generic") compatibility="visual";
+    const {face, compatibility, rule, styleFallback, via} = pickFace(faces, family, style, {policy, aliases, fallbackFamily:options.fallbackFamily});
     // FF-31: `substitute` is true whenever the face is not the chosen family itself (policy
     // replacement, alias, script replacement or fallback). Exporters keep writing sourceFamily.
     const substitute = via!=="family", policyRow = substitute ? fontPolicyFor(family) : undefined;
@@ -203,11 +236,15 @@ export function createFontRegistry(entries, options = {}) {
       let run;
       try { run=shape(); }
       catch (error) {
+        // A lookup fontkit cannot decode (GSUB type 8 in Noto Sans Mongolian) applies nothing; shape again with the rest (FF-44).
+        if (skipUndecodableLookups(face.font)) { try { run=shape(); } catch { /* the mark retry below */ } }
         // fontkit rejects some mark-attachment lookups (null anchors, for example
         // Gurmukhi tippi in Noto Sans Gurmukhi). Mark positioning moves marks
         // without changing advances, so measure again without it (FF-19).
-        try { run=shape({abvm:false,blwm:false,mark:false,mkmk:false}); }
-        catch { throw new OPFFontError("font-shaping-failed", `Font '${face.family}' cannot shape this text.`, {path:style.path,fontFamily:face.family,cause:error?.message}); }
+        if (!run) {
+          try { run=shape({abvm:false,blwm:false,mark:false,mkmk:false}); }
+          catch { throw new OPFFontError("font-shaping-failed", `Font '${face.family}' cannot shape this text.`, {path:style.path,fontFamily:face.family,cause:error?.message}); }
+        }
       }
       value={width:run.positions.reduce((total,position)=>total+position.xAdvance,0)/face.font.unitsPerEm,...value};
       if(includeOutline) {