@openpresentation/opf-editor 0.12.1 → 0.15.0

package/dist/export.d.ts

@@ -1,5 +1,5 @@
 import type { RenderSvgOptions } from "@openpresentation/opf-render";
-import type { FontGate } from "./canvas.js";
+import type { EditorFonts } from "./canvas.js";
 
 export type ExportFormat = "pdf" | "png" | "svg";
 export declare const EXPORT_FORMATS: Readonly<Record<ExportFormat, { extension: string; type: string; label: string }>>;
@@ -44,12 +44,12 @@ export interface ExportOptions {
   pdfMode?: "vector" | "raster";
   /** PNG pixel density (and the raster PDF's), 1 to 4; default 2. */
   scale?: number;
-  /** The options the host draws its preview with (`textMeasurement`, `catalogs`, ...). */
+  /** The options the host draws its preview with (`catalogs`, `date`, ...); the fonts go in `fonts`. */
   renderOptions?: RenderSvgOptions;
-  /** A font gate: the faces the deck needs load before anything is drawn. */
-  fonts?: Pick<FontGate, "pending" | "ensure">;
-  /** The browser font registry; its faces are what gets embedded. */
-  registry?: object;
+  /** Host catalogs (merged with `renderOptions.catalogs`). The deck is embedded first (core `embed`), like a saved file. */
+  catalogs?: readonly import("@openpresentation/opf").Catalog[];
+  /** The renderer's fonts handle (`loadFonts()`): it measures the text, loads the faces the deck needs before anything is drawn, and its registry's faces are what gets embedded. */
+  fonts?: EditorFonts;
   /** Faces to embed instead of the registry's. */
   embeddedFonts?: Array<Record<string, unknown>>;
   /** PDF document properties beyond the title and subject taken from the deck. */
@@ -71,7 +71,7 @@ export interface ExportResult {
   slides: number[];
 }
 /**
- * Draw the deck with the renderer the preview uses and convert it. Rejects with an error whose `code` is `export-aborted`, `export-no-slides`,
+ * Draw the deck with the renderer the preview uses and convert it. Rejects with an error whose `code` is `export-aborted`, `export-fonts-unlicensed` (the license rule left the PDF converter no face for some text), `export-no-slides`,
  * `export-format`, `export-unavailable` (PDF and PNG need the renderer's `export-browser` entry), `fonts-unavailable` or a renderer code.
  */
 export declare function exportDeck(deck: unknown, options: ExportOptions): Promise<ExportResult>;

package/dist/export.js

@@ -1,13 +1,15 @@
 // RR-23: download a deck as PDF, PNG or SVG from the editor, next to the PowerPoint export. Everything runs in the page:
-// the slides are drawn by the same renderer the preview uses (`renderSvgDeck`, with the editor's own text measurement), so
-// a download is the preview, not a second layout. Fonts are the registry's: the faces the document needs load through the
-// font gate first, and only faces the registry holds (bundled or hash-pinned, permissively licensed) are embedded, as
+// the slides are drawn by the same renderer the preview uses (`renderSvg`, with the fonts handle's text measurement), so
+// a download is the preview, not a second layout. Fonts are the renderer's fonts handle's: the faces the document needs load through
+// the handle first, and only faces its registry holds (bundled or hash-pinned, permissively licensed) are embedded, as
 // @font-face data in each SVG and as subsets in the PDF. No system font is read and nothing is fetched at export time.
 //
-//   const result = await exportDeck(editor.document, { format: "pdf", renderOptions, fonts: gate, registry, signal, onProgress });
+//   const result = await exportDeck(editor.presentation, { format: "pdf", fonts, renderOptions, signal, onProgress });
 //   // result.download is { name, type, bytes }: one PDF, one PNG or SVG, or a ZIP of the slides.
 
-import { renderSvgDeck } from "@openpresentation/opf-render/svg";
+import { renderSvg } from "@openpresentation/opf-render/svg";
+import { mergeCatalogs, prepareSave } from "./catalogs.js";
+import { fontGate } from "./font-gate.js";
 import { createZip } from "./zip.js";
 
 export const EXPORT_FORMATS = Object.freeze({
@@ -69,6 +71,19 @@ function exportError(code, message, cause) {
   return error;
 }
 
+// The faces a PDF may embed: the same permissive-license list as the SVG (`embeddableFonts`), as the bytes the converter reads. The fonts
+// handle itself is never given to `svgToPdf`: it would embed every face the registry holds, whatever its license.
+function pdfFontData(faces) {
+  return faces.map((face) => {
+    const text = String(face.dataUrl ?? "");
+    const base64 = text.slice(text.indexOf(",") + 1);
+    const binary = atob(base64);
+    const data = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) data[index] = binary.charCodeAt(index);
+    return { family: face.family, data };
+  });
+}
+
 const fontLabel = (face) => `${face.family} ${face.weight}${face.italic ? " italic" : ""}`;
 
 function slideOf(path) {
@@ -110,14 +125,21 @@ async function loadConverters(options) {
  * - `slides`: "current" (with `slideIndex`), "all" (default; hidden slides only with `includeHidden`) or an array of slide numbers.
  * - `pdfMode`: "vector" (default: selectable text, vector shapes) or "raster" (each slide an image).
  * - `scale`: PNG pixel density, 1 to 4 (default 2); also the raster PDF's density.
- * - `renderOptions`: the render options the host draws with (`textMeasurement`, `catalogs`, ...), the same as its preview.
- * - `fonts`: a font gate (`createFontGate`); the faces the deck needs load before anything is drawn.
- * - `registry`: the browser font registry; its faces are what gets embedded.
+ * - `renderOptions`: the render options the host draws with (`catalogs`, `date`, ...), the same as its preview.
+ * - `catalogs`: the host's registered catalogs (`Catalog[]`, merged with `renderOptions.catalogs`). The deck is embedded first (core's
+ *   `embed`), so what is drawn is the self-contained document a save writes.
+ * - `fonts`: the renderer's fonts handle (`loadFonts()` from `@openpresentation/opf-render/fonts-browser`), the one the preview uses. Its
+ *   `textMeasurement` lays the slides out, the faces the deck needs load through its `ensure` before anything is drawn, and its registry's
+ *   faces are what gets embedded: the SVG carries the faces its slides draw, and the PDF embeds the registry's faces (script faces included).
+ *   Both apply the same license rule (OFL-1.1, Apache-2.0, MIT or UFL-1.0): a face whose license text names none of them is left out of the SVG
+ *   and the PDF and reported once as `export-font-license`. Text that needed it is drawn with another face the registry holds and
+ *   reported by the converter (`pdf-font-substituted`, `pdf-glyph-missing`); when no face is left at all the PDF rejects with
+ *   `export-fonts-unlicensed` (the converter's error is its `cause`).
  * - `signal`, `onProgress({ stage, done, total, message })`, `onDiagnostic(diagnostic)`.
  * Resolves `{ download, files, diagnostics, slides }`. Rejects with an error whose `code` is `export-aborted`,
- * `export-no-slides`, `export-unavailable`, `fonts-unavailable` or a renderer code.
+ * `export-fonts-unlicensed`, `export-no-slides`, `export-unavailable`, `fonts-unavailable` or a renderer code.
  */
-export async function exportDeck(deck, options = {}) {
+export async function exportDeck(input, options = {}) {
   const format = EXPORT_FORMATS[options.format];
   if (!format) throw exportError("export-format", `Choose a format: ${Object.keys(EXPORT_FORMATS).join(", ")}.`);
   const { signal } = options;
@@ -125,28 +147,32 @@ export async function exportDeck(deck, options = {}) {
   const note = (diagnostic) => { diagnostics.push(diagnostic); options.onDiagnostic?.(diagnostic); };
   const progress = (stage, done, total, message) => options.onProgress?.({ stage, done, total, message });
   const check = () => { if (signal?.aborted) throw exportError("export-aborted", "The export was cancelled."); };
-  const indexes = slidesToExport(deck, options);
+  const indexes = slidesToExport(input, options);
   if (!indexes.length) throw exportError("export-no-slides", "There are no slides to export.");
   const selected = new Set(indexes);
   const keep = (diagnostic) => diagnostic.slide === undefined || selected.has(diagnostic.slide);
   const scale = Math.min(MAX_PNG_SCALE, Math.max(1, Number(options.scale) || 2));
-  const renderOptions = options.renderOptions ?? {};
+  const catalogs = mergeCatalogs(options.catalogs, options.renderOptions?.catalogs);
+  const renderOptions = { ...(options.renderOptions ?? {}), catalogs };
+  const deck = prepareSave(input, { catalogs }).document;
 
   check();
-  if (options.fonts?.pending?.(deck, renderOptions)?.length) {
+  const gate = fontGate(options.fonts);
+  if (gate?.pending(deck, renderOptions).length) {
     progress("fonts", 0, 1, "Loading fonts…");
-    try { await options.fonts.ensure(deck, { signal, renderOptions }); }
+    try { await gate.ensure(deck, { signal, renderOptions }); }
     catch (error) { if (signal?.aborted) throw exportError("export-aborted", "The export was cancelled."); throw error; }
   }
   check();
   const converters = format.extension === "svg" ? null : await loadConverters(options);
 
-  const embeddedFonts = options.embeddedFonts ?? embeddableFonts(options.registry, (face) => note({ code: "export-font-license", severity: "warning", message: `${fontLabel(face)} is not embedded: its license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0.`, family: face.family }));
+  const dropped = [];
+  const embeddedFonts = options.embeddedFonts ?? embeddableFonts(options.fonts?.registry, (face) => { dropped.push(face); note({ code: "export-font-license", severity: "warning", message: `${fontLabel(face)} is not embedded: its license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0.`, family: face.family }); });
   progress("render", 0, indexes.length, "Drawing slides…");
   await yieldToHost();
-  const rendered = renderSvgDeck(deck, {
+  const rendered = renderSvg(deck, {
     ...renderOptions,
-    embeddedFonts,
+    fonts: { textMeasurement: options.fonts?.textMeasurement, embeddedFonts },
     // The PDF reports problems by element path; the SVG and PNG are the plain drawing.
     trace: format.extension === "pdf",
     onDiagnostic: (diagnostic) => {
@@ -186,12 +212,17 @@ export async function exportDeck(deck, options = {}) {
         scale,
         metadata,
         signal,
+        fontData: pdfFontData(embeddedFonts),
         ...(options.fallbackFamily ? { defaultFontFamily: options.fallbackFamily } : {}),
         onDiagnostic: (diagnostic) => { const described = describeDiagnostic(diagnostic, "pdf"); if (keep(described)) note(described); },
         onProgress: ({ page, pages }) => progress("convert", page, pages, `Page ${page} of ${pages}`),
       });
     } catch (error) {
       if (signal?.aborted) throw exportError("export-aborted", "The export was cancelled.");
+      // The license rule can leave the converter with no face for some text (every face of a family was dropped): say why, not only what.
+      if (dropped.length && /font face/i.test(String(error?.message))) {
+        throw exportError("export-fonts-unlicensed", `The PDF could not be written: ${dropped.map(fontLabel).join(", ")} ${dropped.length === 1 ? "is" : "are"} not embedded because the license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0, and no other face is available. ${error.message}`, error);
+      }
       throw error;
     }
     files = [{ name: exportFileName(deck, "pdf"), type: format.type, bytes }];

package/dist/find-panel.js

@@ -177,7 +177,7 @@ export function createFindPanel(container, options) {
 
   function search(keep) {
     const before = current >= 0 ? result.matches[current] : undefined;
-    result = findMatches(editor.document, state.query, sessionOptions());
+    result = findMatches(editor.presentation, state.query, sessionOptions());
     setError(result.error);
     if (!result.matches.length) current = -1;
     else if (keep && before) {
@@ -231,8 +231,8 @@ export function createFindPanel(container, options) {
   function doReplaceOne() {
     const match = result.matches[current];
     if (!match || !finishCommit()) return;
-    const order = new Map(collectSearchFields(editor.document, sessionOptions()).map((field, index) => [field.pointer, index]));
-    const fieldText = textOf(getValueAtPath(editor.document, match.pointer));
+    const order = new Map(collectSearchFields(editor.presentation, sessionOptions()).map((field, index) => [field.pointer, index]));
+    const fieldText = textOf(getValueAtPath(editor.presentation, match.pointer));
     const written = match.start + expandReplacement(state.replacement, match, fieldText, state.regex).length;
     try {
       replaceMatch(editor, match, state.query, state.replacement, sessionOptions());
@@ -246,8 +246,8 @@ export function createFindPanel(container, options) {
     setError("");
     // Move on to the next match after the replaced text, in reading order (never the text just written).
     const replacedAt = order.get(match.pointer) ?? -1;
-    result = findMatches(editor.document, state.query, sessionOptions());
-    const nextOrder = new Map(collectSearchFields(editor.document, sessionOptions()).map((field, index) => [field.pointer, index]));
+    result = findMatches(editor.presentation, state.query, sessionOptions());
+    const nextOrder = new Map(collectSearchFields(editor.presentation, sessionOptions()).map((field, index) => [field.pointer, index]));
     let next = result.matches.findIndex((candidate) => {
       const position = nextOrder.get(candidate.pointer) ?? Infinity;
       return position > replacedAt || (position === replacedAt && candidate.start >= written);

package/dist/find-replace.d.ts

@@ -80,11 +80,11 @@ export interface TextEdit {
 /** The plain text of a string or a run array. */
 export declare function textOf(value: unknown): string;
 /** Every searchable text field of a document, in reading order. */
-export declare function collectSearchFields(document: unknown, options?: CollectOptions): SearchField[];
+export declare function collectSearchFields(presentation: unknown, options?: CollectOptions): SearchField[];
 /** Compile a search into a global RegExp; `{ error }` for an invalid regular expression, `{ empty: true }` for an empty query. */
 export declare function compileSearch(query: string, options?: SearchOptions): { regex?: RegExp; error?: string; empty?: boolean };
 /** Search a document's text. */
-export declare function findMatches(document: unknown, query: string, options?: SearchOptions): SearchResult;
+export declare function findMatches(presentation: unknown, query: string, options?: SearchOptions): SearchResult;
 /** Expand a replacement for one match (`$&`, `$1`, `$<name>`, `$$` in regex mode; literal otherwise). */
 export declare function expandReplacement(template: string, match: SearchMatch, fieldText: string, regex?: boolean): string;
 /**
@@ -93,7 +93,7 @@ export declare function expandReplacement(template: string, match: SearchMatch,
  */
 export declare function applyTextEdits<T extends string | unknown[]>(value: T, edits: TextEdit[]): T;
 /** The patches that replace the given matches. Throws `stale-match` when the text changed. */
-export declare function planReplace(document: unknown, matches: SearchMatch[], replacement: string, options?: { regex?: boolean }): ReplacePlan;
+export declare function planReplace(presentation: unknown, matches: SearchMatch[], replacement: string, options?: { regex?: boolean }): ReplacePlan;
 /** Replace every match as one undoable session change. Throws `invalid-search` for a bad regular expression. */
 export declare function replaceAll(editor: EditorSession, query: string, replacement: string, options?: SearchOptions): ReplaceResult;
 /** Replace one match as one undoable change. Throws `stale-match` when it is no longer in the document. */

package/dist/find-replace.js

@@ -81,6 +81,8 @@ function payloadFields(fields, state, base, payload, prefix = "") {
   else if (isObject(payload.quote)) {
     field(fields, state, at("quote", "text"), payload.quote.text, `${prefix}Quote`);
     field(fields, state, at("quote", "attribution"), payload.quote.attribution, `${prefix}Quote attribution`);
+    field(fields, state, at("quote", "role"), payload.quote.role, `${prefix}Quote role`);
+    if (isObject(payload.quote.photo)) field(fields, state, at("quote", "photo", "alt"), payload.quote.photo.alt, `${prefix}Quote photo alt text`, "alt");
     field(fields, state, at("quote", "source"), payload.quote.source, `${prefix}Quote source`);
   }
   const timeline = payload.timeline;
@@ -104,6 +106,7 @@ function payloadFields(fields, state, base, payload, prefix = "") {
       if (typeof value === "string") field(fields, state, at("chart", "data", "rows", String(r), String(c)), value, `${prefix}Chart row ${r + 1}, column ${c + 1}`, "chart");
     }));
   }
+  if (isObject(payload.chart)) field(fields, state, at("chart", "alt"), payload.chart.alt, `${prefix}Chart alt text`, "alt");
   const table = payload.table;
   if (isObject(table)) {
     if (Array.isArray(table.columns)) table.columns.forEach((cell, c) => (isObject(cell) && !("value" in cell) ? field(fields, state, at("table", "columns", String(c), "name"), cell.name, `${prefix}Table header ${c + 1}`, "table") : cellFields(fields, state, at("table", "columns", String(c)), cell, `${prefix}Table header ${c + 1}`)));
@@ -131,27 +134,27 @@ function furnitureFields(fields, state, base, design) {
  * the deck, `pointer` is the JSON pointer of the string or run array, and `runs` says it is a run array. Options:
  * `notes: false` leaves speaker notes out, `slideIndex` limits the list to one slide.
  */
-export function collectSearchFields(document, options = {}) {
+export function collectSearchFields(presentation, options = {}) {
   const fields = [];
-  if (!isObject(document)) return fields;
+  if (!isObject(presentation)) return fields;
   const only = Number.isInteger(options.slideIndex) ? options.slideIndex : undefined;
   if (only === undefined) {
     const deck = { slideIndex: -1 };
-    field(fields, deck, ["name"], document.name, "Presentation name", "deck");
-    field(fields, deck, ["description"], document.description, "Presentation description", "deck");
-    furnitureFields(fields, deck, [], document.design);
+    field(fields, deck, ["name"], presentation.name, "Presentation name", "deck");
+    field(fields, deck, ["description"], presentation.description, "Presentation description", "deck");
+    furnitureFields(fields, deck, [], presentation.design);
   }
   // RR-54: the text cells of a shared dataset belong to the deck. Its column names are left alone (`fields` and `mapping` address them).
-  if (only === undefined && isObject(document.datasets)) {
+  if (only === undefined && isObject(presentation.datasets)) {
     const deck = { slideIndex: -1 };
-    for (const [id, dataset] of Object.entries(document.datasets)) {
+    for (const [id, dataset] of Object.entries(presentation.datasets)) {
       if (!isObject(dataset) || !Array.isArray(dataset.rows)) continue;
       dataset.rows.forEach((row, r) => Array.isArray(row) && row.forEach((value, c) => {
         if (typeof value === "string") field(fields, deck, ["datasets", id, "rows", String(r), String(c)], value, `Dataset ${id}, row ${r + 1}, column ${c + 1}`, "dataset");
       }));
     }
   }
-  (Array.isArray(document.slides) ? document.slides : []).forEach((slide, slideIndex) => {
+  (Array.isArray(presentation.slides) ? presentation.slides : []).forEach((slide, slideIndex) => {
     if (only !== undefined && slideIndex !== only) return;
     if (!isObject(slide)) return;
     const state = { slideIndex };
@@ -203,12 +206,12 @@ function snippet(text, start, end) {
  * are offsets into the field's text. Options: those of `compileSearch`, plus `notes` and `slideIndex` of
  * `collectSearchFields`. Matches that are empty (a regular expression that matches nothing) are skipped.
  */
-export function findMatches(document, query, options = {}) {
+export function findMatches(presentation, query, options = {}) {
   const compiled = compileSearch(query, options);
   const result = { matches: [], fieldCount: 0, slideCount: 0, truncated: false, error: compiled.error };
   if (!compiled.regex) return result;
   const slides = new Set();
-  const fields = collectSearchFields(document, options);
+  const fields = collectSearchFields(presentation, options);
   outer: for (const item of fields) {
     compiled.regex.lastIndex = 0;
     let found;
@@ -320,8 +323,8 @@ export function applyTextEdits(value, edits) {
   return result;
 }
 
-function readField(document, match) {
-  const value = getValueAtPath(document, match.pointer);
+function readField(presentation, match) {
+  const value = getValueAtPath(presentation, match.pointer);
   return typeof value === "string" || Array.isArray(value) ? value : undefined;
 }
 
@@ -330,7 +333,7 @@ function readField(document, match) {
  * `{ patches, count, fieldCount }`; a replacement that leaves a field unchanged adds no patch. Throws `stale-match`
  * when a match no longer reads the same text in the document.
  */
-export function planReplace(document, matches, replacement, options = {}) {
+export function planReplace(presentation, matches, replacement, options = {}) {
   const byField = new Map();
   for (const match of matches) {
     if (!byField.has(match.pointer)) byField.set(match.pointer, []);
@@ -339,7 +342,7 @@ export function planReplace(document, matches, replacement, options = {}) {
   const patches = [];
   let count = 0;
   for (const [pointer, list] of byField) {
-    const value = readField(document, list[0]);
+    const value = readField(presentation, list[0]);
     const text = value === undefined ? undefined : textOf(value);
     const ordered = [...list].sort((a, b) => a.start - b.start);
     if (text === undefined || ordered.some((match) => text.slice(match.start, match.end) !== match.text)) {
@@ -353,8 +356,8 @@ export function planReplace(document, matches, replacement, options = {}) {
   return { patches, count, fieldCount: byField.size };
 }
 
-function search(document, query, options) {
-  const found = findMatches(document, query, options);
+function search(presentation, query, options) {
+  const found = findMatches(presentation, query, options);
   if (found.error) throw new OPFEditorError("invalid-search", found.error, {});
   return found;
 }
@@ -364,8 +367,8 @@ function search(document, query, options) {
  * the session's result (or null when nothing changed). One undo restores every replaced field.
  */
 export function replaceAll(editor, query, replacement, options = {}) {
-  const found = search(editor.document, query, options);
-  const plan = planReplace(editor.document, found.matches, String(replacement ?? ""), options);
+  const found = search(editor.presentation, query, options);
+  const plan = planReplace(editor.presentation, found.matches, String(replacement ?? ""), options);
   if (!plan.patches.length) return { count: 0, fieldCount: 0, change: null };
   const change = editor.applyPatch(plan.patches, { source: "find-replace", rejectInvalid: true, replaced: plan.count });
   return { count: plan.count, fieldCount: plan.fieldCount, change };
@@ -376,10 +379,10 @@ export function replaceAll(editor, query, replacement, options = {}) {
  * current document first: `stale-match` is thrown when the text changed underneath it.
  */
 export function replaceMatch(editor, match, query, replacement, options = {}) {
-  const found = search(editor.document, query, options);
+  const found = search(editor.presentation, query, options);
   const current = found.matches.find((candidate) => candidate.pointer === match.pointer && candidate.start === match.start && candidate.end === match.end && candidate.text === match.text);
   if (!current) throw new OPFEditorError("stale-match", "That match is no longer in the document. Search again.", { path: match.path });
-  const plan = planReplace(editor.document, [current], String(replacement ?? ""), options);
+  const plan = planReplace(editor.presentation, [current], String(replacement ?? ""), options);
   if (!plan.patches.length) return { count: 0, change: null };
   const change = editor.applyPatch(plan.patches, { source: "find-replace", rejectInvalid: true, replaced: 1 });
   return { count: 1, change };

package/dist/font-gate.js

@@ -1,75 +1,65 @@
-// Fonts before pixels. A document can need faces the browser font registry has not loaded yet: script faces for the
-// languages it draws (Japanese, Arabic, ...) and vendored preview faces for the font families it resolves (Intos for
-// Aptos, Open Sans, Barlow, ...). The renderer cannot draw such a document until those faces are loaded (a deck that
-// sets Aptos and contains Japanese fails with "Intos Display cannot display U+65E5"), so nothing may render or measure
-// a new document before `ensure` resolves. This module is the one gate every document-replacing path goes through.
+// Fonts before pixels. A document can need faces the browser has not loaded yet: script faces for the languages it draws
+// (Japanese, Arabic, ...) and vendored preview faces for the font families it resolves (Intos for Aptos, Open Sans, Barlow,
+// ...). The renderer cannot draw such a document until those faces are loaded (a deck that sets Aptos and contains Japanese
+// fails with "Intos Display cannot display U+65E5"), so nothing may render or measure a new document before `ensure`
+// resolves. The renderer's fonts handle (`loadFonts()` from `@openpresentation/opf-render/fonts-browser`) is the source of
+// truth: its `pending(presentation, renderOptions)` and `ensure(presentation, options)` know what is missing and load it. The
+// canvas and `exportDeck` take that handle as `fonts` and gate every document-replacing path through this module.
 
 /** Error code of a document whose required faces are still loading. */
 export const FONTS_PENDING = "fonts-pending";
 /** Error code of a document whose required faces could not be loaded. */
 export const FONTS_UNAVAILABLE = "fonts-unavailable";
 
-// A load that cannot finish (a face the registry never reports as loaded) stops after this many rounds.
-const MAX_ROUNDS = 4;
+const GATE = Symbol("opf-editor.fontGate");
 
 /**
- * Wrap a browser font registry (`loadBrowserFontRegistry` from `@openpresentation/opf-render/fonts-browser`).
- * Registries without the lazy loaders (renderer 0.10.0 and older) gate nothing and keep the fonts they have.
+ * The fonts a preview draws with: the handle's text measurement and nothing else. A full handle also lists `embeddedFonts`, which
+ * the renderer writes into every SVG it returns (an export needs that, so the SVG carries its faces); a preview inside a page
+ * that already loaded the faces would repeat megabytes of base64 in every canvas, thumbnail and panel preview. The measurement
+ * is read from the handle at each use, so faces it loads later still measure.
+ */
+export function previewFonts(fonts) {
+  if (!fonts || typeof fonts !== "object") return undefined;
+  return { get textMeasurement() { return fonts.textMeasurement; } };
+}
+
+/**
+ * The gate over a fonts handle: the two calls the canvas and the export need, with the editor's error contract.
+ *
+ * - `pending(presentation, renderOptions?)` lists the faces (vendored files and script packages) the document needs that are
+ *   not loaded. Synchronous; empty means the document can render now. Never throws: a document the renderer rejects for other
+ *   reasons reports nothing pending and fails with its own validation message when rendered. A handle without `pending`
+ *   (a plain `{ textMeasurement }`) gates nothing.
+ * - `ensure(presentation, { signal, renderOptions })` loads what is missing through the handle's `ensure`, then checks that
+ *   nothing is left. It rejects with a `fonts-unavailable` error (the handle's error is its `cause`), never retries by itself,
+ *   and rethrows an abort as it is.
  *
- * - `pending(document, renderOptions?)` lists the faces (script packages and vendored files) the document needs that are
- *   not loaded. Synchronous; empty means the document can render now. Never throws: a document the renderer rejects for
- *   other reasons reports nothing pending and fails with its own validation message when rendered. Script faces and
- *   vendored faces are asked separately, so one that cannot be answered does not hide the other.
- * - `ensure(document, { signal, renderOptions })` loads vendored faces first (script fallback depends on them), then script faces,
- *   and repeats until nothing is pending. It makes a bounded number of rounds and rejects with a `fonts-unavailable`
- *   error (the registry's error is its `cause`); it never retries by itself, a later call is a new attempt.
- * - `run(document, handlers)` is `whenFontsReady` on this gate.
- * - `renderOptions` (per call, or `createFontGate(registry, { renderOptions })` as an object or a getter) are the options the
- *   host renders with (`catalogs`, ...). They are passed to the registry, so a layout or font scheme that only the host's
- *   catalogs know resolves the same way there (renderer 0.11.5 and newer; older renderers ignore them).
+ * `renderOptions` are the options the host renders with (`catalogs`, ...); they reach the handle, so a layout or font scheme
+ * that only the host's catalogs know resolves the same way there. Hand a gate back unchanged.
  */
-export function createFontGate(registry, gateOptions = {}) {
-  // FF-41: the render options (`catalogs` above all) the document resolves with. The registry resolves a document the way the
-  // host renders it only when it gets the same options, so every call passes them: the gate's defaults (an object, or a
-  // function called each time, for options that change like `canvas.setRenderOptions`) under the call's own.
-  const defaults = () => (typeof gateOptions.renderOptions === "function" ? gateOptions.renderOptions() : gateOptions.renderOptions) ?? {};
-  const optionsFor = (renderOptions) => ({ ...defaults(), ...renderOptions });
-  // Each source answers on its own: a document one loader cannot resolve (an unresolvable layout throws in the renderer's
-  // lazy font loader) must not hide what the other still reports pending.
-  const sources = (document, renderOptions) => {
-    const options = optionsFor(renderOptions);
-    let scripts = [], lazy = [];
-    try { scripts = registry?.pendingScripts?.(document, options) ?? []; } catch { /* the renderer reports the document itself when it renders */ }
-    try { lazy = (registry?.pendingLazyFonts?.(document, options) ?? []).map((face) => face?.file ?? String(face)); } catch { /* likewise */ }
-    return { lazy, scripts };
-  };
-  const pending = (document, renderOptions) => {
-    const { lazy, scripts } = sources(document, renderOptions);
-    return [...lazy, ...scripts];
+export function fontGate(fonts) {
+  if (!fonts || typeof fonts !== "object") return undefined;
+  if (fonts[GATE]) return fonts;
+  const pending = (presentation, renderOptions) => {
+    try { return fonts.pending?.(presentation, renderOptions) ?? []; } catch { return []; /* the renderer reports the document itself when it renders */ }
   };
   const gate = {
+    [GATE]: true,
     pending,
-    async ensure(document, options = {}) {
-      const { signal, renderOptions } = options;
-      const call = { ...optionsFor(renderOptions), signal };
+    async ensure(presentation, { signal, renderOptions } = {}) {
+      if (!pending(presentation, renderOptions).length) return;
       try {
-        for (let round = 0; round < MAX_ROUNDS; round++) {
-          const { lazy, scripts } = sources(document, renderOptions);
-          if (!lazy.length && !scripts.length) break;
-          signal?.throwIfAborted?.();
-          // Vendored faces first (script fallback depends on them). A source with nothing pending is not asked to load.
-          if (lazy.length) await registry.ensureLazyFonts?.(document, call);
-          if (scripts.length) await registry.ensureScripts?.(document, call);
-        }
+        signal?.throwIfAborted?.();
+        await fonts.ensure(presentation, { ...renderOptions, signal });
       } catch (cause) {
         if (signal?.aborted) throw cause;
         throw fontsUnavailable(cause?.message ?? String(cause), cause);
       }
-      const left = pending(document, renderOptions);
+      const left = pending(presentation, renderOptions);
       if (left.length) throw fontsUnavailable(`${left.join(", ")} did not finish loading.`);
     },
   };
-  gate.run = (document, handlers) => whenFontsReady(gate, document, handlers);
   return gate;
 }
 
@@ -88,15 +78,16 @@ export function fontsPendingError(pending) {
 }
 
 /**
- * Ensure fonts for a document, then run `ready`: the one "ensure fonts, then render" helper.
+ * Ensure fonts for a presentation, then run `ready`: the one "ensure fonts, then render" helper.
  * With nothing pending, `ready` runs synchronously, so documents in already-loaded fonts render at once. Otherwise
  * `loading(pending)` runs, the faces load and `ready` runs after them. `isCurrent()` is checked after the wait, so a
  * result for a superseded document is dropped. A load failure, and an exception thrown by `ready`, go to `failed(error)`
- * (they are rethrown when there is no `failed`). `renderOptions` are passed to the gate. `gate` is any object with
- * `pending(document, renderOptions)` and `ensure(document, { renderOptions })`;
- * without one the document is treated as ready. Resolves once `ready` or `failed` has run.
+ * (they are rethrown when there is no `failed`). `renderOptions` reach the fonts handle. `fonts` is the renderer's fonts
+ * handle (anything with `pending(presentation, renderOptions)` and `ensure(presentation, options)`); without one the
+ * document is treated as ready. Resolves once `ready` or `failed` has run.
  */
-export function whenFontsReady(gate, document, { isCurrent = () => true, loading, ready, failed, renderOptions } = {}) {
+export function whenFontsReady(fonts, presentation, { isCurrent = () => true, loading, ready, failed, renderOptions } = {}) {
+  const gate = fontGate(fonts);
   const finish = () => {
     try {
       ready?.();
@@ -105,13 +96,13 @@ export function whenFontsReady(gate, document, { isCurrent = () => true, loading
       failed(error);
     }
   };
-  const left = gate?.pending?.(document, renderOptions) ?? [];
+  const left = gate?.pending(presentation, renderOptions) ?? [];
   if (!left.length) {
     finish();
     return Promise.resolve();
   }
   loading?.(left);
-  return Promise.resolve(gate.ensure(document, { renderOptions })).then(
+  return Promise.resolve(gate.ensure(presentation, { renderOptions })).then(
     () => {
       if (isCurrent()) finish();
     },