@openpresentation/opf-editor 0.14.2 → 0.15.0

package/dist/index.js

@@ -2,15 +2,37 @@ import { paginateSlide } from "@openpresentation/opf/pagination";
 import { OPFPatchError, applyPatch as applyCorePatch, applyPatchWithInverse, formatPointer, invertPatch, jsonEqual, parsePointer, readPointer } from "@openpresentation/opf/patch";
 import { collectReservedPresentationIds } from "./presentation-ids.js";
 import { composeSlide } from "@openpresentation/opf/composition";
-import { catalogKinds, catalogs as bundledCatalogs, resolveSlideContext, stats } from "@openpresentation/opf";
+import { catalogKinds, resolveSlideContext, stats } from "@openpresentation/opf";
 import { checkFormat, errorFindings } from "./checks.js";
+import { forkEditedRecords, forkNotice, listCatalogRecords, mergeCatalogs } from "./catalogs.js";
+
+export {
+  REFERENCE_FINDING_CODES,
+  applyCatalogUpdate,
+  catalogRecordAt,
+  catalogRecordLabel,
+  catalogsFor,
+  checkCatalogUpdates,
+  editedCatalogRecords,
+  FORKED_RECORD_KINDS,
+  forkEditedRecords,
+  forkNotice,
+  listCatalogRecords,
+  mergeCatalogs,
+  moveToCustom,
+  prepareMoveToCustom,
+  prepareSave,
+  referenceFindings,
+  saveDocument,
+} from "./catalogs.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;
+// theme, engine default), with the session's registered catalogs, 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.catalogs`
+// adds catalogs for this call; `options.onDiagnostic` hears each diagnostic (`unresolved-reference`);
 // any other option overrides the resolved one (`layout`, ...).
