@openpresentation/opf-editor 0.12.1 → 0.14.2

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

package/dist/galleries.js

@@ -119,28 +119,15 @@ export async function loadOpfGallery(input, options = {}) {
 }
 const FONT_SCHEME_ENUMS = {
   type: ["sans-serif", "serif", "monospace"],
-  app: ["PowerPoint", "Google Slides"],
-  languageFamily: ["latin", "ea", "cs"],
+  app: ["powerpoint", "google-slides"],
+  languageFamily: ["latin", "ea", "cs", "eastAsian", "complexScript"],
 };
-// A Font role object ({ family, weight?, style?, letterSpacing? }), or undefined.
+// A font role is a family name (a non-empty string), or undefined.
 function fontRole(value) {
-  if (typeof value === "string") return value ? { family: value } : undefined;
-  if (!value || typeof value !== "object" || typeof value.family !== "string")
-    return undefined;
-  const role = { family: value.family };
-  if (typeof value.weight === "number" && Number.isFinite(value.weight))
-    role.weight = value.weight;
-  if (value.style === "normal" || value.style === "italic")
-    role.style = value.style;
-  if (
-    typeof value.letterSpacing === "number" &&
-    Number.isFinite(value.letterSpacing)
-  )
-    role.letterSpacing = value.letterSpacing;
-  return role;
+  return typeof value === "string" && value ? value : undefined;
 }
 // Keep every font-scheme role that the catalog record schema defines: the OOXML
-// pair and `code`. Gallery `heading`/`body` (string or Font object) map onto
+// pair and `code`. Gallery `heading`/`body` (family names) map onto
 // major/minor only, never role objects, so a later inline design.fontScheme
 // major/minor override still wins (resolveFontFamilies checks roles before the
 // pair). `accent` is not part of the record schema and is dropped.
@@ -152,11 +139,11 @@ function fontSchemeRecord(source, id) {
     major:
       typeof source.major === "string"
         ? source.major
-        : fontRole(source.heading)?.family,
+        : fontRole(source.heading),
     minor:
       typeof source.minor === "string"
         ? source.minor
-        : fontRole(source.body)?.family,
+        : fontRole(source.body),
   };
   for (const [field, values] of Object.entries(FONT_SCHEME_ENUMS))
     if (values.includes(source[field])) record[field] = source[field];
@@ -164,7 +151,7 @@ function fontSchemeRecord(source, id) {
   if (code) record.code = code;
   return record;
 }
