@openpresentation/opf-editor 0.11.3 → 0.14.2

package/dist/outline.js

@@ -9,10 +9,11 @@
 //   item      one list item or bullet; `listPath` and `itemIndex` locate it and `level` is 1 plus its nesting level
 //   other     content that is not text, shown by its kind (`label`), never edited here
 // Text that carries formatting (a run array) is shown flattened and is not editable in the outline, so nothing is flattened away.
-import { getValueAtPath, opfPathToJsonPointer, splitOpfPath, validateOpfDocument } from "./index.js";
+import { getValueAtPath, opfPathToJsonPointer, splitOpfPath } from "./index.js";
 import { checkedDocument, fail } from "./edit-helpers.js";
 import { visitContentPayloads } from "./presentation-ids.js";
 import { prepareAddSlide, prepareMoveSlidesBy } from "./slides.js";
+import { checkFormat } from "./checks.js";
 
 const clone = (value) => structuredClone(value);
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -46,14 +47,15 @@ function walkPayload(node, path, slideIndex, rows) {
  * Read the deck as outline rows (see the file header). `rows` follow document order: for each slide its title, subtitle, the
  * slide's own text and list, then every block and region in order.
  */
-export function readOutline(document) {
-  if (!document || !Array.isArray(document.slides)) throw fail("invalid-input", "The outline needs an OPF document with a slides array.");
+export function readOutline(presentation) {
+  if (!presentation || !Array.isArray(presentation.slides)) throw fail("invalid-input", "The outline needs an OPF document with a slides array.");
   const rows = [];
-  document.slides.forEach((slide, slideIndex) => {
+  presentation.slides.forEach((slide, slideIndex) => {
     const base = `slides.${slideIndex}`;
-    const title = typeof slide?.title === "string" ? slide.title : "";
+    // FA-10: a title or subtitle may be TextRun[]: the row shows its plain text and is edited as runs elsewhere (a text row writes a string).
+    const title = flatten(slide?.title);
     rows.push({ key: `slide:${base}`, kind: "slide", slideIndex, level: 0, text: title, path: `${base}.title`, editable: slide?.title === undefined || typeof slide.title === "string", hidden: slide?.hidden === true, section: typeof slide?.section === "string" ? slide.section : undefined, id: slide?.id });
-    if (typeof slide?.subtitle === "string") rows.push({ key: `subtitle:${base}.subtitle`, kind: "subtitle", slideIndex, level: 1, text: slide.subtitle, path: `${base}.subtitle`, editable: true });
+    if (typeof slide?.subtitle === "string" || Array.isArray(slide?.subtitle)) rows.push({ key: `subtitle:${base}.subtitle`, kind: "subtitle", slideIndex, level: 1, text: flatten(slide.subtitle), path: `${base}.subtitle`, editable: typeof slide.subtitle === "string" });
     if (!isObject(slide)) return;
     walkPayload(slide, base, slideIndex, rows);
     visitContentPayloads(slide, base, (payload, path) => walkPayload(payload, path, slideIndex, rows));
@@ -64,23 +66,23 @@ export function readOutline(document) {
 // --- text ------------------------------------------------------------------------------------------
 
 /** Compute editing the text of a row (a title, subtitle, text paragraph or list item); a row that is not plain text throws. */
-export function prepareSetOutlineText(document, row, text) {
+export function prepareSetOutlineText(presentation, row, text) {
   if (!row?.editable) throw fail("outline-row-not-editable", "This text carries formatting or is not text. Edit it on the slide.", { path: row?.path });
   const value = String(text);
-  const current = getValueAtPath(document, splitOpfPath(row.path));
-  if (current === value || (current === undefined && value === "")) return { document: clone(document), patches: [], changed: false, selection: [row.slideIndex] };
+  const current = getValueAtPath(presentation, splitOpfPath(row.path));
+  if (current === value || (current === undefined && value === "")) return { presentation: clone(presentation), patches: [], changed: false, selection: [row.slideIndex] };
   const pointer = opfPathToJsonPointer(row.path);
   const patches = [{ op: current === undefined ? "add" : "replace", path: pointer, value }];
-  return finish(document, patches, { action: "outline-text", selection: [row.slideIndex] });
+  return finish(presentation, patches, { action: "outline-text", selection: [row.slideIndex] });
 }
 export function setOutlineText(editor, row, text, meta) {
-  return apply(editor, prepareSetOutlineText(editor.document, row, text), meta, "outline-text");
+  return apply(editor, prepareSetOutlineText(editor.presentation, row, text), meta, "outline-text");
 }
 
 // --- list levels -----------------------------------------------------------------------------------
 
-function listAt(document, row) {
-  const list = getValueAtPath(document, splitOpfPath(row.listPath));
+function listAt(presentation, row) {
+  const list = getValueAtPath(presentation, splitOpfPath(row.listPath));
   if (!Array.isArray(list) || list[row.itemIndex] === undefined) throw fail("outline-row-not-found", "That list item is no longer there.", { path: row.listPath });
   return list;
 }
@@ -104,17 +106,17 @@ function blockEnd(levels, index) {
  * than the item above, and the first item cannot be nested. Un-nesting an item that is already at the top level is
  * `prepareOutlinePromote`'s job (it becomes a slide); here it reports `changed: false` with a `reason`.
  */
-export function prepareShiftOutlineItem(document, row, delta) {
-  const list = listAt(document, row);
+export function prepareShiftOutlineItem(presentation, row, delta) {
+  const list = listAt(presentation, row);
   const levels = list.map((item) => itemParts(item).level);
   const index = row.itemIndex;
-  const none = (reason) => ({ document: clone(document), patches: [], changed: false, reason, selection: [row.slideIndex] });
+  const none = (reason) => ({ presentation: clone(presentation), patches: [], changed: false, reason, selection: [row.slideIndex] });
   if (delta > 0 && (index === 0 || levels[index] > levels[index - 1])) return none(index === 0 ? "The first item cannot be nested." : "This item is already one level in from the item above.");
   if (delta < 0 && levels[index] === 0) return none("This item is already at the top level.");
   const end = blockEnd(levels, index);
   const next = list.map((item, at) => (at >= index && at < end ? withLevel(item, Math.max(0, levels[at] + delta)) : item));
   const patches = [{ op: "replace", path: opfPathToJsonPointer(row.listPath), value: next }];
-  return finish(document, patches, { action: delta > 0 ? "outline-demote" : "outline-promote", selection: [row.slideIndex], focus: `item:${row.listPath}.${index}` });
+  return finish(presentation, patches, { action: delta > 0 ? "outline-demote" : "outline-promote", selection: [row.slideIndex], focus: `item:${row.listPath}.${index}` });
 }
 
 // --- item order ------------------------------------------------------------------------------------
@@ -123,11 +125,11 @@ export function prepareShiftOutlineItem(document, row, delta) {
  * Compute moving a list item (with the items nested under it) one place up (`delta` -1) or down (1) among the items at its level
  * and under the same parent. At the first or last place nothing changes (`changed` is false).
  */
-export function prepareMoveOutlineItem(document, row, delta) {
-  const list = listAt(document, row);
+export function prepareMoveOutlineItem(presentation, row, delta) {
+  const list = listAt(presentation, row);
   const levels = list.map((item) => itemParts(item).level);
   const index = row.itemIndex, end = blockEnd(levels, index);
-  const none = { document: clone(document), patches: [], changed: false, selection: [row.slideIndex] };
+  const none = { presentation: clone(presentation), patches: [], changed: false, selection: [row.slideIndex] };
   let order, focusIndex;
   if (delta < 0) {
     // The previous sibling starts at the nearest earlier item on the same level, provided no shallower item lies between.
@@ -143,32 +145,32 @@ export function prepareMoveOutlineItem(document, row, delta) {
     focusIndex = index + (siblingEnd - end);
   }
   const patches = [{ op: "replace", path: opfPathToJsonPointer(row.listPath), value: order }];
-  return finish(document, patches, { action: "outline-move", selection: [row.slideIndex], focus: `item:${row.listPath}.${focusIndex}` });
+  return finish(presentation, patches, { action: "outline-move", selection: [row.slideIndex], focus: `item:${row.listPath}.${focusIndex}` });
 }
 
 // --- insert and delete -----------------------------------------------------------------------------
 
 /** Compute adding an empty list item right after the item at `row` and everything nested under it, at the same level. */
-export function prepareInsertOutlineItem(document, row, text = "") {
-  const list = listAt(document, row);
+export function prepareInsertOutlineItem(presentation, row, text = "") {
+  const list = listAt(presentation, row);
   const levels = list.map((item) => itemParts(item).level);
   const end = blockEnd(levels, row.itemIndex);
   const item = levels[row.itemIndex] > 0 ? { text, level: levels[row.itemIndex] } : text;
-  return finish(document, [{ op: "add", path: `${opfPathToJsonPointer(row.listPath)}/${end}`, value: item }], { action: "outline-insert", selection: [row.slideIndex], focus: `item:${row.listPath}.${end}` });
+  return finish(presentation, [{ op: "add", path: `${opfPathToJsonPointer(row.listPath)}/${end}`, value: item }], { action: "outline-insert", selection: [row.slideIndex], focus: `item:${row.listPath}.${end}` });
 }
 /** Compute adding the first bullet under a slide: it goes in the slide's own list, or creates one. */
-export function prepareAddOutlineBullet(document, slideIndex, text = "") {
-  const slide = document.slides?.[slideIndex];
+export function prepareAddOutlineBullet(presentation, slideIndex, text = "") {
+  const slide = presentation.slides?.[slideIndex];
   if (!isObject(slide)) throw fail("slide-index-out-of-range", `Slide ${slideIndex} does not exist.`, { slideIndex });
   const key = LIST_KEYS.find((candidate) => Array.isArray(slide[candidate]));
   const base = `/slides/${slideIndex}`;
-  if (key) return finish(document, [{ op: "add", path: `${base}/${key}/${slide[key].length}`, value: text }], { action: "outline-insert", selection: [slideIndex], focus: `item:slides.${slideIndex}.${key}.${slide[key].length}` });
+  if (key) return finish(presentation, [{ op: "add", path: `${base}/${key}/${slide[key].length}`, value: text }], { action: "outline-insert", selection: [slideIndex], focus: `item:slides.${slideIndex}.${key}.${slide[key].length}` });
   if (Array.isArray(slide.blocks) || slide.type !== undefined) throw fail("outline-row-not-supported", "Add a list to this slide from the Content panel; its content is arranged in blocks.", { slideIndex });
-  return finish(document, [{ op: "add", path: `${base}/items`, value: [text] }], { action: "outline-insert", selection: [slideIndex], focus: `item:slides.${slideIndex}.items.0` });
+  return finish(presentation, [{ op: "add", path: `${base}/items`, value: [text] }], { action: "outline-insert", selection: [slideIndex], focus: `item:slides.${slideIndex}.items.0` });
 }
 /** Compute deleting a list item together with the items nested under it. */
-export function prepareRemoveOutlineItem(document, row) {
-  const list = listAt(document, row);
+export function prepareRemoveOutlineItem(presentation, row) {
+  const list = listAt(presentation, row);
   const levels = list.map((item) => itemParts(item).level);
   const end = blockEnd(levels, row.itemIndex);
   const patches = [];
@@ -178,7 +180,7 @@ export function prepareRemoveOutlineItem(document, row) {
   const removeList = survivors === 0 && row.listPath.split(".").length === 3;
   const finalPatches = removeList ? [{ op: "remove", path: opfPathToJsonPointer(row.listPath) }] : patches;
   const focus = survivors ? `item:${row.listPath}.${Math.max(0, row.itemIndex - 1)}` : `slide:slides.${row.slideIndex}`;
-  return finish(document, finalPatches, { action: "outline-remove", selection: [row.slideIndex], focus });
+  return finish(presentation, finalPatches, { action: "outline-remove", selection: [row.slideIndex], focus });
 }
 
 // --- promote and demote across slides --------------------------------------------------------------
@@ -187,14 +189,14 @@ export function prepareRemoveOutlineItem(document, row) {
  * Compute promoting a top-level list item to a slide: the item becomes the title of a new slide right after its own, and the items that
  * follow it in the same list move to that slide (PowerPoint's outline does the same). Items above it stay.
  */
-export function prepareOutlinePromote(document, row) {
-  const list = listAt(document, row);
+export function prepareOutlinePromote(presentation, row) {
+  const list = listAt(presentation, row);
   const title = itemParts(list[row.itemIndex]);
   if (title.level !== 0) throw fail("outline-row-not-supported", "Only a top-level item becomes a slide.", { path: row.path });
   if (!title.plain) throw fail("outline-row-not-editable", "This item carries formatting. Edit it on the slide.", { path: row.path });
   const following = list.slice(row.itemIndex + 1);
-  const added = prepareAddSlide(document, { at: row.slideIndex + 1, title: title.text });
-  const slide = clone(added.document.slides[row.slideIndex + 1]);
+  const added = prepareAddSlide(presentation, { at: row.slideIndex + 1, title: title.text });
+  const slide = clone(added.presentation.slides[row.slideIndex + 1]);
   const key = row.listPath.endsWith(".bullets") ? "bullets" : "items";
   if (following.length) slide[key] = clone(following);
   const pointer = opfPathToJsonPointer(row.listPath);
@@ -204,7 +206,7 @@ export function prepareOutlinePromote(document, row) {
     ? [{ op: "remove", path: pointer }]
     : Array.from({ length: list.length - row.itemIndex }, (_, offset) => ({ op: "remove", path: `${pointer}/${list.length - 1 - offset}` }));
   const patches = [...removal, { op: "add", path: `/slides/${row.slideIndex + 1}`, value: slide }];
-  return finish(document, patches, { action: "outline-promote-slide", selection: [row.slideIndex + 1], focus: `slide:slides.${row.slideIndex + 1}`, newSlideIndex: row.slideIndex + 1 });
+  return finish(presentation, patches, { action: "outline-promote-slide", selection: [row.slideIndex + 1], focus: `slide:slides.${row.slideIndex + 1}`, newSlideIndex: row.slideIndex + 1 });
 }
 
 const MERGEABLE = new Set(["id", "title", "text", "items", "bullets", "section", "hidden"]);
@@ -213,8 +215,8 @@ const MERGEABLE = new Set(["id", "title", "text", "items", "bullets", "section",
  * beneath it. Only a plain slide qualifies: one with a title and at most text or a list (no blocks, regions, notes, design or layout),
  * after a slide that has a list of its own or no body. Anything else throws `outline-row-not-supported` so nothing is dropped.
  */
-export function prepareOutlineDemoteSlide(document, slideIndex) {
-  const slides = document.slides;
+export function prepareOutlineDemoteSlide(presentation, slideIndex) {
+  const slides = presentation.slides;
   const slide = slides?.[slideIndex];
   if (!isObject(slide)) throw fail("slide-index-out-of-range", `Slide ${slideIndex} does not exist.`, { slideIndex });
   if (slideIndex === 0) throw fail("outline-row-not-supported", "The first slide has no slide before it to join.", { slideIndex });
@@ -231,36 +233,36 @@ export function prepareOutlineDemoteSlide(document, slideIndex) {
   const added = [slide.title, ...(typeof slide.text === "string" && slide.text ? [{ text: slide.text, level: 1 }] : []), ...nested];
   const base = `/slides/${slideIndex - 1}`;
   const patches = [{ op: "remove", path: `/slides/${slideIndex}` }, listKey ? { op: "replace", path: `${base}/${key}`, value: [...previous[key], ...added] } : { op: "add", path: `${base}/${key}`, value: added }];
-  return finish(document, patches, { action: "outline-demote-slide", selection: [slideIndex - 1], focus: `item:slides.${slideIndex - 1}.${key}.${(previous[key]?.length ?? 0)}` });
+  return finish(presentation, patches, { action: "outline-demote-slide", selection: [slideIndex - 1], focus: `item:slides.${slideIndex - 1}.${key}.${(previous[key]?.length ?? 0)}` });
 }
 
 // --- slides ----------------------------------------------------------------------------------------
 
 /** Compute moving a slide (the whole slide: its text moves with its title) by `delta` places; see `prepareMoveSlidesBy`. */
-export function prepareMoveOutlineSlide(document, slideIndex, delta) {
-  const prepared = prepareMoveSlidesBy(document, [slideIndex], delta);
+export function prepareMoveOutlineSlide(presentation, slideIndex, delta) {
+  const prepared = prepareMoveSlidesBy(presentation, [slideIndex], delta);
   return prepared.changed ? { ...prepared, focus: `slide:slides.${prepared.selection[0]}` } : prepared;
 }
 /** Compute adding a slide right after `slideIndex`, with an empty title for the outline to type into. */
-export function prepareInsertOutlineSlide(document, slideIndex) {
-  return { ...prepareAddSlide(document, { at: slideIndex + 1, title: "" }), action: "outline-insert-slide", focus: `slide:slides.${slideIndex + 1}` };
+export function prepareInsertOutlineSlide(presentation, slideIndex) {
+  return { ...prepareAddSlide(presentation, { at: slideIndex + 1, title: "" }), action: "outline-insert-slide", focus: `slide:slides.${slideIndex + 1}` };
 }
 
 // --- apply -----------------------------------------------------------------------------------------
 
-function finish(document, patches, extra) {
-  if (!patches.length) return { document: clone(document), patches: [], changed: false, ...extra };
-  const before = validateOpfDocument(document);
-  return { document: checkedDocument(document, patches, before), patches, changed: true, ...extra };
+function finish(presentation, patches, extra) {
+  if (!patches.length) return { presentation: clone(presentation), patches: [], changed: false, ...extra };
+  const before = checkFormat(presentation);
+  return { presentation: checkedDocument(presentation, patches, before), patches, changed: true, ...extra };
 }
 function requireEditor(editor) {
   if (!editor || typeof editor.applyPatch !== "function") throw fail("invalid-editor", "Expected an editor session created by createEditorSession.");
 }
 function apply(editor, prepared, meta, action) {
   requireEditor(editor);
-  const { document, patches, ...summary } = prepared;
-  void document;
-  if (!prepared.changed) return { ...summary, document: editor.document, patches: [], inversePatches: [], validation: editor.validation };
+  const { presentation, patches, ...summary } = prepared;
+  void presentation;
+  if (!prepared.changed) return { ...summary, presentation: editor.presentation, patches: [], inversePatches: [], validation: editor.validation };
   const change = editor.applyPatch(patches, { ...meta, source: meta?.source ?? "outline", action });
   return { ...change, ...summary };
 }

package/dist/persistence.d.ts

@@ -22,7 +22,7 @@ export interface RestoreOffer {
   dirty: boolean;
   /** Whether the undo history is stored with it. */
   hasHistory: boolean;
-  document: unknown;
+  presentation: unknown;
   /** An older copy that was moved aside when the user kept editing while an earlier offer was open. */
   earlier?: { savedAt: number; name?: string; slideCount?: number };
 }

package/dist/persistence.js

@@ -14,8 +14,9 @@
 //     shows, and the editor keeps working.
 import { fail } from "./edit-helpers.js";
 
-const VERSION = 1;
-const PREFIX = "opf-editor/v1/";
+// 2: the stored record holds `presentation` (it held `document` in version 1). A record of another version is never read.
+const VERSION = 2;
+const PREFIX = "opf-editor/v2/";
 export const DEFAULT_DEBOUNCE_MS = 800;
 export const DEFAULT_MAX_WAIT_MS = 5000;
 export const DEFAULT_MAX_HISTORY_ENTRIES = 200;
@@ -155,7 +156,7 @@ export function createPersistence(editor, options = {}) {
   const limits = { entries: options.maxHistoryEntries ?? DEFAULT_MAX_HISTORY_ENTRIES, bytes: options.maxHistoryBytes ?? DEFAULT_MAX_HISTORY_BYTES };
 
   let adapter;
-  let baseline = jsonOf(editor.document); // JSON of the document last saved elsewhere; null means "unsaved in a way we cannot compare"
+  let baseline = jsonOf(editor.presentation); // JSON of the document last saved elsewhere; null means "unsaved in a way we cannot compare"
   let touched = false; // the document changed (or was saved) since this controller was created: only then is a copy written
   let pending; // the stored record on offer
   let stashed = false; // the offered record has been moved aside (earlierKey) because the user kept editing
@@ -172,20 +173,20 @@ export function createPersistence(editor, options = {}) {
     options.onStatus?.(status);
   };
   function isDirty() {
-    return baseline === null || jsonOf(editor.document) !== baseline;
+    return baseline === null || jsonOf(editor.presentation) !== baseline;
   }
 
   // --- writing --------------------------------------------------------------------------------------
 
   async function writeRecord() {
     if (!adapter || destroyed) return false;
-    const document = editor.document;
-    const json = jsonOf(document);
+    const presentation = editor.presentation;
+    const json = jsonOf(presentation);
     const dirty = baseline === null || json !== baseline;
     const history = includeHistory ? trimHistory(editor.exportHistory(), limits) : undefined;
     const signature = `${json}|${dirty}|${history ? history.undo.length + ":" + history.redo.length : ""}`;
     if (signature === lastWritten) return true;
-    const record = { version: VERSION, key: options.key, savedAt: now(), name: typeof document.name === "string" ? document.name : undefined, slideCount: Array.isArray(document.slides) ? document.slides.length : 0, dirty, document, ...(history ? { undo: history.undo, redo: history.redo } : {}) };
+    const record = { version: VERSION, key: options.key, savedAt: now(), name: typeof presentation.name === "string" ? presentation.name : undefined, slideCount: Array.isArray(presentation.slides) ? presentation.slides.length : 0, dirty, presentation, ...(history ? { undo: history.undo, redo: history.redo } : {}) };
     setStatus({ state: "saving" });
     try {
       // The first write while an offer is open moves the offered copy aside, so ignoring the prompt never loses it.
@@ -233,24 +234,24 @@ export function createPersistence(editor, options = {}) {
 
   // --- offering and restoring -------------------------------------------------------------------------
 
-  const validRecord = (record) => isRecordObject(record) && record.version === VERSION && isRecordObject(record.document) && Array.isArray(record.document.slides);
-  const offerOf = (record) => ({ key: options.key, savedAt: record.savedAt, name: record.name, slideCount: record.slideCount, dirty: record.dirty !== false, hasHistory: Boolean(record.undo?.length || record.redo?.length), document: record.document });
+  const validRecord = (record) => isRecordObject(record) && record.version === VERSION && isRecordObject(record.presentation) && Array.isArray(record.presentation.slides);
+  const offerOf = (record) => ({ key: options.key, savedAt: record.savedAt, name: record.name, slideCount: record.slideCount, dirty: record.dirty !== false, hasHistory: Boolean(record.undo?.length || record.redo?.length), presentation: record.presentation });
 
   async function applyRecord(record) {
     const pristine = !touched && !editor.canUndo && !editor.canRedo;
-    const state = { document: record.document, undo: record.undo ?? [], redo: record.redo ?? [] };
+    const state = { presentation: record.presentation, undo: record.undo ?? [], redo: record.redo ?? [] };
     if (pristine) {
       try { editor.restoreState(state, { source: "restore" }); }
       catch (error) {
         if (error?.code !== "invalid-history") throw error;
-        editor.restoreState({ document: record.document }, { source: "restore" });
+        editor.restoreState({ presentation: record.presentation }, { source: "restore" });
       }
     } else {
       // The user already worked in this session: bring the copy back as one undoable change instead of replacing their history.
-      editor.applyPatch([{ op: "replace", path: "", value: structuredClone(record.document) }], { source: "restore" });
+      editor.applyPatch([{ op: "replace", path: "", value: structuredClone(record.presentation) }], { source: "restore" });
     }
     touched = true;
-    baseline = record.dirty === false ? jsonOf(editor.document) : null;
+    baseline = record.dirty === false ? jsonOf(editor.presentation) : null;
   }
 
   /** Put the offered copy back. Resolves true when it was restored, false when there was nothing on offer or it was refused. */
@@ -294,7 +295,7 @@ export function createPersistence(editor, options = {}) {
     let record;
     try { record = await adapter.get(earlierKey); } catch { return false; }
     if (!validRecord(record)) return false;
-    try { editor.applyPatch([{ op: "replace", path: "", value: structuredClone(record.document) }], { source: "restore" }); }
+    try { editor.applyPatch([{ op: "replace", path: "", value: structuredClone(record.presentation) }], { source: "restore" }); }
     catch { return false; }
     pending = undefined;
     touched = true;
@@ -309,13 +310,13 @@ export function createPersistence(editor, options = {}) {
 
   /** The host saved the document somewhere of its own (a download, a server): it is no longer "unsaved", and the stored copy says so. */
   function markSaved() {
-    baseline = jsonOf(editor.document);
+    baseline = jsonOf(editor.presentation);
     touched = true;
     return flush();
   }
   /** Treat the current document as the starting point (a host that loads a document into the editor): no write, and not dirty, until the next change. */
   function rebase() {
-    baseline = jsonOf(editor.document);
+    baseline = jsonOf(editor.presentation);
     touched = false;
     clearTimeout(timer);
     firstDirtyAt = 0;
@@ -329,7 +330,7 @@ export function createPersistence(editor, options = {}) {
     await dropEarlier();
     lastWritten = "";
     touched = false;
-    baseline = jsonOf(editor.document);
+    baseline = jsonOf(editor.presentation);
     setStatus({ state: status.available ? "idle" : status.state, message: "" });
   }
 
@@ -371,7 +372,7 @@ export function createPersistence(editor, options = {}) {
       setStatus({ state: "error", message: `Saved work could not be read (${String(error?.message ?? error)}).` });
       return { available: true, offered: false };
     }
-    if (!validRecord(record) || jsonOf(record.document) === jsonOf(editor.document)) return { available: true, offered: false };
+    if (!validRecord(record) || jsonOf(record.presentation) === jsonOf(editor.presentation)) return { available: true, offered: false };
     try {
       const earlier = await adapter.get(earlierKey);
       hasEarlier = validRecord(earlier);

package/dist/presentation-ids.js

@@ -47,9 +47,9 @@ export function slideIds(slide) {
   return ids;
 }
 
-export function collectReservedPresentationIds(document) {
+export function collectReservedPresentationIds(presentation) {
   const ids = [];
-  for (const slide of document.slides ?? []) ids.push(...slideIds(slide));
+  for (const slide of presentation.slides ?? []) ids.push(...slideIds(slide));
   return ids.filter(Boolean);
 }
 

package/dist/react.js

@@ -32,7 +32,7 @@ export function createOPFReactComponents(React) {
     ...props
   }) {
     const snapshot = useEditorSnapshot(editor);
-    const value = getValueAtPath(snapshot.document, path, "");
+    const value = getValueAtPath(snapshot.presentation, path, "");
     const tag = multiline ? "textarea" : "input";
     return React.createElement(tag, {
       ...props,
@@ -60,9 +60,9 @@ export function createOPFReactComponents(React) {
     ...props
   }) {
     const snapshot = useEditorSnapshot(editor);
-    const value = getValueAtPath(snapshot.document, path, "");
+    const value = getValueAtPath(snapshot.presentation, path, "");
     const currentId = value && typeof value === "object" ? value.id : value;
-    const options = catalogOptions ?? getCatalogOptions(catalogKind, { presentation: snapshot.document });
+    const options = catalogOptions ?? getCatalogOptions(catalogKind, { presentation: snapshot.presentation });
 
     return React.createElement(
       "select",

package/dist/review-panel.d.ts

@@ -1,44 +1,61 @@
+import type { ValidateOptions } from "@openpresentation/opf";
 import type { EditorSession } from "./index.js";
-import type { ReviewAuditOptions, ReviewFinding, ReviewFix, ReviewReport, ReviewTarget } from "./review.js";
+import type { ReviewFinding, ReviewFix, ReviewHook, ReviewReport, ReviewTarget } from "./review.js";
 
 export interface ReviewPanelOptions {
   editor: EditorSession;
   /** The slide the "This slide only" filter follows. Call `update()` when it changes. */
   getSlideIndex?: () => number;
-  /** Core's `AuditOptions` for this document, for example `{ textMeasurement }` from the host's font registry. */
-  getAuditOptions?: (document: unknown) => ReviewAuditOptions;
+  /** Core's `ValidateOptions` for this document, for example `{ fonts: { textMeasurement } }` from the host's fonts handle (a function of the slide index is accepted too). */
+  getValidateOptions?: (presentation: unknown) => ValidateOptions;
   /** Select the content a finding is about. `target.path` is the OPF dotted path (the nearest existing field), `target.slide` the slide or null. */
   onGoTo?: (event: { finding: ReviewFinding; target: ReviewTarget }) => void;
   /** Focus a field the panel does not own (a title, text, link, language or font size) after going to it. Alt text is edited in the panel itself. */
   onFocusField?: (event: { finding: ReviewFinding; fix: ReviewFix; target: ReviewTarget }) => void;
   /** Called with every status or error message the panel shows. */
   onStatus?: (message: string, info: { error: boolean }) => void;
-  /** Called after every redraw with the counts of the findings shown (after the filters and hidden checks) and of all findings. */
-  onChange?: (counts: { error: number; warning: number; info: number; total: number; all: number; unavailable: boolean }) => void;
+  /** Called after every redraw with the counts of the findings shown (after the filters and hidden checks), of all findings, and the sources present (`opf`, `pptx.dev/review`, ...). */
+  onChange?: (counts: { error: number; warning: number; info: number; total: number; all: number; sources: string[]; unavailable: boolean }) => void;
   /** Rule ids hidden at the start, and a callback when the author hides or restores a check. */
   ignored?: string[];
   onIgnoredChange?: (ids: string[]) => void;
-  /** Re-audit after every session change (default true). Set false to call `refresh()` yourself, for example after the host's fonts have loaded. */
+  /** Re-check after changes (default true). Set false to call `refresh()` yourself, for example after the host's fonts have loaded. */
   autoRefresh?: boolean;
-  /** Use another audit function instead of core's `auditPresentation`. */
-  audit?: ReviewAuditOptions["audit"];
+  /** Milliseconds the document must be quiet after a change before the full `validate` runs again (default 300). `refresh()` checks at once. */
+  delay?: number;
+  /**
+   * A hosted reviewer: resolves a `FindingReport` whose findings (`source`, for example `pptx.dev/review`) are listed beside core's. It runs when
+   * the author presses its button, or after every re-check with `autoReview`. A finding with no `source` is listed under `review`.
+   */
+  review?: ReviewHook;
+  /** The label of the button that runs the `review` hook (default "Run review"). */
+  reviewLabel?: string;
+  /** Run the `review` hook after every re-check, not only on the button (default false: a hosted review can be slow or metered). */
+  autoReview?: boolean;
 }
 
 export interface ReviewPanel {
   element: HTMLElement;
-  /** The latest findings before the panel's filters and hidden checks. */
+  /** The latest findings before the panel's filters and hidden checks: core's and the hosted reviewer's. */
   readonly findings: ReviewFinding[];
+  /** The merged report (`valid`, `findings`, `counts`, `sources`). */
   readonly report: ReviewReport | undefined;
-  /** Audit the document again and redraw. */
+  /** Core's `validate` report alone, or undefined when it could not run. */
+  readonly validation: import("@openpresentation/opf").ValidationReport | undefined;
+  /** Run core's full check again now and redraw. */
   refresh(): void;
-  /** Redraw without auditing, after the host's slide changed. */
+  /** Check after `delay` milliseconds without another call (a burst of calls checks once). With `autoRefresh: false` the host calls this after each redraw. */
+  schedule(): void;
+  /** Run the `review` hook now; resolves once its findings are listed (or its error is shown). */
+  review(): Promise<void>;
+  /** Redraw without checking, after the host's slide changed. */
   update(): void;
   /** Hide (true) or show again (false) the findings of one rule in this panel. */
   setIgnored(ruleId: string, hidden: boolean): void;
   destroy(): void;
 }
 
-export { auditAvailable, reviewSeverities } from "./review.js";
+export { reviewSeverities } from "./review.js";
 
-/** Mount the Review panel: the audit's findings with go-to, safe quick fixes and live updates as the document changes. */
+/** Mount the Review panel: core's findings by category with go-to and quick fixes, a hosted reviewer's beside them, and updates as the document changes. */
 export declare function createReviewPanel(container: HTMLElement, options: ReviewPanelOptions): ReviewPanel;