-function slideContext(presentation, slideIndex, { fonts, catalogs, onDiagnostic, ...overrides } = {}) {
+function slideContext(presentation, slideIndex, catalogs, { fonts, catalogs: _extra, 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);
@@ -123,7 +145,10 @@ export function deckStats(editor, options) {
 
 export function createEditorSession(input, options = {}) {
   let presentation = parseInput(input);
-  let validation = checkFormat(presentation);
+  // The host's registered catalogs (FA-23): one list, handed to every core call, the renderer and the exporter.
+  let catalogs = mergeCatalogs(options.catalogs);
+  const check = (document) => checkFormat(document, { catalogs });
+  let validation = check(presentation);
   const undoStack = [];
   const redoStack = [];
   const listeners = new Set();
@@ -138,7 +163,7 @@ export function createEditorSession(input, options = {}) {
 
   function commitPatch(operations, meta = {}) {
     assertPatchOperations(operations);
-    const patches = operations.map(normalizeOperation);
+    let patches = operations.map(normalizeOperation);
     const before = presentation;
     let next, inversePatches;
     try {
@@ -146,7 +171,24 @@ export function createEditorSession(input, options = {}) {
     } catch (error) {
       throw editorPatchError(error);
     }
-    const nextValidation = checkFormat(next);
+    // Owner rule (FA-23): an edit of a record under catalogs.default or a named group forks it into catalogs.custom (every reference
+    // follows, the original is dropped), in this same undo step. Catalog updates and moves change catalog records on purpose.
+    let forks = [];
+    if (meta.catalogRecordEdit !== "in-place") {
+      const forked = forkEditedRecords(before, next, { catalogs, forkIds: meta.forkIds });
+      if (forked.forks.length) {
+        forks = forked.forks;
+        for (const key of new Set([...Object.keys(next), ...Object.keys(forked.document)]))
+          if (!jsonEqual(next[key], forked.document[key])) patches = [...patches, forked.document[key] === undefined ? { op: "remove", path: formatPointer([key]) } : { op: Object.hasOwn(next, key) ? "replace" : "add", path: formatPointer([key]), value: clone(forked.document[key]) }];
+        try {
+          ({ presentation: next, inverse: inversePatches } = applyPatchWithInverse(before, patches));
+        } catch (error) {
+          throw editorPatchError(error);
+        }
+        meta = { ...meta, forked: forks, notice: forks.map(forkNotice).join(" ") };
+      }
+    }
+    const nextValidation = check(next);
 
     if ((meta.rejectInvalid ?? rejectInvalid) && !nextValidation.valid) {
       throw new OPFEditorError("invalid-opf-edit", "OPF edit produced an invalid document.", {
@@ -174,7 +216,8 @@ export function createEditorSession(input, options = {}) {
       presentation: clone(presentation),
       patches: clonePatchOperations(patches),
       inversePatches: clonePatchOperations(inversePatches),
-      validation
+      validation,
+      ...(forks.length ? { forked: forks, notice: meta.notice } : {})
     };
   }
 
@@ -185,6 +228,20 @@ export function createEditorSession(input, options = {}) {
     get validation() {
       return validation;
     },
+    /** The catalogs the host registered (`Catalog[]`, frozen): the first is the host default. */
+    get catalogs() {
+      return catalogs;
+    },
+    /**
+     * Replace the registered catalogs (for example after the host loads a company catalog). The document is not changed; it is
+     * re-validated against the new list (reference findings depend on it) and one `catalogs` event tells every view to redraw.
+     */
+    setCatalogs(next, meta = {}) {
+      catalogs = mergeCatalogs(next);
+      validation = check(presentation);
+      emit({ type: "catalogs", patches: [], validation, meta });
+      return catalogs;
+    },
     get canUndo() {
       return undoStack.length > 0;
     },
@@ -218,13 +275,15 @@ export function createEditorSession(input, options = {}) {
       });
     },
     composeSlide(slideIndex, options = {}) {
-      return composeSlide(presentation.slides?.[slideIndex], slideContext(presentation, slideIndex, options));
+      return composeSlide(presentation.slides?.[slideIndex], slideContext(presentation, slideIndex, mergeCatalogs(catalogs, options.catalogs), options));
     },
     paginateSlide(slideIndex, options = {}, meta = {}) {
+      const list = mergeCatalogs(catalogs, options.catalogs);
       // Core pagination reads the measurement from `fonts`, so the resolved context hands it over that way.
-      const { textMeasurement, ...resolved } = slideContext(presentation, slideIndex, options);
+      const { textMeasurement, ...resolved } = slideContext(presentation, slideIndex, list, options);
       const pagination = paginateSlide(presentation.slides[slideIndex], {
         ...resolved,
+        catalogs: list,
         fonts: options.fonts ?? (textMeasurement ? { textMeasurement } : undefined),
         reservedIds: collectReservedPresentationIds(presentation),
       });
@@ -267,7 +326,7 @@ export function createEditorSession(input, options = {}) {
     restoreState(state, meta = {}) {
       if (!state || typeof state !== "object") throw new OPFEditorError("invalid-state", "restoreState needs { presentation, undo?, redo? }.");
       const next = parseInput(state.presentation);
-      const nextValidation = checkFormat(next);
+      const nextValidation = check(next);
       if ((meta.rejectInvalid ?? rejectInvalid) && !nextValidation.valid) {
         throw new OPFEditorError("invalid-opf-edit", "The restored document is not valid OPF.", { issues: errorFindings(nextValidation) });
       }
@@ -304,7 +363,7 @@ export function createEditorSession(input, options = {}) {
       const entry = undoStack.pop();
       if (!entry) return null;
       presentation = applyJsonPatch(presentation, entry.inversePatches);
-      validation = checkFormat(presentation);
+      validation = check(presentation);
       redoStack.push(entry);
       emit({
         type: "undo",
@@ -324,7 +383,7 @@ export function createEditorSession(input, options = {}) {
       const entry = redoStack.pop();
       if (!entry) return null;
       presentation = applyJsonPatch(presentation, entry.patches);
-      validation = checkFormat(presentation);
+      validation = check(presentation);
       undoStack.push(entry);
       emit({
         type: "redo",
@@ -415,29 +474,29 @@ export function createSvgTraceBinding(root, editor, options = {}) {
   };
 }
 
+/**
+ * The records a catalog control can offer for `catalogKind`, from core's `catalogRecords`: the document's embedded records,
+ * then the registered catalogs' (`options.catalogs`, merged with `options.editor`'s). Each is the record itself.
+ */
 export function getCatalogRecords(catalogKind, options = {}) {
-  assertCatalogKind(catalogKind);
-  const presentationCatalog = options.presentation?.catalogs?.[catalogKind];
-  const explicitCatalog = options.catalogs?.[catalogKind] ?? options.catalogSources?.[catalogKind];
-
-  return firstRecords(presentationCatalog)
-    ?? firstRecords(explicitCatalog)
-    ?? firstRecords(bundledCatalogs[catalogKind])
-    ?? [];
+  return getCatalogOptions(catalogKind, options).map((option) => option.record);
 }
 
+/**
+ * Picker options for `catalogKind`: `{ id, reference, label, record, group, source, origin }`, where `id` (= `reference`) is the
+ * reference to write, `id` or `name:id`. `options.presentation` is the document (default: `options.editor`'s), `options.catalogs`
+ * the host catalogs (merged after the session's registered ones).
+ */
 export function getCatalogOptions(catalogKind, options = {}) {
-  return getCatalogRecords(catalogKind, options).map((record) => ({
-    id: record.id,
-    label: catalogLabel(record),
-    record
-  }));
+  assertCatalogKind(catalogKind);
+  const presentation = options.presentation ?? options.editor?.presentation ?? {};
+  return listCatalogRecords(presentation, catalogKind, { catalogs: mergeCatalogs(options.editor?.catalogs, options.catalogs) });
 }
 
 export function assertCatalogId(catalogKind, id, options = {}) {
   assertCatalogKind(catalogKind);
   if (typeof id !== "string" || id.length === 0) {
-    throw new OPFEditorError("invalid-catalog-id", "Catalog control values must be non-empty catalog IDs.", {
+    throw new OPFEditorError("invalid-catalog-id", "Catalog control values must be non-empty catalog references.", {
       catalogKind,
       id
     });
@@ -445,7 +504,7 @@ export function assertCatalogId(catalogKind, id, options = {}) {
 
   const optionsById = new Set(getCatalogOptions(catalogKind, options).map((option) => option.id));
   if (!optionsById.has(id)) {
-    throw new OPFEditorError("unknown-catalog-id", `Unknown ${catalogKind} catalog ID: ${id}.`, {
+    throw new OPFEditorError("unknown-catalog-id", `Unknown ${catalogKind} catalog reference: ${id}.`, {
       catalogKind,
       id
     });
@@ -454,16 +513,16 @@ export function assertCatalogId(catalogKind, id, options = {}) {
   return id;
 }
 
+/** Write the catalog reference `id` at `path` (an object reference keeps its overrides and takes the new `id`). */
 export function setCatalogId(editor, path, catalogKind, id, meta = {}) {
   assertEditorSession(editor);
   const catalogId = assertCatalogId(catalogKind, id, {
     presentation: meta.presentation ?? editor.presentation,
-    catalogs: meta.catalogs,
-    catalogSources: meta.catalogSources
+    catalogs: mergeCatalogs(editor.catalogs, meta.catalogs)
   });
   const current = editor.get(path);
   const value = catalogReferenceValue(current, catalogId);
-  const { catalogs, catalogSources, presentation, ...commitMeta } = meta;
+  const { catalogs: _catalogs, presentation: _presentation, ...commitMeta } = meta;
   return editor.set(path, value, {
     ...commitMeta,
     catalogKind,
@@ -517,7 +576,7 @@ export function createCatalogSelect(editor, options) {
   if (options?.label) select.setAttribute("aria-label", options.label);
 
   for (const option of getCatalogOptions(catalogKind, {
-    ...options,
+    catalogs: mergeCatalogs(editor.catalogs, options?.catalogs),
     presentation: options?.presentation ?? editor.presentation
   })) {
     const optionElement = documentRef.createElement("option");
@@ -533,7 +592,6 @@ export function createCatalogSelect(editor, options) {
   const onChange = () => {
     setCatalogId(editor, path, catalogKind, select.value, {
       catalogs: options?.catalogs,
-      catalogSources: options?.catalogSources,
       presentation: options?.presentation,
       source: "catalog-select"
     });
@@ -677,20 +735,6 @@ function assertCatalogKind(catalogKind) {
   }
 }
 
-function firstRecords(value) {
-  if (Array.isArray(value)) return value.filter(isCatalogRecord);
-  if (Array.isArray(value?.records)) return value.records.filter(isCatalogRecord);
-  return null;
-}
-
-function isCatalogRecord(record) {
-  return Boolean(record && typeof record === "object" && typeof record.id === "string");
-}
-
-function catalogLabel(record) {
-  return String(record.name ?? record.title ?? record.label ?? record.id);
-}
-
 function catalogReferenceValue(current, id) {
   if (current && typeof current === "object" && !Array.isArray(current)) {
     return { ...current, id };

package/dist/json-editor.js

@@ -103,7 +103,7 @@ function skipDelimiter(view, delimiter) {
 }
 function mountJsonCodeEditor(parent, options) {
   const attributes = new Compartment(), indent = new Compartment();
-  let disposed=false, menu=null, catalogs=options.catalogs??{}, generation=0;
+  let disposed=false, menu=null, catalogs=options.catalogs??[], generation=0;
   function closeOptions(){generation++;menu?.destroy();menu=null;}
   async function openOptions(left,top){
     closeOptions();
@@ -244,7 +244,7 @@ function mountJsonCodeEditor(parent, options) {
   return {
     api,
     openOptions,
-    setCatalogs(value){catalogs=value??{};closeOptions();},
+    setCatalogs(value){catalogs=value??[];closeOptions();},
     update(code, invalid=false, field=null, describedBy) {
       if(code!==api.getValue())closeOptions();
       const current = view.state.doc.toString(), normalized=textInputMap(code).text;

package/dist/json-menu.js

@@ -26,9 +26,9 @@ export function mountJsonFieldMenu(parent,api,catalogs,left,top,onClose){
   const error=add('p',undefined,'json-field-empty');error.setAttribute('role','alert');error.hidden=true;
   if(isLayout){
     const help=add('details',undefined,'json-field-catalog-help');add('summary','Where do these layouts come from?',undefined,help);
-    add('p','Standard OPF: included with OPF. Provided by app: extra records supplied by the host app. In this document: records in your JSON, which override matching IDs. External galleries are not automatically loaded.',undefined,help);
+    add('p','Provided by app: records from the catalogs the host app registered. In this document: records embedded in your JSON, which take precedence. Nothing is fetched; saving embeds every record the document uses.',undefined,help);
   }
-  add('p',context.unloadedSource?'Using available records. External catalog URLs are not loaded here.':'Choose an option or press Escape to keep editing JSON.','json-field-footnote');
+  add('p',context.unloadedSource?'Using the embedded records: a catalog this document names is not registered here.':'Choose an option or press Escape to keep editing JSON.','json-field-footnote');
   let selected=Math.max(0,context.options.findIndex(option=>option.value===context.value)),choices=[],disposed=false;
   function close(restore=false){if(disposed)return;disposed=true;observer.disconnect();root.remove();doc.removeEventListener('pointerdown',outside);doc.removeEventListener('wheel',outside,true);doc.removeEventListener('touchmove',outside,true);win.removeEventListener('resize',resize);onClose();if(restore){api.focus();api.setSelection(...selection);}}
   function outside(event){if(!root.contains(event.target))close();}

package/dist/json-options.d.ts

@@ -1,11 +1,11 @@
-/** Already-loaded catalog records by kind. No remote catalog URLs are fetched. */
-export type JsonCatalogContext = Readonly<Record<string, readonly Record<string, unknown>[]>>;
+/** The host's catalogs (core `Catalog[]`): records offered after the document's embedded ones. */
+export type JsonCatalogContext = readonly import("@openpresentation/opf").Catalog[];
 export type JsonOptionValue = string | number | boolean;
 export interface JsonFieldOption {
   value: JsonOptionValue;
   label: string;
   description?: string;
-  source: 'Built-in catalog' | 'Loaded catalog' | 'Document catalog' | 'Schema' | 'Current value';
+  source: 'Loaded catalog' | 'Document catalog' | 'Schema' | 'Current value';
   suggested?: boolean;
   /** User-facing provenance; source remains stable for existing consumers. */
   sourceLabel?: string;

package/dist/json-options.js

@@ -1,12 +1,23 @@
-import { catalogKinds, catalogSchemaNames, schemas, validateCatalogRecord } from "@openpresentation/opf";
 import { checkFormat, firstErrorMessage } from "./checks.js";
-import { getCatalogOptions } from "./index.js";
+import { listCatalogRecords } from "./catalogs.js";
 import { schemaAtPath, schemaVariants } from "./schema.js";
 import { applyEdits, findNodeAtLocation, findNodeAtOffset, getNodePath, modify, parseTree } from "jsonc-parser";
 import { populateLayoutPlaceholders } from "./layout-placeholders.js";
-function catalogFor(description) {
-    return catalogKinds.find(kind => description.includes(`catalogs.${kind}`)
-        || new RegExp(`\\b${kind}['’]? catalog`).test(description));
+// The catalog kind a field references (OPF 0.15: every content kind is `id` or `name:id`), read from where the field sits.
+const ROOT_REFERENCES = { narrative: "narratives", audience: "audiences", purpose: "purposes", tone: "tones" };
+const DESIGN_REFERENCES = { theme: "themes", colorScheme: "colorSchemes", fontScheme: "fontSchemes" };
+function catalogAtPath(path) {
+    const parts = path.map(String);
+    // A reference's object form names its record with `id`; an audience array's entries are references too.
+    const field = parts.at(-1) === "id" ? parts.slice(0, -1) : parts;
+    const tail = /^\d+$/.test(field.at(-1) ?? "") && field.at(-2) === "audience" ? field.slice(0, -1) : field;
+    const key = tail.at(-1);
+    if (tail.length === 3 && tail[0] === "slides" && key === "layout") return "layouts";
+    if (tail.length === 1 && ROOT_REFERENCES[key]) return ROOT_REFERENCES[key];
+    if (DESIGN_REFERENCES[key] && ((tail.length === 2 && tail[0] === "design") || (tail.length === 4 && tail[0] === "slides" && tail[2] === "design"))) return DESIGN_REFERENCES[key];
+    // Inside an embedded record: a theme's colour or font scheme.
+    if (tail.length === 5 && tail[0] === "catalogs" && tail[2] === "themes" && (key === "colorScheme" || key === "fontScheme")) return DESIGN_REFERENCES[key];
+    return undefined;
 }
 // Compare declared placeholders, including multiplicity. This describes a layout
 // contract, not a claim that arbitrary slide content will render without overflow.
@@ -28,9 +39,8 @@ function placeholderSummary(types) {
     }).join(" + ");
 }
 const sourceDetails = {
-    "Built-in catalog": ["Standard OPF", "Included with OPF and available offline."],
-    "Loaded catalog": ["Provided by app", "Additional records supplied to the preview by this app; these are not fetched from a URL."],
-    "Document catalog": ["In this document", "Defined in this document’s catalogs. Takes precedence over app and standard records with the same ID."],
+    "Loaded catalog": ["Provided by app", "Records from a catalog this app registered; nothing is fetched from a URL. Saving embeds the record in the document."],
+    "Document catalog": ["In this document", "Embedded in this document’s catalogs. Takes precedence over the app’s records with the same reference."],
     "Current value": ["Custom value", "The current value is not in the available catalogs."],
     "Schema": ["OPF option", "Allowed by the OPF schema."],
 };
@@ -64,7 +74,7 @@ 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 = {}) {
+export function getJsonFieldContext(source, position, loadedCatalogs = []) {
     let presentation;
     try {
         presentation = JSON.parse(source);
@@ -87,42 +97,21 @@ export function getJsonFieldContext(source, position, loadedCatalogs = {}) {
         return null;
     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(presentation, path.slice(0, -1).map(String)).description ?? ""));
+    const catalog = catalogAtPath(path);
     const options = new Map();
     const records = new Map();
-    let unloadedSource = false;
+    // A document group whose source no registered catalog matches: its records beyond the embedded ones are not available here.
+    const registered = new Set((Array.isArray(loadedCatalogs) ? loadedCatalogs : []).map(entry => entry?.source));
+    const unloadedSource = Boolean(catalog) && Object.entries(presentation.catalogs ?? {}).some(([name, group]) => name !== "custom" && group && typeof group === "object" && typeof group.source === "string" && !registered.has(group.source));
     if (catalog && typeof node.value === "string") {
-        const entries = presentation.catalogs;
-        const local = entries?.[catalog];
-        unloadedSource = Boolean(local?.source);
-        for (const option of getCatalogOptions(catalog)) {
+        const hostCatalogs = Array.isArray(loadedCatalogs) ? loadedCatalogs : [];
+        // A draft whose own catalogs are malformed still offers the host's records; a malformed host list offers nothing.
+        const attempt = (document) => { try { return listCatalogRecords(document, catalog, { catalogs: hostCatalogs }); } catch { return undefined; } };
+        const available = attempt(presentation) ?? attempt({ ...presentation, catalogs: undefined }) ?? [];
+        for (const option of available) {
             records.set(option.id, option.record);
-            options.set(option.id, { value: option.id, label: option.label, description: typeof option.record.description === "string" ? option.record.description : undefined,
-                source: "Built-in catalog" });
-        }
-        for (const { value, source } of [...(Array.isArray(loadedCatalogs?.[catalog]) ? loadedCatalogs[catalog] : []).map(value => ({ value, source: "Loaded catalog" })),
-            ...(Array.isArray(local?.records) ? local.records : []).map(value => ({ value, source: "Document catalog" }))]) {
-            if (!value || typeof value !== "object")
-                continue;
-            const record = value;
-            if (typeof record.id !== "string")
-                continue;
-            // Inline records may omit the standalone document's $schema marker.
-            // Supply it only for validation; never change the authored record.
-            const schemaId = schemas[catalogSchemaNames[catalog]].$id;
-            if (!validateCatalogRecord(catalog, { $schema: schemaId, ...record }).valid) {
-                options.delete(record.id);
-                records.delete(record.id);
-                continue;
-            }
-            records.set(record.id, record);
-            options.set(record.id, { value: record.id, label: typeof record.name === "string" ? record.name : record.id,
-                description: typeof record.description === "string" ? record.description : undefined,
-                source });
+            options.set(option.id, { value: option.id, label: option.label, description: option.description,
+                source: option.origin === "document" ? "Document catalog" : "Loaded catalog" });
         }
     }
     else {

package/dist/react.js

@@ -62,7 +62,7 @@ export function createOPFReactComponents(React) {
     const snapshot = useEditorSnapshot(editor);
     const value = getValueAtPath(snapshot.presentation, path, "");
     const currentId = value && typeof value === "object" ? value.id : value;
-    const options = catalogOptions ?? getCatalogOptions(catalogKind, { presentation: snapshot.presentation });
+    const options = catalogOptions ?? getCatalogOptions(catalogKind, { presentation: snapshot.presentation, catalogs: editor.catalogs });
 
     return React.createElement(
       "select",

package/dist/review-panel.js

@@ -6,6 +6,7 @@
 // document state: every fix is an undoable edit through the editor session. Importing this module does not need a DOM;
 // mounting does.
 import { validate } from "@openpresentation/opf";
+import { mergeCatalogs } from "./catalogs.js";
 import {
   applyReviewFix,
   countFindings,
@@ -115,6 +116,11 @@ function summaryText(counts, scopeLabel) {
  */
 export function createReviewPanel(container, options) {
   const { editor, getSlideIndex, getValidateOptions, onGoTo, onFocusField, onStatus, onIgnoredChange, onChange, review } = options;
+  // Core resolves the deck's references with the session's registered catalogs (and any the host adds): the same list as the preview.
+  const validateOptions = () => {
+    const host = getValidateOptions?.(editor.presentation) ?? {};
+    return { ...host, catalogs: mergeCatalogs(editor.catalogs, host.catalogs) };
+  };
   if (review !== undefined && typeof review !== "function") throw new TypeError("The Review panel's review hook must be a function (presentation, options) returning a FindingReport.");
   if (!editor || typeof editor.subscribe !== "function") throw new Error("The Review panel needs an editor session created by createEditorSession.");
   const doc = container.ownerDocument;
@@ -171,7 +177,7 @@ export function createReviewPanel(container, options) {
   function validateNow() {
     lastAuditError = undefined;
     try {
-      coreReport = validate(editor.presentation, getValidateOptions?.(editor.presentation) ?? {});
+      coreReport = validate(editor.presentation, validateOptions());
     } catch (error) {
       coreReport = undefined;
       lastAuditError = error;
@@ -204,7 +210,7 @@ export function createReviewPanel(container, options) {
     if (!coreReport && !lastAuditError) validateNow();
     renderList();
     try {
-      const result = await review(editor.presentation, { signal: controller.signal, report: coreReport, validateOptions: getValidateOptions?.(editor.presentation) ?? {} });
+      const result = await review(editor.presentation, { signal: controller.signal, report: coreReport, validateOptions: validateOptions() });
       if (destroyed || hookRunning !== running) return;
       if (!result || !Array.isArray(result.findings)) throw new TypeError("The review hook must resolve a FindingReport ({ valid, findings, counts }).");
       hookRunning = undefined;

package/dist/schema-inspector.js

@@ -18,7 +18,7 @@ export function createSchemaInspector(container, {editor,path='',onDraft,onCommi
   function showError(message){errorBox.textContent=message;}
   function check(){
     // The draft must be valid OPF (the format category, as every edit); unresolved references (an unknown variable, a missing asset) are listed as notes.
-    const report=validate(draft,{only:['format','references']});
+    const report=validate(draft,{only:['format','references'],...(editor?.catalogs?.length?{catalogs:editor.catalogs}:{})});
     const errors=report.findings.filter(finding=>finding.severity==='error'&&finding.category==='format'),warnings=report.findings.filter(finding=>finding.category!=='format'&&finding.severity!=='info');
     const validation={valid:!errors.length};
     apply.disabled=!dirty||!validation.valid;

package/dist/schema.js

@@ -69,7 +69,7 @@ export function schemaAtPath(presentation, path, root = schemas.presentation) {
   const parts=splitOpfPath(path);let current=root,value=presentation;
   for(let index=0; index<parts.length;index++) {
     const key=parts[index], resolved=activeSchema(current,value,root);
-    if(parts[0]==='catalogs' && parts[2]==='records' && index===3) current=schemas[catalogSchemaNames[parts[1]]]??{};
+    if(parts[0]==='catalogs' && index===3 && catalogSchemaNames[parts[2]]) current=schemas[catalogSchemaNames[parts[2]]]??{};
     else current=Array.isArray(value)||resolved.type==='array' ? resolved.items??{} : resolved.properties?.[key] ?? Object.entries(resolved.patternProperties??{}).find(([pattern])=>new RegExp(pattern).test(key))?.[1] ?? (typeof resolved.additionalProperties==='object'?resolved.additionalProperties:{});
     value=value?.[key];
   }

package/dist/slide-manager.js

@@ -482,7 +482,7 @@ export function createSlideManager(container, options) {
     });
   }
   function layoutChoices() {
-    return options.layoutOptions ? options.layoutOptions(deck()) : listSwitchOptions(deck(), "layouts");
+    return options.layoutOptions ? options.layoutOptions(deck()) : listSwitchOptions(deck(), "layouts", { catalogs: editor.catalogs });
   }
   function openLayoutPicker() {
     const choices = layoutChoices();

package/dist/slides.d.ts

@@ -48,7 +48,7 @@ export type MoveSectionMode = "adopt" | "keep" | string | null;
 export interface AddSlideOptions {
   /** The index the slide takes (default: the end). */
   at?: number;
-  /** A layouts catalog id; the layout's placeholders are added as empty slots. */
+  /** A layout reference (`id` or `name:id`); the layout's placeholders are added as empty slots. */
   layout?: string;
   title?: string;
   text?: string;

package/dist/slides.js

@@ -11,6 +11,7 @@
 import { checkedDocument, fail, same } from "./edit-helpers.js";
 import { collectReservedPresentationIds, remapSlideTreeIds } from "./presentation-ids.js";
 import { prepareDimensionSwitch } from "./switches.js";
+import { mergeCatalogs } from "./catalogs.js";
 import { checkFormat } from "./checks.js";
 
 const isIndex = (value) => Number.isInteger(value) && value >= 0;
@@ -130,10 +131,10 @@ function newSlideId(presentation) {
 }
 
 /**
- * Compute adding a slide. Options: `at` (the index the slide takes, default the end), `layout` (a layouts
- * catalog id; the layout's placeholders are added as empty slots, exactly like switching a slide's layout),
+ * Compute adding a slide. Options: `at` (the index the slide takes, default the end), `layout` (a layout
+ * reference, `id` or `name:id`; the layout's placeholders are added as empty slots, exactly like switching a slide's layout),
  * `title`, `text`, `id`, `section` (default: the section of the slide before it), `slide` (a ready slide to
- * insert, for hosts that build their own), `catalogs`/`record` for catalog lookup (as `prepareDimensionSwitch`).
+ * insert, for hosts that build their own), `catalogs`/`record`/`recordSource` for catalog lookup (as `prepareDimensionSwitch`).
  */
 export function prepareAddSlide(presentation, options = {}) {
   const slides = requireSlides(presentation);
@@ -153,7 +154,7 @@ export function prepareAddSlide(presentation, options = {}) {
     // Switch the layout on a scratch copy to reuse the placeholder rules and the catalog lookup.
     const scratch = { ...clone(presentation), slides: [...clone(slides)] };
     scratch.slides.splice(at, 0, slide);
-    const switched = prepareDimensionSwitch(scratch, "layouts", options.layout, { slideIndex: at, catalogs: options.catalogs, record: options.record });
+    const switched = prepareDimensionSwitch(scratch, "layouts", options.layout, { slideIndex: at, catalogs: options.catalogs, record: options.record, recordSource: options.recordSource });
     const catalogOps = switched.patches.filter((patch) => !patch.path.startsWith("/slides/"));
     slide = switched.presentation.slides[at];
     const patches = [...catalogOps, { op: "add", path: slidePointer(at), value: slide }];
@@ -164,7 +165,7 @@ export function prepareAddSlide(presentation, options = {}) {
 /** Add a slide (see `prepareAddSlide`) as one undoable step. The change reports `index`, `id` and `selection`. */
 export function addSlide(editor, options = {}, meta) {
   requireEditor(editor);
-  return apply(editor, prepareAddSlide(editor.presentation, options), meta, "add");
+  return apply(editor, prepareAddSlide(editor.presentation, { ...options, catalogs: mergeCatalogs(editor.catalogs, options.catalogs) }), meta, "add");
 }
 
 // --- duplicate -------------------------------------------------------------------------------------

package/dist/svelte.js

@@ -50,8 +50,8 @@ export function opfCatalogSelect(node, params) {
     node.setAttribute?.("data-opf-catalog-kind", catalogKind);
     if (label) node.setAttribute?.("aria-label", label);
     replaceOptions(node, getCatalogOptions(catalogKind, {
+      editor,
       catalogs: nextParams.catalogs,
-      catalogSources: nextParams.catalogSources,
       presentation: nextParams.presentation ?? editor.presentation
     }));
 
@@ -61,7 +61,6 @@ export function opfCatalogSelect(node, params) {
     };
     const onChange = () => setCatalogId(editor, path, catalogKind, node.value, {
       catalogs: nextParams.catalogs,
-      catalogSources: nextParams.catalogSources,
       presentation: nextParams.presentation,
       source: "svelte-catalog-select"
     });