@openpresentation/opf-editor 0.12.1 → 0.14.2

package/dist/image-cropper.js

@@ -121,7 +121,7 @@ export function createImageCropper(root, overlay, options) {
 
   function placePill() {
     const target = selected && !session ? frameImage(selected) : null;
-    if (!target || !editor || describeImage(editor.document, selected).error) { pill.hidden = true; return; }
+    if (!target || !editor || describeImage(editor.presentation, selected).error) { pill.hidden = true; return; }
     const box = target.getBoundingClientRect();
     const base = root.getBoundingClientRect();
     if (!box.width || !box.height) { pill.hidden = true; return; }
@@ -135,7 +135,7 @@ export function createImageCropper(root, overlay, options) {
   async function open(path, openOptions = {}) {
     if (destroyed || session) return false;
     if (options.beforeOpen && !options.beforeOpen()) return false;
-    const image = describeImage(editor.document, path);
+    const image = describeImage(editor.presentation, path);
     if (image.error) {
       options.report?.(new Error(image.error));
       return false;
@@ -483,7 +483,7 @@ export function createImageCropper(root, overlay, options) {
     aspectSelect.querySelector('option[value="frame"]').disabled = !frame;
     s.rect = fullRect(s.loaded.width, s.loaded.height);
     layout();
-    restoreButton.hidden = !prepareRestore(editor.document, path);
+    restoreButton.hidden = !prepareRestore(editor.presentation, path);
     if (s.tool === "focus") {
       s.tool = "crop";
       setTool("focus");

package/dist/index.d.ts

@@ -1,8 +1,17 @@
 import type { PaginationOptions, PaginationResult } from "@openpresentation/opf/pagination";
 import type { Composition, ComposeSlideOptions, SlideComposition } from "@openpresentation/opf/composition";
-/** Reported when a font-scheme id matches no inline or bundled record; the default font scheme (`aptos`) is the base. */
-export interface FontSchemeDiagnostic { code: "unresolved-font-scheme"; path: string; message: string; id: string; fallback: string }
-export interface EditorDiagnosticOptions { onDiagnostic?: (diagnostic: FontSchemeDiagnostic) => void }
+import type { Fonts, PresentationStats, SlideContextDiagnostic, StatsOptions, ValidationReport } from "@openpresentation/opf";
+/**
+ * What the editor adds to the options of `composeSlide` and `paginateSlide`: `fonts` is the renderer's fonts handle (`loadFonts()`), whose
+ * `textMeasurement` measures the text; `catalogs` are host catalog records; `onDiagnostic` hears every `unresolved-font-scheme`,
+ * `unresolved-layout`, `unresolved-theme` and `unresolved-color-scheme` diagnostic of core's `resolveSlideContext`. Any other option overrides
+ * the resolved one.
+ */
+export interface EditorDiagnosticOptions {
+  fonts?: Fonts;
+  catalogs?: Record<string, readonly unknown[]>;
+  onDiagnostic?: (diagnostic: SlideContextDiagnostic) => void;
+}
 export declare const packageName = "@openpresentation/opf-editor";
 
 export declare const releaseLane: Readonly<{
@@ -29,16 +38,9 @@ export type JsonPatchOperation =
   | { op: "copy"; from: string; path: string }
   | { op: "test"; path: string; value: unknown };
 
-export interface OPFValidationSummary {
-  valid: boolean;
-  errors: unknown[];
-  warnings: unknown[];
-  result: unknown;
-}
-
 export interface EditorSnapshot {
-  document: unknown;
-  validation: OPFValidationSummary;
+  presentation: unknown;
+  validation: ValidationReport;
   canUndo: boolean;
   canRedo: boolean;
   undoDepth: number;
@@ -46,11 +48,11 @@ export interface EditorSnapshot {
 }
 
 export interface EditorChange {
-  document: unknown;
+  presentation: unknown;
   patches: JsonPatchOperation[];
   inversePatches?: JsonPatchOperation[];
   redoPatches?: JsonPatchOperation[];
-  validation: OPFValidationSummary;
+  validation: ValidationReport;
 }
 
 export interface EditorEvent {
@@ -58,7 +60,7 @@ export interface EditorEvent {
   patches: JsonPatchOperation[];
   inversePatches?: JsonPatchOperation[];
   redoPatches?: JsonPatchOperation[];
-  validation: OPFValidationSummary;
+  validation: ValidationReport;
   meta?: Record<string, unknown>;
   snapshot: EditorSnapshot;
 }
@@ -70,8 +72,8 @@ export interface EditorSession {
   paginateSlide(slideIndex: number, options?: PaginationOptions & EditorDiagnosticOptions, meta?: Record<string, unknown>): { change: EditorChange | null; pagination: PaginationResult };
   composeSlide(slideIndex: number, options?: ComposeSlideOptions & EditorDiagnosticOptions): SlideComposition;
   setComposition(slideIndex: number, composition: Composition, meta?: Record<string, unknown>): EditorChange;
-  readonly document: unknown;
-  readonly validation: OPFValidationSummary;
+  readonly presentation: unknown;
+  readonly validation: ValidationReport;
   readonly canUndo: boolean;
   readonly canRedo: boolean;
   snapshot(): EditorSnapshot;
@@ -84,13 +86,13 @@ export interface EditorSession {
   /** The undo and redo stacks as plain data (oldest entry first), for hosts that persist work. */
   exportHistory(): EditorHistory;
   /** Replace the document and, optionally, the history in one step (one `restore` event). A history that does not replay against the document throws `invalid-history` before anything changes. */
-  restoreState(state: { document: unknown; undo?: EditorHistoryEntry[]; redo?: EditorHistoryEntry[] }, meta?: Record<string, unknown>): EditorChange;
+  restoreState(state: { presentation: unknown; undo?: EditorHistoryEntry[]; redo?: EditorHistoryEntry[] }, meta?: Record<string, unknown>): EditorChange;
   undo(meta?: Record<string, unknown>): EditorChange | null;
   redo(meta?: Record<string, unknown>): EditorChange | null;
 }
 
 export interface CreateEditorSessionOptions {
-  validate?: (document: unknown) => unknown;
+  /** Refuse every edit whose result has an error finding (the default per edit is `meta.rejectInvalid`). */
   rejectInvalid?: boolean;
 }
 
@@ -160,20 +162,18 @@ export declare function opfPathToJsonPointer(path: string | string[]): string;
 
 export declare function jsonPointerToOpfPath(pointer: string): string;
 
-export declare function getValueAtPath(document: unknown, path: string | string[], fallback?: unknown): unknown;
-
-export declare function hasValueAtPath(document: unknown, path: string | string[]): boolean;
+export declare function getValueAtPath(presentation: unknown, path: string | string[], fallback?: unknown): unknown;
 
-export declare function createValuePatch(document: unknown, path: string | string[], value: unknown): JsonPatchOperation[];
+export declare function hasValueAtPath(presentation: unknown, path: string | string[]): boolean;
 
-export declare function applyJsonPatch(document: unknown, operations: JsonPatchOperation[]): unknown;
+export declare function createValuePatch(presentation: unknown, path: string | string[], value: unknown): JsonPatchOperation[];
 
-export declare function invertJsonPatch(document: unknown, operations: JsonPatchOperation[]): JsonPatchOperation[];
+export declare function applyJsonPatch(presentation: unknown, operations: JsonPatchOperation[]): unknown;
 
-export declare function validateOpfDocument(document: unknown, validator?: (document: unknown) => unknown): OPFValidationSummary;
+export declare function invertJsonPatch(presentation: unknown, operations: JsonPatchOperation[]): JsonPatchOperation[];
 
-/** Font families the slide resolves to (slide, deck, theme, then the shared default scheme). */
-export declare function resolveSlideFonts(document: unknown, slideIndex?: number, options?: EditorDiagnosticOptions): { heading?: string; body?: string; code?: string; [role: string]: string | undefined };
+/** Core's `stats` of the session's document: neutral facts (counts, words, notes coverage, images and alt text, speaking time), never severities. Reads the JSON only. */
+export declare function deckStats(editor: EditorSession, options?: StatsOptions): PresentationStats;
 
 export declare function createEditorSession(input: unknown, options?: CreateEditorSessionOptions): EditorSession;
 

package/dist/index.js

@@ -1,38 +1,20 @@
 import { paginateSlide } from "@openpresentation/opf/pagination";
-import { PatchError, applyPatch as applyCorePatch, applyPatchWithInverse, formatPointer, invertPatch, jsonEqual, parsePointer, readPointer } from "@openpresentation/opf/patch";
+import { OPFPatchError, applyPatch as applyCorePatch, applyPatchWithInverse, formatPointer, invertPatch, jsonEqual, parsePointer, readPointer } from "@openpresentation/opf/patch";
 import { collectReservedPresentationIds } from "./presentation-ids.js";
-import { DEFAULT_FONT_SCHEME, resolveFontSchemeReference } from "./font-defaults.js";
-import { composeSlide, resolveCanvasDimensions, resolveFontFamilies } from "@openpresentation/opf/composition";
-import {
-  catalogKinds,
-  catalogs as bundledCatalogs,
-  validatePresentation
-} from "@openpresentation/opf";
-
-function resolveCompositionOptions(document, slideIndex, { onDiagnostic, ...options } = {}) {
-      const slide = document.slides?.[slideIndex];
-      if (!Number.isInteger(slideIndex) || !slide) throw new OPFEditorError("slide-index-out-of-range", "Slide index is out of range.");
-      const inline = document.catalogs?.layouts?.records ?? [];
-      const layout = options.layout ?? inline.find(record => record.id === slide.layout)
-        ?? bundledCatalogs.layouts.find(record => record.id === slide.layout);
-      const themeReference = slide.design?.theme ?? document.design?.theme ?? "minimal";
-      const themeId = typeof themeReference === "string" ? themeReference : themeReference.id;
-      const theme = document.catalogs?.themes?.records?.find(record => record.id === themeId)
-        ?? bundledCatalogs.themes.find(record => record.id === themeId);
-      const reference = slide.design?.fontScheme ?? document.design?.fontScheme ?? theme?.fontScheme ?? DEFAULT_FONT_SCHEME;
-      const fontPath = slide.design?.fontScheme !== undefined ? `slides.${slideIndex}.design.fontScheme` : document.design?.fontScheme !== undefined ? "design.fontScheme" : slide.design?.theme !== undefined ? `slides.${slideIndex}.design.theme` : "design.theme";
-      const { scheme: fontScheme, diagnostic } = resolveFontSchemeReference(reference, id => document.catalogs?.fontSchemes?.records?.find(record=>record.id===id) ?? bundledCatalogs.fontSchemes.find(record=>record.id===id), fontPath);
-      if (diagnostic) onDiagnostic?.(diagnostic);
-      return { ...resolveCanvasDimensions(slide.design?.dimensions ?? document.design?.dimensions ?? theme?.dimensions), fonts:resolveFontFamilies(fontScheme), contentAlignment:slide.design?.contentAlignment??document.design?.contentAlignment, titleAlignment:slide.design?.titleAlignment??document.design?.titleAlignment, contentBox:slide.design?.contentBox??document.design?.contentBox, presentation:document, ...options, layout, slideIndex };
-}
-
-/**
- * The font families a slide resolves to (`heading`, `body`, `code`), by the same slide, deck,
- * theme, default order that composition, pagination and export use. Hosts read this after a
- * font-scheme or theme switch to show the fonts the preview now uses.
- */
-export function resolveSlideFonts(document, slideIndex = 0, options = {}) {
-  return resolveCompositionOptions(document, slideIndex, options).fonts;
+import { composeSlide } from "@openpresentation/opf/composition";
+import { catalogKinds, catalogs as bundledCatalogs, resolveSlideContext, stats } from "@openpresentation/opf";
+import { checkFormat, errorFindings } from "./checks.js";
+
+// The options `composeSlide` and `paginateSlide` take for one slide of the open deck. Core's `resolveSlideContext` resolves the
+// slide's canvas, layout, theme, colour scheme and font families the one way every engine does (slide design, deck design,
+// theme, default), so the editor measures and composes what the renderer draws and the exporter writes. `options.fonts` is the
+// renderer's fonts handle (its `textMeasurement` measures); `options.onDiagnostic` hears each `unresolved-*` diagnostic;
+// any other option overrides the resolved one (`layout`, ...).
+function slideContext(presentation, slideIndex, { fonts, catalogs, onDiagnostic, ...overrides } = {}) {
+  if (!Number.isInteger(slideIndex) || !presentation.slides?.[slideIndex]) throw new OPFEditorError("slide-index-out-of-range", "Slide index is out of range.");
+  const { options, diagnostics } = resolveSlideContext(presentation, slideIndex, { fonts, catalogs });
+  for (const diagnostic of diagnostics) onDiagnostic?.(diagnostic);
+  return { ...options, ...overrides };
 }
 
 export const packageName = "@openpresentation/opf-editor";
@@ -85,20 +67,20 @@ export function jsonPointerToOpfPath(pointer) {
   return parseJsonPointer(pointer).join(".");
 }
 
-export function getValueAtPath(document, path, fallback) {
-  const found = readPointer(document, splitOpfPath(path));
+export function getValueAtPath(presentation, path, fallback) {
+  const found = readPointer(presentation, splitOpfPath(path));
   return found.found ? found.value : fallback;
 }
 
-export function hasValueAtPath(document, path) {
-  return readPointer(document, splitOpfPath(path)).found;
+export function hasValueAtPath(presentation, path) {
+  return readPointer(presentation, splitOpfPath(path)).found;
 }
 
-export function createValuePatch(document, path, value) {
+export function createValuePatch(presentation, path, value) {
   const pointer = normalizePatchPath(path);
   return [
     {
-      op: hasValueAtPath(document, pointer) ? "replace" : "add",
+      op: hasValueAtPath(presentation, pointer) ? "replace" : "add",
       path: pointer,
       value: clone(value)
     }
@@ -108,40 +90,40 @@ export function createValuePatch(document, path, value) {
 // Patch semantics (RFC 6902, pointers, inverse patches) live in core's
 // "@openpresentation/opf/patch"; the editor adds its path spellings (dotted OPF
 // paths), its error type and its clone policy on top.
-export function applyJsonPatch(document, operations) {
+export function applyJsonPatch(presentation, operations) {
   assertPatchOperations(operations);
   const patch = operations.map(normalizeOperation);
   try {
-    return applyCorePatch(document, patch);
+    return applyCorePatch(presentation, patch);
   } catch (error) {
     throw editorPatchError(error);
   }
 }
 
-export function invertJsonPatch(document, operations) {
+export function invertJsonPatch(presentation, operations) {
   assertPatchOperations(operations);
   const patch = operations.map(normalizeOperation);
   try {
-    return invertPatch(document, patch);
+    return invertPatch(presentation, patch);
   } catch (error) {
     throw editorPatchError(error);
   }
 }
 
-export function validateOpfDocument(document, validator = validatePresentation) {
-  const result = validator(document);
-  const valid = Boolean(result?.valid);
-  return {
-    valid,
-    errors: Array.isArray(result?.errors) ? result.errors : [],
-    warnings: Array.isArray(result?.warnings) ? result.warnings : [],
-    result
-  };
+/**
+ * Facts about the open presentation, from core's `stats`: slide, layout and section counts, payload kinds, words and notes coverage,
+ * images and their alt text, charts, tables, citations, fonts and an estimated speaking time (`options`: `perSlide`, `values`,
+ * `wordsPerMinute`). They are facts, never findings: no severities and no judgment about whether a number is too high, so a deck-info
+ * view can show them next to the Review panel. It reads the JSON only, so it also works on a document that fails validation.
+ */
+export function deckStats(editor, options) {
+  assertEditorSession(editor);
+  return stats(editor.presentation, options);
 }
 
 export function createEditorSession(input, options = {}) {
-  let document = parseInput(input);
-  let validation = validateOpfDocument(document, options.validate ?? validatePresentation);
+  let presentation = parseInput(input);
+  let validation = checkFormat(presentation);
   const undoStack = [];
   const redoStack = [];
   const listeners = new Set();
@@ -157,26 +139,26 @@ export function createEditorSession(input, options = {}) {
   function commitPatch(operations, meta = {}) {
     assertPatchOperations(operations);
     const patches = operations.map(normalizeOperation);
-    const before = document;
+    const before = presentation;
     let next, inversePatches;
     try {
-      ({ document: next, inverse: inversePatches } = applyPatchWithInverse(before, patches));
+      ({ presentation: next, inverse: inversePatches } = applyPatchWithInverse(before, patches));
     } catch (error) {
       throw editorPatchError(error);
     }
-    const nextValidation = validateOpfDocument(next, options.validate ?? validatePresentation);
+    const nextValidation = checkFormat(next);
 
     if ((meta.rejectInvalid ?? rejectInvalid) && !nextValidation.valid) {
       throw new OPFEditorError("invalid-opf-edit", "OPF edit produced an invalid document.", {
-        issues: nextValidation.errors,
+        issues: errorFindings(nextValidation),
         patches
       });
     }
 
     if (patches.every(patch => patch.op === "test")) return {
-      document: clone(document), patches: clonePatchOperations(patches), inversePatches: [], validation: nextValidation
+      presentation: clone(presentation), patches: clonePatchOperations(patches), inversePatches: [], validation: nextValidation
     };
-    document = next;
+    presentation = next;
     validation = nextValidation;
     undoStack.push({ patches: clonePatchOperations(patches), inversePatches, meta });
     redoStack.length = 0;
@@ -189,7 +171,7 @@ export function createEditorSession(input, options = {}) {
     });
 
     return {
-      document: clone(document),
+      presentation: clone(presentation),
       patches: clonePatchOperations(patches),
       inversePatches: clonePatchOperations(inversePatches),
       validation
@@ -197,8 +179,8 @@ export function createEditorSession(input, options = {}) {
   }
 
   const editor = {
-    get document() {
-      return clone(document);
+    get presentation() {
+      return clone(presentation);
     },
     get validation() {
       return validation;
@@ -211,7 +193,7 @@ export function createEditorSession(input, options = {}) {
     },
     snapshot() {
       return snapshotCache ??= freezeSnapshot({
-        document: clone(document),
+        presentation: clone(presentation),
         validation: clone(validation),
         canUndo: undoStack.length > 0,
         canRedo: redoStack.length > 0,
@@ -227,33 +209,35 @@ export function createEditorSession(input, options = {}) {
       return () => listeners.delete(listener);
     },
     get(path, fallback) {
-      return getValueAtPath(document, path, fallback);
+      return getValueAtPath(presentation, path, fallback);
     },
     set(path, value, meta = {}) {
-      return commitPatch(createValuePatch(document, path, value), {
+      return commitPatch(createValuePatch(presentation, path, value), {
         ...meta,
         path: normalizePatchPath(path)
       });
     },
     composeSlide(slideIndex, options = {}) {
-      return composeSlide(document.slides?.[slideIndex], resolveCompositionOptions(document, slideIndex, options));
+      return composeSlide(presentation.slides?.[slideIndex], slideContext(presentation, slideIndex, options));
     },
     paginateSlide(slideIndex, options = {}, meta = {}) {
-      const resolved = resolveCompositionOptions(document, slideIndex, options);
-      const pagination = paginateSlide(document.slides[slideIndex], {
+      // Core pagination reads the measurement from `fonts`, so the resolved context hands it over that way.
+      const { textMeasurement, ...resolved } = slideContext(presentation, slideIndex, options);
+      const pagination = paginateSlide(presentation.slides[slideIndex], {
         ...resolved,
-        reservedIds: collectReservedPresentationIds(document),
+        fonts: options.fonts ?? (textMeasurement ? { textMeasurement } : undefined),
+        reservedIds: collectReservedPresentationIds(presentation),
       });
       // Pagination can persist a readability policy without adding a page. Commit
       // that change too, so preview/export use the same minimum that was evaluated.
-      if (pagination.slides.length === 1 && jsonEqual(pagination.slides[0], document.slides[slideIndex])) return { change: null, pagination };
-      const slides = [...document.slides];
+      if (pagination.slides.length === 1 && jsonEqual(pagination.slides[0], presentation.slides[slideIndex])) return { change: null, pagination };
+      const slides = [...presentation.slides];
       slides.splice(slideIndex, 1, ...pagination.slides);
       const change = editor.set('slides', slides, { ...meta, rejectInvalid: true, pagination: pagination.pages });
       return { change, pagination };
     },
     setComposition(slideIndex, composition, meta = {}) {
-      if (!Number.isInteger(slideIndex) || !document.slides?.[slideIndex]) throw new OPFEditorError("slide-index-out-of-range", "Slide index is out of range.");
+      if (!Number.isInteger(slideIndex) || !presentation.slides?.[slideIndex]) throw new OPFEditorError("slide-index-out-of-range", "Slide index is out of range.");
       return editor.set(`slides.${slideIndex}.composition`, composition, { ...meta, rejectInvalid: true });
     },
     setGroupComposition(path, composition, meta = {}) {
@@ -268,7 +252,7 @@ export function createEditorSession(input, options = {}) {
     applyPatch: commitPatch,
     /**
      * The undo and redo stacks as plain data (oldest entry first): `{ undo: [{ patches, inversePatches, meta }], redo: [...] }`.
-     * Together with `document` this is everything `restoreState` needs to bring a session back, for hosts that persist work.
+     * Together with `presentation` this is everything `restoreState` needs to bring a session back, for hosts that persist work.
      */
     exportHistory() {
       const entry = (item) => ({ patches: clonePatchOperations(item.patches), inversePatches: clonePatchOperations(item.inversePatches), meta: clone(item.meta ?? {}) });
@@ -281,11 +265,11 @@ export function createEditorSession(input, options = {}) {
      * before anything changes, so a stale or damaged copy never corrupts the session. Emits one `restore` event.
      */
     restoreState(state, meta = {}) {
-      if (!state || typeof state !== "object") throw new OPFEditorError("invalid-state", "restoreState needs { document, undo?, redo? }.");
-      const next = parseInput(state.document);
-      const nextValidation = validateOpfDocument(next, options.validate ?? validatePresentation);
+      if (!state || typeof state !== "object") throw new OPFEditorError("invalid-state", "restoreState needs { presentation, undo?, redo? }.");
+      const next = parseInput(state.presentation);
+      const nextValidation = checkFormat(next);
       if ((meta.rejectInvalid ?? rejectInvalid) && !nextValidation.valid) {
-        throw new OPFEditorError("invalid-opf-edit", "The restored document is not valid OPF.", { issues: nextValidation.errors });
+        throw new OPFEditorError("invalid-opf-edit", "The restored document is not valid OPF.", { issues: errorFindings(nextValidation) });
       }
       const undo = state.undo ?? [], redo = state.redo ?? [];
       const wellFormed = (entries) => Array.isArray(entries) && entries.every((item) => item && Array.isArray(item.patches) && Array.isArray(item.inversePatches));
@@ -307,20 +291,20 @@ export function createEditorSession(input, options = {}) {
         throw new OPFEditorError("invalid-history", "The undo history does not belong to this document.", { cause: error instanceof Error ? error.message : String(error) });
       }
       const entry = (item) => ({ patches: item.patches.map(normalizeOperation), inversePatches: item.inversePatches.map(normalizeOperation), meta: clone(item.meta ?? {}) });
-      document = next;
+      presentation = next;
       validation = nextValidation;
       undoStack.length = 0;
       redoStack.length = 0;
       undoStack.push(...undo.map(entry));
       redoStack.push(...redo.map(entry));
       emit({ type: "restore", patches: [], validation, meta });
-      return { document: clone(document), patches: [], validation };
+      return { presentation: clone(presentation), patches: [], validation };
     },
     undo(meta = {}) {
       const entry = undoStack.pop();
       if (!entry) return null;
-      document = applyJsonPatch(document, entry.inversePatches);
-      validation = validateOpfDocument(document, options.validate ?? validatePresentation);
+      presentation = applyJsonPatch(presentation, entry.inversePatches);
+      validation = checkFormat(presentation);
       redoStack.push(entry);
       emit({
         type: "undo",
@@ -330,7 +314,7 @@ export function createEditorSession(input, options = {}) {
         meta
       });
       return {
-        document: clone(document),
+        presentation: clone(presentation),
         patches: clonePatchOperations(entry.inversePatches),
         redoPatches: clonePatchOperations(entry.patches),
         validation
@@ -339,8 +323,8 @@ export function createEditorSession(input, options = {}) {
     redo(meta = {}) {
       const entry = redoStack.pop();
       if (!entry) return null;
-      document = applyJsonPatch(document, entry.patches);
-      validation = validateOpfDocument(document, options.validate ?? validatePresentation);
+      presentation = applyJsonPatch(presentation, entry.patches);
+      validation = checkFormat(presentation);
       undoStack.push(entry);
       emit({
         type: "redo",
@@ -350,7 +334,7 @@ export function createEditorSession(input, options = {}) {
         meta
       });
       return {
-        document: clone(document),
+        presentation: clone(presentation),
         patches: clonePatchOperations(entry.patches),
         inversePatches: clonePatchOperations(entry.inversePatches),
         validation
@@ -473,7 +457,7 @@ export function assertCatalogId(catalogKind, id, options = {}) {
 export function setCatalogId(editor, path, catalogKind, id, meta = {}) {
   assertEditorSession(editor);
   const catalogId = assertCatalogId(catalogKind, id, {
-    presentation: meta.presentation ?? editor.document,
+    presentation: meta.presentation ?? editor.presentation,
     catalogs: meta.catalogs,
     catalogSources: meta.catalogSources
   });
@@ -534,7 +518,7 @@ export function createCatalogSelect(editor, options) {
 
   for (const option of getCatalogOptions(catalogKind, {
     ...options,
-    presentation: options?.presentation ?? editor.document
+    presentation: options?.presentation ?? editor.presentation
   })) {
     const optionElement = documentRef.createElement("option");
     optionElement.value = option.id;
@@ -636,12 +620,12 @@ function normalizeOperation(operation) {
 
 // Core patch errors keep their stable codes; the editor reports them as OPFEditorError.
 function editorPatchError(error) {
-  if (!(error instanceof PatchError)) return error;
+  if (!(error instanceof OPFPatchError)) return error;
   const details = {};
   if (error.path !== undefined) details.path = error.path;
   if (error.operation !== undefined) details.operation = error.operation;
   if (error.index !== undefined) details.index = error.index;
-  if (error.validation) details.issues = error.validation.errors;
+  if (error.validation) details.issues = errorFindings(error.validation);
   return new OPFEditorError(error.code, error.message, details);
 }
 

package/dist/json-options.js

@@ -1,4 +1,5 @@
-import { catalogKinds, catalogSchemaNames, schemas, validateCatalogRecord, validatePresentation } from "@openpresentation/opf";
+import { catalogKinds, catalogSchemaNames, schemas, validateCatalogRecord } from "@openpresentation/opf";
+import { checkFormat, firstErrorMessage } from "./checks.js";
 import { getCatalogOptions } from "./index.js";
 import { schemaAtPath, schemaVariants } from "./schema.js";
 import { applyEdits, findNodeAtLocation, findNodeAtOffset, getNodePath, modify, parseTree } from "jsonc-parser";
@@ -19,8 +20,8 @@ function placeholderSummary(types) {
         return "Placeholders not specified";
     if (!types.length)
         return "No placeholders";
-    const labels = { title: "Title", subtitle: "Subtitle", text: "Text", metric: "Metric", list: "List", picture: "Image", chart: "Chart", table: "Table", code: "Code", media: "Video", quote: "Quote", timeline: "Timeline", tag: "Tag", diagram: "Image" };
-    const order = ["title", "subtitle", "text", "metric", "list", "picture", "chart", "table", "code", "media", "quote", "timeline", "tag", "diagram"];
+    const labels = { title: "Title", subtitle: "Subtitle", tag: "Tag", text: "Text", list: "List", image: "Image", video: "Video", chart: "Chart", table: "Table", code: "Code", metric: "Metric", quote: "Quote", timeline: "Timeline" };
+    const order = ["title", "subtitle", "tag", "text", "list", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
     return [...new Set(types)].sort((a, b) => order.indexOf(a) - order.indexOf(b)).map(type => {
         const count = types.filter(value => value === type).length;
         return `${labels[type] ?? type}${count > 1 ? ` × ${count}` : ""}`;
@@ -64,9 +65,9 @@ function describeOptions(choices, records, current, catalog) {
 // The installed schema identifies fields; a document field merely named "layout"
 // inside arbitrary metadata is not mistaken for an OPF layout reference.
 export function getJsonFieldContext(source, position, loadedCatalogs = {}) {
-    let document;
+    let presentation;
     try {
-        document = JSON.parse(source);
+        presentation = JSON.parse(source);
     }
     catch {
         return null;
@@ -84,18 +85,18 @@ export function getJsonFieldContext(source, position, loadedCatalogs = {}) {
     const path = getNodePath(node);
     if (!path.length)
         return null;
-    const schema = schemaAtPath(document, path.map(String));
+    const schema = schemaAtPath(presentation, path.map(String));
     const variants = schemaVariants(schema);
     const description = String(schema.description ?? "");
     let catalog = catalogFor(description);
     // Audience arrays inherit the catalog context from the array property.
     if (!catalog && typeof path.at(-1) === "number")
-        catalog = catalogFor(String(schemaAtPath(document, path.slice(0, -1).map(String)).description ?? ""));
+        catalog = catalogFor(String(schemaAtPath(presentation, path.slice(0, -1).map(String)).description ?? ""));
     const options = new Map();
     const records = new Map();
     let unloadedSource = false;
     if (catalog && typeof node.value === "string") {
-        const entries = document.catalogs;
+        const entries = presentation.catalogs;
         const local = entries?.[catalog];
         unloadedSource = Boolean(local?.source);
         for (const option of getCatalogOptions(catalog)) {
@@ -148,18 +149,18 @@ export function replaceFieldOption(context, value) {
     if (!context.options.some(option => option.value === value))
         throw new Error("This choice is no longer available.");
     let next = context.source.slice(0, context.offset) + JSON.stringify(value) + context.source.slice(context.offset + context.length);
-    const document = JSON.parse(next);
-    if (context.path.reduce((current, key) => current?.[key], document) !== value)
+    const presentation = JSON.parse(next);
+    if (context.path.reduce((current, key) => current?.[key], presentation) !== value)
         throw new Error("This field has a duplicate key. Resolve it in the JSON before choosing an option.");
     const types = context.options.find(option => option.value === value).placeholderTypes;
     if (value !== context.value && types && context.catalog === 'layouts' && context.path.length === 3
-        && context.path[0] === 'slides' && context.path[2] === 'layout' && validatePresentation(document).valid) {
-        const populated = populateLayoutPlaceholders(document, context.path[1], types);
-        next = updateSource(next, document, populated);
+        && context.path[0] === 'slides' && context.path[2] === 'layout' && checkFormat(presentation).valid) {
+        const populated = populateLayoutPlaceholders(presentation, context.path[1], types);
+        next = updateSource(next, presentation, populated);
     }
-    const result = validatePresentation(JSON.parse(next));
-    if (!result.valid && validatePresentation(JSON.parse(context.source)).valid)
-        throw new Error(result.errors[0]?.message ?? "This option is not valid here.");
+    const result = checkFormat(JSON.parse(next));
+    if (!result.valid && checkFormat(JSON.parse(context.source)).valid)
+        throw new Error(firstErrorMessage(result, "This option is not valid here."));
     return next;
 }
 

package/dist/layout-handles.js

@@ -22,11 +22,11 @@ export function createLayoutHandles(root, options) {
     const edit=active;
     edit.fraction=fraction;
     try{
-      const prepared=prepareTrackResize(editor.document,active.flow,active.boundary,fraction);
-      options.render(prepared.document);
+      const prepared=prepareTrackResize(editor.presentation,active.flow,active.boundary,fraction);
+      options.render(prepared.presentation);
       if(active!==edit)return false;
       edit.prepared=prepared;edit.valid=true;
-      options.onDraft?.({document:prepared.document,path:active.flow.path+'.composition',value:prepared.composition});
+      options.onDraft?.({presentation:prepared.presentation,path:active.flow.path+'.composition',value:prepared.composition});
       if(active!==edit)return false;
       options.clearError?.();return true;
     }catch(error){if(active===edit)edit.valid=false;options.onError(error);return false;}
@@ -41,7 +41,7 @@ export function createLayoutHandles(root, options) {
     active=null;release(edit);committing=true;
     try{
       // Rebase unrelated document edits, retaining the guarded container.
-      const prepared=prepareTrackResize(editor.document,edit.flow,edit.boundary,edit.fraction);
+      const prepared=prepareTrackResize(editor.presentation,edit.flow,edit.boundary,edit.fraction);
       if(edit.moved)editor.applyPatch(prepared.patches,{source:'canvas-layout',rejectInvalid:true});
       else renderCanonical();
       options.onCommit?.({path:edit.flow.path+'.composition',editor});return true;
@@ -56,7 +56,7 @@ export function createLayoutHandles(root, options) {
     if(event)layer.setPointerCapture(event.pointerId);
     return true;
   }
-  function update(document,geometry) {
+  function update(presentation,geometry) {
     lastGeometry=geometry;
     layer.replaceChildren();
     if(!enabled||options.isTextEditing())return;

package/dist/layout-placeholders.js

@@ -2,7 +2,7 @@ import {listBlockContainers,prepareBlockInsert} from './blocks.js';
 
 const payloadFields=['text','items','bullets','image','video','chart','table','code','metric','quote','timeline'];
 const headingFields=new Set(['title','subtitle','tag']);
-const fields={text:'text',list:'items',picture:'image',media:'video',diagram:'image',chart:'chart',table:'table',code:'code',metric:'metric',quote:'quote',timeline:'timeline'};
+const fields={text:'text',list:'items',image:'image',video:'video',chart:'chart',table:'table',code:'code',metric:'metric',quote:'quote',timeline:'timeline'};
 const region=key=>/^(?:(?:top|middle|bottom)(?:\+(?:top|middle|bottom))*(?::(?:left|center|right)(?:\+(?:left|center|right))*)?|(?:left|center|right)(?:\+(?:left|center|right))*)$/.test(key);
 
 function emptyPayload(field){
@@ -16,8 +16,8 @@ function emptyPayload(field){
 }
 
 /** Supply authored slots without replacing content, metadata or region placement. */
-export function populateLayoutPlaceholders(document,slideIndex,types){
-  let next=structuredClone(document),slide=next.slides[slideIndex];
+export function populateLayoutPlaceholders(presentation,slideIndex,types){
+  let next=structuredClone(presentation),slide=next.slides[slideIndex];
   const counts=new Map();
   function count(host){
     if(!host||typeof host!=='object')return;
@@ -48,7 +48,7 @@ export function populateLayoutPlaceholders(document,slideIndex,types){
       const path=regions.length?`/slides/${slideIndex}/${regions.at(-1)}`:`/slides/${slideIndex}`;
       const containers=listBlockContainers(next,{slideIndex,includeImplicit:true});
       if(!containers.some(container=>container.path===path))throw new Error('This slide has no editable content container for the new placeholder.');
-      next=prepareBlockInsert(next,path,{[field]:value}).document;
+      next=prepareBlockInsert(next,path,{[field]:value}).presentation;
       slide=next.slides[slideIndex];
     }
   }