-function attachDefinition(document, descriptor) {
+function attachDefinition(presentation, descriptor) {
   const source = descriptor.metadata?.source,
     category = descriptor.category ?? descriptor.metadata?.category;
   if (!source) return;
@@ -179,33 +166,30 @@ function attachDefinition(document, descriptor) {
   if (!id) return;
   if (
     catalogs[kind]?.some((record) => record.id === id) ||
-    document.catalogs?.[kind]?.records?.some((record) => record.id === id)
+    presentation.catalogs?.[kind]?.records?.some((record) => record.id === id)
   )
     return;
   let record;
   if (kind === "layouts") {
-    const n = Math.min(
-      12,
-      Number(String(source.contentMultiple ?? "").replace("x", "")) || 1,
-    );
-    const type =
-      { Image: "picture", Chart: "chart", List: "list" }[source.contentType] ??
-      "text";
+    // A gallery layout item is a layout record: its placeholders, design hints and composition are the
+    // record's own. Only an item that declares no placeholders gets the default title and text.
+    const placeholders = Array.isArray(source.placeholders)
+      ? source.placeholders
+          .filter((placeholder) => typeof placeholder?.type === "string")
+          .map((placeholder) => ({ type: placeholder.type }))
+      : [{ type: "title" }, { type: "text" }];
+    const plain = (value) =>
+      value && typeof value === "object" && !Array.isArray(value)
+        ? structuredClone(value)
+        : undefined;
     record = {
       $schema: "https://openpresentation.org/schema/opf-layout/v1",
       id,
       name: source.label ?? source.name ?? id,
-      placeholders: [
-        { type: "title" },
-        ...Array.from({ length: n }, () => ({ type })),
-      ],
-      ...(n > 1
-        ? {
-            composition: {
-              mode: n <= 3 ? "row" : "grid",
-              ...(n > 3 ? { columns: 2 } : {}),
-            },
-          }
+      ...(plain(source.design) ? { design: plain(source.design) } : {}),
+      placeholders,
+      ...(plain(source.composition)
+        ? { composition: plain(source.composition) }
         : {}),
     };
   } else if (kind === "fontSchemes") record = fontSchemeRecord(source, id);
@@ -215,10 +199,10 @@ function attachDefinition(document, descriptor) {
       $schema: `https://openpresentation.org/schema/opf-${kind === "themes" ? "theme" : "color-scheme"}/v1`,
     };
   }
-  document.catalogs ??= {};
-  document.catalogs[kind] ??= { records: [] };
-  document.catalogs[kind].records ??= [];
-  document.catalogs[kind].records.push(record);
+  presentation.catalogs ??= {};
+  presentation.catalogs[kind] ??= { records: [] };
+  presentation.catalogs[kind].records ??= [];
+  presentation.catalogs[kind].records.push(record);
 }
 export async function loadOpfGalleryItem(item, { gallery, ...options } = {}) {
   const base = gallery ?? options.base;
@@ -234,10 +218,10 @@ export async function loadOpfGalleryItem(item, { gallery, ...options } = {}) {
     );
     if (!descriptor) throw new Error("This gallery item was not found.");
   }
-  const document = structuredClone(unwrapOpf(descriptor));
-  if (!document?.slides)
+  const presentation = structuredClone(unwrapOpf(descriptor));
+  if (!presentation?.slides)
     throw new Error("This gallery item does not include a presentation.");
-  attachDefinition(document, descriptor);
+  attachDefinition(presentation, descriptor);
   // PPTX.gallery's older descriptors omit inline layout records. Resolve only named
   // layout references from its known, same-origin registry; no arbitrary dependency crawl.
   if (
@@ -246,13 +230,13 @@ export async function loadOpfGalleryItem(item, { gallery, ...options } = {}) {
   ) {
     const missing = [
       ...new Set(
-        document.slides
+        presentation.slides
           .map((slide) => slide.layout)
           .filter(
             (id) =>
               typeof id === "string" &&
               !catalogs.layouts.some((record) => record.id === id) &&
-              !document.catalogs?.layouts?.records?.some(
+              !presentation.catalogs?.layouts?.records?.some(
                 (record) => record.id === id,
               ),
           ),
@@ -269,9 +253,9 @@ export async function loadOpfGalleryItem(item, { gallery, ...options } = {}) {
         `/registry/layouts/${id}.json`,
         { ...options, base: url, origin: new URL(url).origin },
       );
-      attachDefinition(document, dependency);
+      attachDefinition(presentation, dependency);
     }
   }
-  assertOpf(document);
-  return document;
+  assertOpf(presentation);
+  return presentation;
 }

package/dist/grid-model.d.ts

@@ -34,18 +34,18 @@ export interface PreparedGridChange {
   path: string;
   /** The id of the shared dataset the edit changes, when the chart or table shows one (RR-54). */
   dataset?: string;
-  document: unknown;
+  presentation: unknown;
   patches: JsonPatchOperation[];
   changed: boolean;
   [key: string]: unknown;
 }
-export interface GridChange extends Omit<EditorChange, "document" | "patches"> {
+export interface GridChange extends Omit<EditorChange, "presentation" | "patches"> {
   action: string;
   kind: "chart" | "table";
   path: string;
   /** The id of the shared dataset the edit changed, when the chart or table shows one. */
   dataset?: string;
-  document: unknown;
+  presentation: unknown;
   patches: JsonPatchOperation[];
   changed: boolean;
   [key: string]: unknown;
@@ -136,11 +136,11 @@ export declare function chartColumnRoles(columnCount: number, chartType?: string
 /** The text a cell shows. */
 export declare function cellText(raw: unknown, kind: "chart" | "table", decimal?: "." | ","): string;
 /**
- * Find the data a path points at (`…chart`, `…chart.data`, `…table`). Throws `grid-target-not-found`, `table-not-found`, `chart-data-source` or
+ * Find the data a path points at (`…chart`, `…chart.data`, `…table`). Throws `grid-target-not-found`, `table-not-found` or
  * `dataset-unavailable`. For a chart or table that shows a shared dataset, `data` is the dataset, `dataParts` is `["datasets", id]` and `dataset`
  * says which columns `fields` selects (`indices`, into the dataset's own columns) and where the reference is (`refParts`).
  */
-export declare function locateGridData(document: unknown, path: string | string[]): {
+export declare function locateGridData(presentation: unknown, path: string | string[]): {
   kind: "chart" | "table";
   parts: string[];
   dataParts: string[];
@@ -150,48 +150,46 @@ export declare function locateGridData(document: unknown, path: string | string[
   dataset?: { id: string; fields?: string[]; indices: number[]; refParts: string[]; ref: Record<string, unknown> };
 };
 /** The chart or table a selection path belongs to, or undefined. */
-export declare function resolveDataGridTarget(document: unknown, selectedPath: string): DataGridTarget | undefined;
+export declare function resolveDataGridTarget(presentation: unknown, selectedPath: string): DataGridTarget | undefined;
 /** The grid view of a chart or table: lines of cells with spans, covered positions, text, warnings. */
-export declare function describeDataGrid(document: unknown, path: string, options?: GridOptions): DataGridDescription;
+export declare function describeDataGrid(presentation: unknown, path: string, options?: GridOptions): DataGridDescription;
 /** The smallest guarded patch from `before` to `after` at `parts`. */
 export declare function gridPatches(parts: string[], before: unknown, after: unknown): JsonPatchOperation[];
 /** The problems the edits would have, without applying them or validating the document. */
-export declare function gridCellIssues(document: unknown, path: string, edits: GridCellEdit[], options?: GridOptions): GridIssue[];
+export declare function gridCellIssues(presentation: unknown, path: string, edits: GridCellEdit[], options?: GridOptions): GridIssue[];
 /** The text of a range (`{ from, to }` addresses; the whole grid when omitted) as TSV, or another delimiter. */
-export declare function gridRangeText(document: unknown, path: string, range?: { from: GridAddress; to: GridAddress }, options?: GridOptions): string;
+export declare function gridRangeText(presentation: unknown, path: string, range?: { from: GridAddress; to: GridAddress }, options?: GridOptions): string;
 
-export declare function prepareGridCells(document: unknown, path: string, edits: GridCellEdit[], options?: GridOptions): PreparedGridChange;
-export declare function preparePaste(document: unknown, path: string, anchor: GridAddress, source: string | string[][], options?: GridOptions): PreparedGridChange;
-export declare function prepareInsertRows(document: unknown, path: string, at: number, count?: number, options?: GridOptions): PreparedGridChange;
-export declare function prepareDeleteRows(document: unknown, path: string, indices: number[], options?: GridOptions): PreparedGridChange;
-export declare function prepareMoveRows(document: unknown, path: string, from: number, to: number, count?: number, options?: GridOptions): PreparedGridChange;
-export declare function prepareInsertColumns(document: unknown, path: string, at: number, count?: number, options?: GridOptions): PreparedGridChange;
-export declare function prepareDeleteColumns(document: unknown, path: string, indices: number[], options?: GridOptions): PreparedGridChange;
-export declare function prepareMoveColumns(document: unknown, path: string, from: number, to: number, count?: number, options?: GridOptions): PreparedGridChange;
-export declare function prepareSortRows(document: unknown, path: string, column: number, options?: GridSortOptions): PreparedGridChange;
-export declare function prepareSetHeader(document: unknown, path: string, enabled: boolean, options?: { use?: "first-row" | "new" }): PreparedGridChange;
-export declare function prepareTranspose(document: unknown, path: string): PreparedGridChange;
+export declare function prepareGridCells(presentation: unknown, path: string, edits: GridCellEdit[], options?: GridOptions): PreparedGridChange;
+export declare function preparePaste(presentation: unknown, path: string, anchor: GridAddress, source: string | string[][], options?: GridOptions): PreparedGridChange;
+export declare function prepareInsertRows(presentation: unknown, path: string, at: number, count?: number, options?: GridOptions): PreparedGridChange;
+export declare function prepareDeleteRows(presentation: unknown, path: string, indices: number[], options?: GridOptions): PreparedGridChange;
+export declare function prepareMoveRows(presentation: unknown, path: string, from: number, to: number, count?: number, options?: GridOptions): PreparedGridChange;
+export declare function prepareInsertColumns(presentation: unknown, path: string, at: number, count?: number, options?: GridOptions): PreparedGridChange;
+export declare function prepareDeleteColumns(presentation: unknown, path: string, indices: number[], options?: GridOptions): PreparedGridChange;
+export declare function prepareMoveColumns(presentation: unknown, path: string, from: number, to: number, count?: number, options?: GridOptions): PreparedGridChange;
+export declare function prepareSortRows(presentation: unknown, path: string, column: number, options?: GridSortOptions): PreparedGridChange;
+export declare function prepareSetHeader(presentation: unknown, path: string, enabled: boolean, options?: { use?: "first-row" | "new" }): PreparedGridChange;
+export declare function prepareTranspose(presentation: unknown, path: string): PreparedGridChange;
 /** Why `format` is not a valid number format ("#,##0", "0.0%", "$#,##0.00"), or undefined when it is valid or empty (empty clears the format). */
 export declare function columnFormatError(format: unknown): string | undefined;
-/** Whether the installed core has the RR-54 chart and table data contract (number formats, datasets, strict chart numbers). An older core edits documents that use none of it. */
-export declare const supportsChartTableData: boolean;
 /**
  * Set or clear (`null` or "") the number format of column `column` (its header cell). A string header becomes `{ name, format }` and returns to a string
  * when the format is cleared. Throws `number-format-invalid` with the reason, or `grid-no-header` for a table without a header row.
  */
-export declare function prepareGridColumnFormat(document: unknown, path: string, column: number, format: string | null | undefined, options?: GridOptions): PreparedGridChange;
+export declare function prepareGridColumnFormat(presentation: unknown, path: string, column: number, format: string | null | undefined, options?: GridOptions): PreparedGridChange;
 /** The columns a chart plots and how they got that role (the chart's `mapping`, or core's positional default). */
-export declare function describeChartMapping(document: unknown, path: string): ChartMappingDescription;
+export declare function describeChartMapping(presentation: unknown, path: string): ChartMappingDescription;
 /**
  * Set a chart's category, X and series columns by name; what `wanted` leaves out keeps its current value. A field that equals the default is not
  * written, and `chart.mapping` is removed when nothing is left. One patch. Throws `chart-mapping-unknown-column`, `chart-mapping-x-unsupported`,
  * `chart-mapping-conflict` or `chart-mapping-no-series`.
  */
-export declare function prepareChartMapping(document: unknown, path: string, wanted?: ChartMappingColumns): PreparedGridChange;
+export declare function prepareChartMapping(presentation: unknown, path: string, wanted?: ChartMappingColumns): PreparedGridChange;
 /** Replace the chart's or table's dataset reference with its own inline copy of the data. The dataset stays for the other items. One patch. */
-export declare function prepareDetachDataset(document: unknown, path: string): PreparedGridChange;
+export declare function prepareDetachDataset(presentation: unknown, path: string): PreparedGridChange;
 /** The charts and tables that use dataset `id`, in document order. */
-export declare function datasetUsage(document: unknown, id: string): Array<{ kind: "chart" | "table"; path: string; parts: string[] }>;
+export declare function datasetUsage(presentation: unknown, id: string): Array<{ kind: "chart" | "table"; path: string; parts: string[] }>;
 
 export declare function setGridCells(editor: EditorSession, path: string, edits: GridCellEdit[], options?: GridOptions): GridChange;
 export declare function pasteGridText(editor: EditorSession, path: string, anchor: GridAddress, source: string | string[][], options?: GridOptions): GridChange;