@openpresentation/opf-editor 0.11.3 → 0.14.2

package/dist/image-crop.d.ts

@@ -41,14 +41,14 @@ export interface ImageDescription {
   entry?: unknown;
 }
 /** What a path holds when it is a picture, or `{ error }` with the reason it is not croppable (not a picture, a missing asset, SVG). */
-export declare function describeImage(document: unknown, path: string): ImageDescription | { error: string };
-export declare function countAssetReferences(document: unknown, id: string): number;
+export declare function describeImage(presentation: unknown, path: string): ImageDescription | { error: string };
+export declare function countAssetReferences(presentation: unknown, id: string): number;
 export interface CroppedPixels { dataUri: string; mediaType: string; width: number; height: number; bytes?: number }
 export interface PreparedCrop { patches: JsonPatchOperation[]; assetId: string; reference: string; origin?: string; image: ImageDescription }
 /** The patches that apply a cropped picture: a new asset and the image pointing at it (pure). Throws `not-croppable`. */
-export declare function prepareCrop(document: unknown, path: string, pixels: CroppedPixels): PreparedCrop;
+export declare function prepareCrop(presentation: unknown, path: string, pixels: CroppedPixels): PreparedCrop;
 /** The patches that put a cropped picture back to its original asset, or null. */
-export declare function prepareRestore(document: unknown, path: string): { patches: JsonPatchOperation[]; origin: string; image: ImageDescription } | null;
+export declare function prepareRestore(presentation: unknown, path: string): { patches: JsonPatchOperation[]; origin: string; image: ImageDescription } | null;
 /** Restore the original as one undoable change; null when there is no original. */
 export declare function restoreOriginal(editor: EditorSession, path: string, meta?: Record<string, unknown>): (EditorChange & { origin: string }) | null;
 export interface LoadedImage { image: HTMLImageElement; width: number; height: number }

package/dist/image-crop.js

@@ -156,11 +156,11 @@ export const isFullRect = (rect, bounds) => rect.x < 0.5 && rect.y < 0.5 && Math
  * (the field is `{ src, ... }`); `assetSrc` is what `src` resolves to (the asset's own `src`), and `origin` is the asset a
  * crop of this picture was made from, when there is one.
  */
-export function describeImage(document, path) {
+export function describeImage(presentation, path) {
   const segments = String(path).split(".");
   const last = segments.at(-1);
   if (!["image", "slideImage"].includes(last)) return { error: "This is not a picture." };
-  const value = getValueAtPath(document, path);
+  const value = getValueAtPath(presentation, path);
   const pointer = opfPathToJsonPointer(segments);
   let form;
   let src;
@@ -177,7 +177,7 @@ export function describeImage(document, path) {
   let assetSrc = src;
   let entry;
   if (assetId !== undefined) {
-    entry = getValueAtPath(document, ["assets", assetId]);
+    entry = getValueAtPath(presentation, ["assets", assetId]);
     if (entry === undefined) return { error: `The picture asset "${assetId}" is missing from this presentation.` };
     assetSrc = typeof entry === "string" ? entry : entry?.src;
     if (typeof assetSrc !== "string") return { error: `The picture asset "${assetId}" has no source.` };
@@ -193,22 +193,22 @@ export function describeImage(document, path) {
 }
 
 /** How many places in the document use `asset:<id>` (the `assets` map itself is not counted). */
-export function countAssetReferences(document, id) {
+export function countAssetReferences(presentation, id) {
   const reference = `asset:${id}`;
   let count = 0;
   const walk = (value) => {
     if (typeof value === "string") count += value === reference ? 1 : 0;
     else if (Array.isArray(value)) value.forEach(walk);
-    else if (isObject(value)) for (const [key, child] of Object.entries(value)) if (key !== "assets" || value !== document) walk(child);
+    else if (isObject(value)) for (const [key, child] of Object.entries(value)) if (key !== "assets" || value !== presentation) walk(child);
   };
-  walk(document);
+  walk(presentation);
   return count;
 }
 
 // ---- the change --------------------------------------------------------------------------------------------------------
 
-function assetPatches(document, id, entry) {
-  const assets = document?.assets;
+function assetPatches(presentation, id, entry) {
+  const assets = presentation?.assets;
   return isObject(assets)
     ? [{ op: "add", path: opfPathToJsonPointer(["assets", id]), value: entry }]
     : [{ op: "add", path: "/assets", value: { [id]: entry } }];
@@ -219,33 +219,33 @@ function assetPatches(document, id, entry) {
  * pointing at it. `pixels` is `{ dataUri, mediaType, width, height }` (from `cropImagePixels`). A previous crop's asset that
  * nothing else uses is removed in the same change. Pure.
  */
-export function prepareCrop(document, path, pixels) {
-  const image = describeImage(document, path);
+export function prepareCrop(presentation, path, pixels) {
+  const image = describeImage(presentation, path);
   if (image.error) throw fail("not-croppable", image.error, { path });
   const origin = image.origin ?? image.assetId;
-  const id = uniqueAssetId(document, `${origin ?? "image"}-crop`);
+  const id = uniqueAssetId(presentation, `${origin ?? "image"}-crop`);
   const title = (isObject(image.entry) && typeof image.entry.title === "string" ? image.entry.title : origin ?? "Picture").replace(/ \(cropped\)$/, "");
   const entry = { src: pixels.dataUri, mediaType: pixels.mediaType, title: `${title} (cropped)` };
   if (image.alt) entry.alt = image.alt;
   if (origin) entry.description = `Cropped from asset:${origin}`;
-  const patches = assetPatches(document, id, entry);
+  const patches = assetPatches(presentation, id, entry);
   patches.push({ op: "replace", path: image.srcPointer, value: `asset:${id}` });
-  if (image.origin && image.assetId && countAssetReferences(document, image.assetId) === 1) patches.push({ op: "remove", path: opfPathToJsonPointer(["assets", image.assetId]) });
+  if (image.origin && image.assetId && countAssetReferences(presentation, image.assetId) === 1) patches.push({ op: "remove", path: opfPathToJsonPointer(["assets", image.assetId]) });
   return { patches, assetId: id, reference: `asset:${id}`, origin, image };
 }
 
 /** The patches that put a cropped picture back to the asset it was cropped from, or null when there is none. */
-export function prepareRestore(document, path) {
-  const image = describeImage(document, path);
-  if (image.error || !image.origin || getValueAtPath(document, ["assets", image.origin]) === undefined) return null;
+export function prepareRestore(presentation, path) {
+  const image = describeImage(presentation, path);
+  if (image.error || !image.origin || getValueAtPath(presentation, ["assets", image.origin]) === undefined) return null;
   const patches = [{ op: "replace", path: image.srcPointer, value: `asset:${image.origin}` }];
-  if (countAssetReferences(document, image.assetId) === 1) patches.push({ op: "remove", path: opfPathToJsonPointer(["assets", image.assetId]) });
+  if (countAssetReferences(presentation, image.assetId) === 1) patches.push({ op: "remove", path: opfPathToJsonPointer(["assets", image.assetId]) });
   return { patches, origin: image.origin, image };
 }
 
 /** Put a cropped picture back to its original as one undoable change. Returns null when there is no original to restore. */
 export function restoreOriginal(editor, path, meta = {}) {
-  const prepared = prepareRestore(editor.document, path);
+  const prepared = prepareRestore(editor.presentation, path);
   if (!prepared) return null;
   return { ...editor.applyPatch(prepared.patches, { ...meta, source: meta.source ?? "image-restore", path }), origin: prepared.origin };
 }
@@ -325,12 +325,12 @@ export async function cropImagePixels(loaded, rect, { mediaType, maxBytes = DEFA
  * `{ assetId, reference, width, height }`.
  */
 export async function applyCrop(editor, path, rect, options = {}) {
-  const image = describeImage(editor.document, path);
+  const image = describeImage(editor.presentation, path);
   if (image.error) throw fail("not-croppable", image.error, { path });
   const loaded = options.loaded ?? await loadImagePixels(image.assetSrc);
   const pixels = await cropImagePixels(loaded, rect, { mediaType: image.mediaType, maxBytes: options.maxBytes });
   // The document may have changed while the picture was encoding.
-  const prepared = prepareCrop(editor.document, path, pixels);
+  const prepared = prepareCrop(editor.presentation, path, pixels);
   const change = editor.applyPatch(prepared.patches, { ...options.meta, source: options.meta?.source ?? "image-crop", path, assetId: prepared.assetId });
   return { ...change, assetId: prepared.assetId, reference: prepared.reference, width: pixels.width, height: pixels.height };
 }

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