@openpresentation/opf 0.14.0 → 0.16.0

package/dist/{chunk-JDJBDYSR.js → chunk-PX5AWL7Y.js}

@@ -1,6 +1,7 @@
-import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, tableGrid, timelineTextColor, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveFontSchemeReference, DEFAULT_FONT_SCHEME, resolveColorRoles, resolveFontFamilies, resolveCanvasDimensions, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, bareIdPattern, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, OPFCompositionError, composeSlide, resolveScriptFonts } from './chunk-6OXY2CP3.js';
-import { catalogs, catalogKinds, catalogEntries, catalogSchemaNames, themes } from './chunk-XOZ4KMSR.js';
-import { schemaEntries, schemas } from './chunk-LS2FMPI5.js';
+import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, imageBackground, tableGrid, timelineTextColor, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, textWidthMeasurer, normalizeHexColor, resolveColorRef, resolveDesignRecords, resolveColorRoles, resolveFontFamilies, resolveCanvasDimensions, defaultSlideBackground, isRecord, hasContentVariables, isTemplate, instantiateForValidation, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, MAX_PLACEHOLDER_GROUP_DEPTH, OPFCompositionError, composeSlide, resolveScriptFonts } from './chunk-5PDN7BN6.js';
+import { catalogSchemaNames } from './chunk-TRDXRRQK.js';
+import { resolveReference, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, catalogRecords, catalogKinds, catalogGroupSource, registeredCatalog } from './chunk-SPFV27O5.js';
+import { schemaEntries, schemas } from './chunk-WEDGVC5W.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
@@ -71,450 +72,6 @@ function unusedReferenceWarnings(value) {
   return value.references.flatMap((reference, index) => isRecord(reference) && typeof reference.id === "string" && unused.includes(reference.id) ? [issue(`/references/${index}`, `reference '${reference.id}' is never cited; cite it with a run's cite field or remove it`, { code: "unused-reference", id: reference.id })] : []);
 }
 
-// src/generated/catalog-ids.ts
-var catalogIds = {
-  audiences: [
-    "board",
-    "engineering-team",
-    "all-hands",
-    "candidates",
-    "executive",
-    "investor",
-    "technical",
-    "sales",
-    "marketing",
-    "academic",
-    "internal-team",
-    "customer",
-    "general-public",
-    "media",
-    "partner",
-    "regulatory"
-  ],
-  purposes: [
-    "inform",
-    "decide",
-    "align",
-    "persuade",
-    "educate",
-    "report",
-    "pitch",
-    "sell",
-    "plan"
-  ],
-  tones: [
-    "formal",
-    "casual",
-    "inspirational",
-    "technical",
-    "persuasive",
-    "authoritative",
-    "conversational"
-  ],
-  themes: [
-    "minimal",
-    "classic",
-    "dark",
-    "bold"
-  ],
-  layouts: [
-    "blank",
-    "chart-1x",
-    "chart-2x",
-    "chart-3x",
-    "code-1x",
-    "image-1x",
-    "image-2x",
-    "image-3x",
-    "image-bleed",
-    "list-1x",
-    "list-2x",
-    "list-3x",
-    "list-4x",
-    "list-5x",
-    "list-6x",
-    "media-1x",
-    "number-1x",
-    "number-2x",
-    "number-3x",
-    "number-4x",
-    "number-5x",
-    "number-6x",
-    "quote-1x",
-    "table-1x",
-    "text-1x",
-    "text-2x",
-    "text-3x",
-    "timeline-1x",
-    "title",
-    "title-subtitle",
-    "title-slide",
-    "two-column",
-    "image-focus",
-    "data-visualization",
-    "quote-highlight",
-    "section-divider",
-    "agenda",
-    "thank-you-cta",
-    "bullet-list",
-    "three-column",
-    "icon-grid",
-    "faq",
-    "stats-metrics",
-    "comparison",
-    "swot-analysis",
-    "matrix-quadrant",
-    "funnel-pyramid",
-    "timeline",
-    "process-flow",
-    "photo-grid",
-    "before-after",
-    "testimonial-grid",
-    "team-bio",
-    "pricing-table",
-    "roadmap",
-    "product-feature",
-    "executive-summary",
-    "key-takeaway",
-    "chapter-recap",
-    "qa-discussion",
-    "single-message-statement",
-    "one-column-explainer",
-    "case-study",
-    "pros-cons",
-    "feature-comparison-matrix",
-    "venn-overlap",
-    "decision-tree",
-    "kpi-scorecard",
-    "dashboard",
-    "waterfall-bridge",
-    "benchmark-target-table",
-    "heatmap-cohort",
-    "risk-heatmap",
-    "forecast-scenario",
-    "swimlane-process",
-    "gantt-project-plan",
-    "circular-lifecycle",
-    "customer-journey",
-    "org-chart",
-    "capability-map",
-    "logic-tree",
-    "hub-and-spoke",
-    "architecture-stack",
-    "ecosystem-map",
-    "network-dependency-map",
-    "wheel-radial",
-    "geographic-map",
-    "screenshot-walkthrough",
-    "market-size",
-    "persona-grid",
-    "competitive-landscape",
-    "business-model-canvas",
-    "customer-logos",
-    "executive-decision",
-    "status-rag",
-    "raci-matrix",
-    "action-plan",
-    "assumptions-dependencies",
-    "appendix-index",
-    "detailed-data-table"
-  ],
-  chartTypes: [
-    "100pct-stacked-area",
-    "100pct-stacked-bar",
-    "100pct-stacked-column",
-    "area",
-    "bar",
-    "box-and-whisker",
-    "column",
-    "combo",
-    "doughnut",
-    "filled-radar",
-    "funnel",
-    "histogram",
-    "line",
-    "line-with-markers",
-    "pareto",
-    "pie",
-    "radar",
-    "radar-with-markers",
-    "scatter",
-    "stacked-area",
-    "stacked-bar",
-    "stacked-column",
-    "stacked-line",
-    "stacked-line-with-markers",
-    "treemap",
-    "waterfall",
-    "world"
-  ],
-  narratives: [
-    "problem-solution",
-    "scqa",
-    "pyramid-principle",
-    "situation-complication-resolution",
-    "what-so-what-now-what",
-    "strategic-narrative",
-    "golden-circle",
-    "conference-talk",
-    "transformation-arc",
-    "pitch-deck",
-    "early-startup-pitch",
-    "venture-pitch",
-    "persuasive-sales",
-    "sparkline",
-    "company-intro",
-    "marketing-strategy",
-    "product-launch",
-    "strategic-advisory",
-    "challenge-resolution",
-    "project-proposal",
-    "vision-roadmap",
-    "failure-analysis",
-    "star-method",
-    "classic-story",
-    "heros-journey",
-    "business-narrative",
-    "change-story",
-    "rags-to-riches",
-    "underdog-victory",
-    "survival-story",
-    "educate",
-    "persuade",
-    "reveal",
-    "justice",
-    "innovation",
-    "focus",
-    "qbr",
-    "business-review",
-    "board-meeting",
-    "weekly-progress",
-    "status-update",
-    "performance-review",
-    "survey-analysis",
-    "trend-analysis",
-    "data-story",
-    "employee-review",
-    "performance-improvement-plan",
-    "capacity-planning"
-  ],
-  socialPlatforms: [
-    "linkedin",
-    "x",
-    "github",
-    "youtube",
-    "instagram",
-    "facebook",
-    "tiktok",
-    "threads",
-    "mastodon",
-    "bluesky"
-  ],
-  languages: [
-    "afrikaans",
-    "albanian",
-    "amharic",
-    "arabic",
-    "armenian",
-    "aymara",
-    "azerbaijani",
-    "bengali",
-    "berber-latin",
-    "bosnian-latin",
-    "bulgarian",
-    "catalan",
-    "cebuano",
-    "chinese-simplified",
-    "chinese-traditional",
-    "chittagonian",
-    "croatian",
-    "czech",
-    "danish",
-    "dutch",
-    "english",
-    "english-au",
-    "english-ca",
-    "english-gb",
-    "english-in",
-    "english-us",
-    "estonian",
-    "filipino",
-    "finnish",
-    "french",
-    "fulfulde",
-    "galician",
-    "georgian",
-    "german",
-    "greek",
-    "gujarati",
-    "hausa",
-    "hebrew",
-    "hindi",
-    "hungarian",
-    "igbo",
-    "indonesian",
-    "italian",
-    "japanese",
-    "kannada",
-    "kazakh",
-    "khmer",
-    "kinyarwanda",
-    "korean",
-    "kurmanji",
-    "latvian",
-    "lithuanian",
-    "macedonian",
-    "malagasy",
-    "malay",
-    "malayalam",
-    "maori",
-    "marathi",
-    "mongolian",
-    "nepali",
-    "norwegian",
-    "odia",
-    "oromo",
-    "pashto",
-    "persian",
-    "polish",
-    "portuguese",
-    "punjabi-gurmukhi",
-    "punjabi-shahmukhi",
-    "romanian",
-    "russian",
-    "serbian-cyrillic",
-    "serbian-latin",
-    "shona",
-    "slovak",
-    "slovenian",
-    "somali",
-    "spanish",
-    "swahili",
-    "swedish",
-    "tagalog",
-    "tajik",
-    "tamil",
-    "telugu",
-    "thai",
-    "turkish",
-    "ukrainian",
-    "urdu",
-    "uzbek-latin",
-    "vietnamese-quoc-ngu",
-    "xhosa",
-    "yoruba",
-    "zulu"
-  ],
-  colorSchemes: [
-    "black-and-white",
-    "bold-red",
-    "boost",
-    "burnt-orange",
-    "cool-horizon",
-    "corporate-blue",
-    "deep-purple",
-    "forest-green",
-    "golden-yellow",
-    "luxury",
-    "pastel-red",
-    "slate-gray",
-    "steel-blue",
-    "vibes"
-  ],
-  fontSchemes: [
-    "consolas",
-    "courier-new",
-    "arial",
-    "calibri",
-    "impact",
-    "lucida-sans",
-    "segoe-ui",
-    "segoe-ui-light",
-    "tahoma",
-    "trebuchet-ms",
-    "verdana",
-    "bookman",
-    "century-schoolbook",
-    "constantia",
-    "garamond",
-    "rockwell",
-    "times-new-roman",
-    "aptos",
-    "grandview",
-    "seaford",
-    "skeena",
-    "tenorite",
-    "georgia",
-    "microsoft-yahei",
-    "simsun",
-    "fangsong",
-    "yu-gothic",
-    "pmingliu",
-    "mingliu",
-    "ms-mincho",
-    "malgun-gothic",
-    "batang",
-    "gungsuh",
-    "mangal",
-    "nirmala-ui",
-    "latha",
-    "david",
-    "miriam",
-    "gisha",
-    "vrinda",
-    "shruti",
-    "tunga",
-    "kartika",
-    "kalinga",
-    "raavi",
-    "gautami",
-    "arabic-typesetting",
-    "microsoft-jhenghei",
-    "meiryo",
-    "angsana-new",
-    "aparajita",
-    "dilleniaupc",
-    "sakkal-majalla",
-    "shonar-bangla",
-    "sylfaen",
-    "traditional-arabic",
-    "montserrat",
-    "open-sans",
-    "poppins",
-    "pt-serif",
-    "raleway",
-    "roboto",
-    "noto-sans-arabic",
-    "noto-sans-armenian",
-    "noto-sans-bengali",
-    "noto-sans-devangari",
-    "noto-sans-georgian",
-    "noto-sans-gujarati",
-    "noto-sans-gurmukhi",
-    "noto-sans-hebrew",
-    "noto-sans-jp",
-    "noto-sans-kannada",
-    "noto-sans-kr",
-    "noto-sans-malayalam",
-    "noto-sans-mongolian",
-    "noto-sans-oriya",
-    "noto-sans-sc",
-    "noto-sans-tamil",
-    "noto-sans-tc",
-    "noto-sans-telugu",
-    "noto-sans",
-    "noto-sans-thai",
-    "noto-nastaliq-urdu",
-    "noto-naksh-arabic",
-    "noto-sans-ethiopic",
-    "noto-sans-khmer",
-    "nyala",
-    "daunpenh",
-    "khmer-ui"
-  ]
-};
-var deprecatedCatalogIds = {};
-
 // src/validation-definitions.ts
 var schemaLocations;
 var issueLocations = /* @__PURE__ */ new WeakMap();
@@ -618,6 +175,7 @@ var contentKindSpecs = {
   }
 };
 var captionableKinds = /* @__PURE__ */ new Set(["image", "chart", "table", "video"]);
+var imageOptionFields = ["fit", "focus", "aspectRatio", "shape", "cornerRadius", "border", "opacity", "recolor", "overlay", "placement"];
 var columnSpans = {
   left: [0],
   center: [1],
@@ -733,15 +291,31 @@ function validateContentPayload(value, path, options = {}) {
   const payloadFields = presentFields(value, rootPayloadFields);
   const hasBlocks = hasOwn(value, "blocks");
   const captionIssue = (reason, params = {}) => semanticIssue(pathFor(path, "caption"), `caption is only valid on an image, chart, table or video payload; ${reason}`, { code: "caption-unsupported-payload", ...params });
+  const imageOptionIssues = (reason, params = {}) => {
+    for (const field of imageOptionFields) if (hasOwn(value, field)) issues.push(semanticIssue(pathFor(path, field), `${field} is only valid on an image payload; ${reason}`, { code: "image-option-unsupported-payload", field, ...params }));
+  };
+  if (hasOwn(value, "placement") && !options.topLevel && !hasBlocks && explicitType !== "group" && inferredKinds(value).includes("image")) {
+    issues.push(semanticIssue(pathFor(path, "placement"), "placement is only valid on a top-level block (slides.N.blocks.I); a block inside a group or a promoted region cannot bleed to a slide edge", { code: "image-placement-invalid" }));
+  }
   if (hasBlocks || explicitType === "group") {
     if (hasOwn(value, "caption")) issues.push(captionIssue("a group cannot carry one"));
+    imageOptionIssues("a group cannot carry them");
     if (explicitType !== void 0 && explicitType !== "group") issues.push(semanticIssue(path, "a group must use type 'group' or omit type"));
     const incompatible2 = payloadFields.filter((field) => field !== "blocks" && field !== "type");
     if (incompatible2.length) issues.push(semanticIssue(path, "blocks cannot be mixed with leaf payload fields", { fields: incompatible2 }));
     if (!Array.isArray(value.blocks) || value.blocks.length === 0 && !options.slideRoot) issues.push(semanticIssue(pathFor(path, "blocks"), "a group requires at least one block"));
     if (Array.isArray(value.blocks)) value.blocks.forEach((block, index) => {
-      if (isRecord(block)) issues.push(...validateContentPayload(block, `${pathFor(path, "blocks")}/${index}`));
+      if (isRecord(block)) issues.push(...validateContentPayload(block, `${pathFor(path, "blocks")}/${index}`, { topLevel: options.slideRoot === true }));
     });
+    if (options.slideRoot && Array.isArray(value.blocks)) {
+      const edges = /* @__PURE__ */ new Map();
+      value.blocks.forEach((block, index) => {
+        const edge = isRecord(block) && isRecord(block.placement) ? block.placement.edge : void 0;
+        if (edge === void 0) return;
+        if (edges.has(edge)) issues.push(semanticIssue(`${pathFor(path, "blocks")}/${index}/placement/edge`, `blocks ${edges.get(edge)} and ${index} are both placed on the ${String(edge)} edge; a slide edge takes at most one placed image`, { code: "image-placement-invalid", edge, blocks: [edges.get(edge), index] }));
+        else edges.set(edge, index);
+      });
+    }
     return issues;
   }
   if (hasOwn(value, "composition") && !options.slideRoot) issues.push(semanticIssue(pathFor(path, "composition"), "composition is only valid on a group containing blocks"));
@@ -774,6 +348,7 @@ function validateContentPayload(value, path, options = {}) {
   }
   const spec = contentKindSpecs[resolvedKind];
   if (hasOwn(value, "caption") && !captionableKinds.has(resolvedKind)) issues.push(captionIssue(`this payload is '${resolvedKind}'`, { type: resolvedKind }));
+  if (resolvedKind !== "image") imageOptionIssues(`this payload is '${resolvedKind}'`, { type: resolvedKind });
   const allowedFields = /* @__PURE__ */ new Set([
     "type",
     ...spec.fields
@@ -937,77 +512,6 @@ function presentationSemanticIssues(value) {
   issues.push(...annotationIssues(value));
   return issues;
 }
-function inlineCatalogEntry(context, kind) {
-  const catalogsField = context.document.catalogs;
-  if (!isRecord(catalogsField)) {
-    return void 0;
-  }
-  const entry = catalogsField[kind];
-  return isRecord(entry) ? entry : void 0;
-}
-function unknownIdWarning(kind, value, path, context) {
-  if (typeof value !== "string" || !bareIdPattern.test(value)) {
-    return void 0;
-  }
-  if (context) {
-    const entry = inlineCatalogEntry(context, kind);
-    if (entry) {
-      const inline = Array.isArray(entry.records) ? entry.records.find((record) => isRecord(record) && record.id === value) : void 0;
-      if (isRecord(inline)) {
-        const replacedBy = isRecord(inline.deprecation) ? inline.deprecation.replacedBy : void 0;
-        return typeof replacedBy === "string" ? deprecatedIdWarning(kind, value, replacedBy, path) : void 0;
-      }
-      if (typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0) {
-        return void 0;
-      }
-    }
-  }
-  if (catalogIds[kind].includes(value)) {
-    const replacedBy = deprecatedCatalogIds[`${kind}/${value}`];
-    return replacedBy === void 0 ? void 0 : deprecatedIdWarning(kind, value, replacedBy, path);
-  }
-  return semanticIssue(path, `unknown ${kind} catalog id '${value}'`, { kind, id: value });
-}
-function deprecatedIdWarning(kind, id, replacedBy, path) {
-  return semanticIssue(path, `deprecated ${kind} catalog id '${id}'; use '${replacedBy}'`, { kind, id, replacedBy });
-}
-function referenceObjectWarning(kind, value, path, context) {
-  if (typeof value === "string") {
-    return unknownIdWarning(kind, value, path, context);
-  }
-  if (isRecord(value)) {
-    return unknownIdWarning(kind, value.id, pathFor(path, "id"), context);
-  }
-  return void 0;
-}
-function pushIfDefined(issues, issue2) {
-  if (issue2) {
-    issues.push(issue2);
-  }
-}
-function designReferenceWarnings(design, path, context) {
-  if (!isRecord(design)) {
-    return [];
-  }
-  const issues = [];
-  pushIfDefined(issues, referenceObjectWarning("themes", design.theme, pathFor(path, "theme"), context));
-  pushIfDefined(issues, referenceObjectWarning("colorSchemes", design.colorScheme, pathFor(path, "colorScheme"), context));
-  pushIfDefined(issues, referenceObjectWarning("fontSchemes", design.fontScheme, pathFor(path, "fontScheme"), context));
-  if (isRecord(design.theme)) {
-    const themePath = pathFor(path, "theme");
-    pushIfDefined(issues, referenceObjectWarning("colorSchemes", design.theme.colorScheme, pathFor(themePath, "colorScheme"), context));
-    pushIfDefined(issues, referenceObjectWarning("fontSchemes", design.theme.fontScheme, pathFor(themePath, "fontScheme"), context));
-  }
-  return issues;
-}
-function themeOf(reference, context) {
-  const id = typeof reference === "string" ? reference : isRecord(reference) ? reference.id : void 0;
-  const entry = inlineCatalogEntry(context, "themes");
-  const inline = typeof id === "string" && Array.isArray(entry?.records) ? entry.records.find((record) => isRecord(record) && record.id === id) : void 0;
-  const base = isRecord(inline) ? inline : typeof id === "string" ? themes.find((record) => isRecord(record) && record.id === id) : void 0;
-  if (isRecord(reference)) return { ...base ?? {}, ...reference };
-  return base;
-}
 function canvasSize(dimensions) {
   try {
     const { width, height } = resolveCanvasDimensions(dimensions);
@@ -1016,15 +520,16 @@ function canvasSize(dimensions) {
     return "invalid";
   }
 }
-function slideThemeDimensionsWarnings(document, slide, slidePath, context) {
+function slideThemeDimensionsWarnings(document, slide, index, catalogs) {
+  const slidePath = `/slides/${index}`;
   const slideDesign = isRecord(slide.design) ? slide.design : void 0;
-  if (!slideDesign || slideDesign.theme === void 0) return [];
-  const slideTheme = themeOf(slideDesign.theme, context);
-  if (!slideTheme || slideTheme.dimensions === void 0) return [];
+  if (!slideDesign || typeof slideDesign.theme !== "string") return [];
+  const options = { catalogs: catalogs ?? [] };
+  const slideTheme = resolveDesignRecords(document, index, options);
+  if (slideTheme.diagnostics.some((diagnostic) => diagnostic.kind === "themes") || slideTheme.theme.dimensions === void 0) return [];
   const deckDesign = isRecord(document.design) ? document.design : {};
-  const deckTheme = themeOf(deckDesign.theme ?? "minimal", context);
-  const deckDimensions = deckDesign.dimensions ?? deckTheme?.dimensions;
-  const slideSize = canvasSize(slideTheme.dimensions);
+  const deckDimensions = deckDesign.dimensions ?? resolveDesignRecords(document, void 0, options).theme.dimensions;
+  const slideSize = canvasSize(slideTheme.theme.dimensions);
   const deckSize = canvasSize(deckDimensions);
   if (slideSize === deckSize) return [];
   const explicit = deckDesign.dimensions !== void 0;
@@ -1034,20 +539,19 @@ function slideThemeDimensionsWarnings(document, slide, slidePath, context) {
     { code: "slide-theme-dimensions", slideDimensions: slideSize, deckDimensions: deckSize }
   )];
 }
-function chartTypeWarnings(payload, path, context) {
+function chartTypeWarnings(payload, path) {
   if (!isRecord(payload)) {
     return [];
   }
   const issues = [];
   if (isRecord(payload.chart)) {
-    pushIfDefined(issues, unknownIdWarning("chartTypes", payload.chart.type, `${pathFor(path, "chart")}/type`, context));
     for (const diagnostic of resolveChartOptions(payload.chart, chartOptionTarget(payload.chart.type)).diagnostics) {
       issues.push(semanticIssue(diagnostic.option.split(".").reduce(pathFor, pathFor(path, "chart")), diagnostic.message, { code: diagnostic.code, option: diagnostic.option, reason: diagnostic.reason }));
     }
   }
   if (Array.isArray(payload.blocks)) {
     payload.blocks.forEach((block, index) => {
-      issues.push(...chartTypeWarnings(block, `${pathFor(path, "blocks")}/${index}`, context));
+      issues.push(...chartTypeWarnings(block, `${pathFor(path, "blocks")}/${index}`));
     });
   }
   return issues;
@@ -1216,34 +720,19 @@ function variableReferenceWarnings(value) {
   });
   return issues;
 }
-function presentationReferenceWarnings(value) {
+function presentationReferenceWarnings(value, catalogs) {
   if (!isRecord(value) || !Array.isArray(value.slides)) {
     return [];
   }
-  const context = { document: value };
   const issues = [];
-  if (typeof value.narrative === "string") {
-    pushIfDefined(issues, unknownIdWarning("narratives", value.narrative, "/narrative", context));
-  }
-  if (Array.isArray(value.audience)) {
-    value.audience.forEach((entry, index) => {
-      pushIfDefined(issues, referenceObjectWarning("audiences", entry, `/audience/${index}`, context));
-    });
-  } else if (isRecord(value.audience)) {
-    pushIfDefined(issues, referenceObjectWarning("audiences", value.audience, "/audience", context));
-  } else {
-    pushIfDefined(issues, unknownIdWarning("audiences", value.audience, "/audience", context));
-  }
-  issues.push(...designReferenceWarnings(value.design, "/design", context));
   issues.push(...variableReferenceWarnings(value));
   value.slides.forEach((slide, index) => {
     if (!isRecord(slide)) {
       return;
     }
     const slidePath = `/slides/${index}`;
-    issues.push(...designReferenceWarnings(slide.design, pathFor(slidePath, "design"), context));
-    issues.push(...slideThemeDimensionsWarnings(value, slide, slidePath, context));
-    issues.push(...chartTypeWarnings(slide, slidePath, context));
+    issues.push(...slideThemeDimensionsWarnings(value, slide, index, catalogs));
+    issues.push(...chartTypeWarnings(slide, slidePath));
     const numberingWarnings = (payload, path) => {
       for (const finding2 of numberingFindings(payload).warnings) issues.push(semanticIssue(pathFor(path, finding2.key), finding2.message, { ...finding2.params, code: "numbering-start-ignored" }));
     };
@@ -1261,34 +750,12 @@ function presentationReferenceWarnings(value) {
     visitContentPayloads(slide, slidePath, highlightWarnings);
     for (const key of Object.keys(slide)) {
       if (promotedRegionKeySet.has(key)) {
-        issues.push(...chartTypeWarnings(slide[key], pathFor(slidePath, key), context));
+        issues.push(...chartTypeWarnings(slide[key], pathFor(slidePath, key)));
       }
     }
   });
   return issues;
 }
-var catalogCrossLinkFields = {
-  audience: { recommendedNarratives: "narratives", recommendedTones: "tones" },
-  purpose: { recommendedNarratives: "narratives", recommendedTones: "tones" },
-  tone: { recommendedNarratives: "narratives" }
-};
-function catalogCrossLinkWarnings(schemaName, value) {
-  const fields2 = catalogCrossLinkFields[schemaName];
-  if (!fields2 || !isRecord(value)) {
-    return [];
-  }
-  const issues = [];
-  for (const [field, kind] of Object.entries(fields2)) {
-    const links = value[field];
-    if (!Array.isArray(links)) {
-      continue;
-    }
-    links.forEach((link, index) => {
-      pushIfDefined(issues, unknownIdWarning(kind, link, `${pathFor("/", field)}/${index}`));
-    });
-  }
-  return issues;
-}
 function validateLanguageSemantics(value) {
   if (!isRecord(value)) {
     return [];
@@ -1397,6 +864,33 @@ function dataUnionErrors(errors, value) {
     return { ...error, message: field === "fields" ? "'fields' applies only to a dataset-backed table; add 'dataset' or remove 'fields'" : datasetTableMessage(field) };
   });
 }
+var placeholderHeadings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
+function placeholderGroupIssues(value) {
+  const issues = [];
+  if (!isRecord(value) || !Array.isArray(value.placeholders)) return issues;
+  const walk = (entries, path, depth) => entries.forEach((entry, index) => {
+    if (!isRecord(entry)) return;
+    const at2 = `${path}/${index}`;
+    if (entry.type === "group") {
+      if (depth >= MAX_PLACEHOLDER_GROUP_DEPTH) issues.push(semanticIssue(at2, `placeholder groups nest at most ${MAX_PLACEHOLDER_GROUP_DEPTH} levels inside a layout record; this group would be level ${depth + 1}`, { code: "layout-placeholder-group", depth: depth + 1, maxDepth: MAX_PLACEHOLDER_GROUP_DEPTH }));
+      else if (Array.isArray(entry.placeholders)) walk(entry.placeholders, `${at2}/placeholders`, depth + 1);
+      return;
+    }
+    if (depth === 0) return;
+    if (typeof entry.type === "string" && placeholderHeadings.has(entry.type)) issues.push(semanticIssue(`${at2}/type`, `a placeholder group holds body regions only; a '${entry.type}' placeholder belongs at the record's top level`, { code: "layout-placeholder-group" }));
+    if (hasOwn(entry, "placement")) issues.push(semanticIssue(`${at2}/placement`, "placement is only valid on a top-level image placeholder; a region inside a placeholder group cannot bleed to a slide edge", { code: "image-placement-invalid" }));
+  });
+  walk(value.placeholders, "/placeholders", 0);
+  return issues;
+}
+function withPlaceholderGroupIssues(errors, value) {
+  const issues = placeholderGroupIssues(value);
+  const entries = issues.map((issue2) => issue2.path.replace(/\/(type|placement)$/, ""));
+  const covered = (error) => entries.some((entry) => error.path === entry || error.path.startsWith(`${entry}/`));
+  const kept = errors.filter((error) => !covered(error));
+  const reported = [...kept.filter((error) => error.keyword !== "if"), ...issues].map((error) => error.path);
+  return [...kept.filter((error) => error.keyword !== "if" || !reported.some((path) => path === error.path || path.startsWith(`${error.path}/`))), ...issues];
+}
 function validateAgainstSchema(value, schemaOrKind = "presentation", options = {}) {
   const resolved = resolveValidator(schemaOrKind);
   if (resolved.schemaName === "presentation") {
@@ -1428,20 +922,20 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options = {
   }
   const valid = resolved.validate(subject) === true;
   const ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
-  const errors = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
+  const mapped = (resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors).map(toIssue);
+  const errors = resolved.schemaName === "layout" ? withPlaceholderGroupIssues(mapped, subject) : mapped;
   const warnings = [];
   if (resolved.schemaName === "presentation") {
     errors.push(...presentationSemanticIssues(subject));
     errors.push(...variableIssues.errors);
     const data = dataIssues(subject);
     errors.push(...data.errors);
-    warnings.push(...presentationReferenceWarnings(subject));
+    warnings.push(...presentationReferenceWarnings(subject, options.catalogs));
     warnings.push(...data.warnings);
     warnings.push(...variableIssues.warnings);
   } else if (resolved.schemaName === "language") {
     errors.push(...validateLanguageSemantics(value));
   }
-  warnings.push(...catalogCrossLinkWarnings(resolved.schemaName, value));
   return {
     valid: errors.length === 0,
     errors,
@@ -1455,24 +949,13 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options = {
 
 // src/narrative-plan.ts
 var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function resolveNarrative(document, loaded = []) {
+function resolveNarrative(document, options = {}) {
   if (!isRec(document) || typeof document.narrative !== "string") return void 0;
-  const id = document.narrative;
-  if (/^(?:https?:|pkg:)/i.test(id)) return void 0;
-  const entry = isRec(document.catalogs) && isRec(document.catalogs.narratives) ? document.catalogs.narratives : {};
-  const sources = [
-    ["document", Array.isArray(entry.records) ? entry.records : []],
-    ["loaded", loaded],
-    ["built-in", catalogs.narratives]
-  ];
-  for (const [origin, records] of sources) {
-    const record = records.find((candidate) => isRec(candidate) && candidate.id === id);
-    if (isRec(record)) {
-      const beats = Array.isArray(record.beats) ? record.beats.flatMap((beat) => isRec(beat) && typeof beat.id === "string" ? [beat.id] : []) : [];
-      return { record, origin, beats };
-    }
-  }
-  return void 0;
+  const found = resolveReference(document, "narratives", document.narrative, { catalogs: options.catalogs ?? [] });
+  if (!found) return void 0;
+  const record = found.record;
+  const beats = Array.isArray(record.beats) ? record.beats.flatMap((beat) => isRec(beat) && typeof beat.id === "string" ? [beat.id] : []) : [];
+  return { record, origin: found.origin, beats };
 }
 function slideBeatReferences(document) {
   if (!isRec(document) || !Array.isArray(document.slides)) return [];
@@ -1590,19 +1073,13 @@ function simulateVision(hex, model) {
   const m = CVD_MATRICES[model];
   return toHex(m.map((row) => delinear(row[0] * (rgb[0] ?? 0) + row[1] * (rgb[1] ?? 0) + row[2] * (rgb[2] ?? 0))));
 }
-function createLookup(document, extra) {
-  return (kind, id) => {
-    const inline = rec(rec(document.catalogs)[kind]).records;
-    const found = (Array.isArray(inline) ? inline : []).find((r) => r?.id === id) ?? (extra?.[kind] ?? []).find((r) => rec(r).id === id) ?? catalogs[kind]?.find((r) => rec(r).id === id);
-    return found === void 0 ? void 0 : rec(found);
-  };
-}
 var PAGE = "#FFFFFF";
 var colorFrom = (scheme, slot, fallback) => typeof slot === "string" ? slot.startsWith("#") ? normalizeHexColor(slot) ?? fallback : normalizeHexColor(scheme[slot]) ?? fallback : fallback;
 function backdropOf(definition, scheme, text, variables) {
   const resolve2 = (value, fallback) => backgroundColorRef(value, scheme, variables, fallback);
   const canvas = defaultSlideBackground(scheme);
   if (!definition) return { kind: "solid", color: canvas };
+  if (imageBackground(definition)) return { kind: "image", opacity: imageBackground(definition)?.opacity ?? 1, base: PAGE };
   if (typeof definition === "string") return { kind: "solid", color: colorFrom(scheme, definition, canvas) };
   const bg = rec(definition), opacity = typeof bg.opacity === "number" ? Math.max(0, Math.min(1, bg.opacity)) : 1;
   switch (bg.type) {
@@ -1653,6 +1130,7 @@ function decisionColor(definition, scheme, variables = {}) {
   if (!definition) return void 0;
   const canvas = defaultSlideBackground(scheme);
   const reference = (value) => backgroundColorRef(value, scheme, variables, PAGE);
+  if (imageBackground(definition)) return void 0;
   if (typeof definition === "string") return colorFrom(scheme, definition, canvas);
   const bg = rec(definition);
   switch (bg.type) {
@@ -1671,15 +1149,15 @@ function resolveDesign(document, index, context) {
   const { options, diagnostics, resolved } = context;
   const { theme, colorScheme, fontScheme, fontSchemePath } = resolved;
   const fontPath = `/${fontSchemePath.split(".").join("/")}`;
-  const fontDiagnostic = diagnostics.find((diagnostic) => diagnostic.code === "unresolved-font-scheme");
+  const fontDiagnostic = diagnostics.find((diagnostic) => diagnostic.kind === "fontSchemes");
   const dimensions = { width: options.width, height: options.height };
   const variables = rec(document.variables);
   const roles = resolveColorRoles(colorScheme, { background: decisionColor(own2.background ?? deck.background ?? theme.background, colorScheme, variables) });
   const dark = roles.dark;
   const text = roles.text;
   const backdrop = backdropOf(own2.background ?? deck.background ?? theme.background, colorScheme, text, variables);
-  const definition = rec(own2.background ?? deck.background ?? theme.background);
-  const backgroundImage = definition.type === "image" && own2.background !== void 0 ? { source: rec(definition.image).src, fit: rec(definition.image).fit ?? "cover", path: `/slides/${index}/design/background/image` } : definition.type === "image" && deck.background !== void 0 ? { source: rec(definition.image).src, fit: rec(definition.image).fit ?? "cover", path: "/design/background/image" } : void 0;
+  const picture = imageBackground(own2.background ?? deck.background ?? theme.background);
+  const backgroundImage = picture && own2.background !== void 0 ? { source: picture.src, fit: picture.fit, path: `/slides/${index}/design/background` } : picture && deck.background !== void 0 ? { source: picture.src, fit: picture.fit, path: "/design/background" } : void 0;
   return {
     theme,
     colorScheme,
@@ -1700,7 +1178,7 @@ function resolveDesign(document, index, context) {
     variables,
     ...backgroundImage ? { backgroundImage } : {},
     fontSchemePath: fontPath,
-    ...fontDiagnostic ? { unresolvedFontScheme: fontDiagnostic.id } : {}
+    ...fontDiagnostic ? { unresolvedFontScheme: fontDiagnostic.reference } : {}
   };
 }
 function resolveTextColor(reference, design, fallback) {
@@ -1896,9 +1374,6 @@ function assetRefs(document, slide, slidePath, includeDeck) {
     if (rec(payload.node.quote).photo !== void 0) out.push({ path: at2("quote", "photo"), value: rec(payload.node.quote).photo, kind: "quote-photo" });
   }
   const designRefs = (design, base) => {
-    const slideImage = design.slideImage;
-    if (slideImage && (typeof slideImage === "string" || typeof slideImage.src === "string"))
-      out.push({ path: `${base}/slideImage`, value: slideImage, kind: "slide-image" });
     const logo = design.logo;
     if (typeof logo === "string" || logo && typeof logo.src === "string") out.push({ path: `${base}/logo`, value: logo, kind: "logo" });
     else if (logo && typeof logo === "object") {
@@ -1940,10 +1415,10 @@ var isLarge = (sizePx, bold) => {
 };
 function slideBackdrop(context, box) {
   const { design, composition } = context;
-  const image = composition?.slideImage;
-  if (image?.position === "background") {
-    const overlay = image.overlay && image.overlay.box.width >= composition.width * 0.99 && image.overlay.box.height >= composition.height * 0.99 ? { color: resolveTextColor(image.overlay.color, design, "#000000") ?? "#000000", opacity: image.overlay.opacity } : void 0;
-    return backdropColors({ kind: "image", opacity: image.opacity ?? 1, base: design.backdrop.kind === "solid" ? design.backdrop.color : "#FFFFFF" }, box, design.dimensions, { overlay });
+  const image = composition?.backgroundImage;
+  if (image) {
+    const overlay = image.overlay && !image.overlay.edge ? { color: resolveTextColor(image.overlay.color, design, "#000000") ?? "#000000", opacity: image.overlay.opacity } : void 0;
+    return backdropColors({ kind: "image", opacity: image.opacity ?? 1, base: "#FFFFFF" }, box, design.dimensions, { overlay });
   }
   return backdropColors(design.backdrop, box, design.dimensions);
 }
@@ -2055,7 +1530,7 @@ var onImageRule = rule(
     standard: "WCAG 2.2 SC 1.4.3 Contrast (Minimum), level AA",
     thresholds: ["contrastNormal", "contrastLarge"],
     cost: "composition",
-    approximations: "Core never reads picture pixels. The picture is bounded by a grey ramp from black to white, composited through the image opacity and a full-frame design.slideImage.overlay; the text passes only when every step of that ramp passes. An edge-banded overlay is not counted."
+    approximations: "Core never reads picture pixels. The picture is bounded by a grey ramp from black to white, composited through the image opacity and a full-frame design.background overlay; the text passes only when every step of that ramp passes. An edge-banded overlay is not counted."
   }
 );
 var contrastRules = [
@@ -2078,7 +1553,7 @@ var contrastRules = [
                 path: sample.path,
                 slide,
                 message: `${sample.label} sits on a background picture. Contrast cannot be guaranteed from the document (against the lightest or darkest possible pixels it is as low as ${worst.ratio.toFixed(1)}:1; ${needed}:1 is needed at this size).`,
-                help: "Add a full-frame overlay to design.slideImage (overlay colour and an opacity high enough that text passes on any picture), use a solid or gradient background behind text, or place text on a card.",
+                help: "Add a full-frame overlay to the image background (design.background.overlay: a colour and an opacity high enough that text passes on any picture), use a solid or gradient background behind text, or place text on a card.",
                 measured: { ratio: round(worst.ratio), needed, textColor: sample.color }
               });
             }
@@ -2126,7 +1601,7 @@ var altRule = rule(
   'People using a screen reader get nothing for a picture without alternative text. A picture that is purely decorative should say so with an empty alt (alt: ""), which is an explicit, reviewed choice instead of an omission.',
   {
     standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A",
-    approximations: "Checks the alt field of images, video, the slide image, logos (design.logo and each LogoSet variant, organization.logo), header/footer images, quote photos and speaker photos, following asset: references to the assets registry. Whether the text describes the picture well is not judged here (see opf/poor-alt-text). Charts carry `chart.alt` and are checked by opf/chart-text-alternative. Background images and watermarks are decorative by definition and are not checked."
+    approximations: "Checks the alt field of images (image blocks, Slide.image and region images, placed or not), video, logos (design.logo and each LogoSet variant, organization.logo), header/footer images, quote photos and speaker photos, following asset: references to the assets registry. Whether the text describes the picture well is not judged here (see opf/poor-alt-text). Charts carry `chart.alt` and are checked by opf/chart-text-alternative. Picture backgrounds are decorative unless they carry their own alt, and watermarks are decorative, so neither is checked."
   }
 );
 var poorAltRule = rule(
@@ -2140,7 +1615,7 @@ var poorAltRule = rule(
 var GENERIC_ALT = /^(image|picture|photo|photograph|graphic|img|icon|figure|screenshot|untitled|alt|alt text|logo)$/i;
 var FILE_ALT = /(\.(png|jpe?g|gif|svg|webp|bmp|tiff?|heic|avif)$)|^(img|dsc|image|screenshot|screen shot|photo|pic)[ _-]?\d+/i;
 var GENERIC_CHART_ALT = /^((a|an|the)\s+)?([a-z-]+\s+){0,2}(chart|graph|plot|diagram|figure)$/i;
-var kindLabel = (kind) => ({ chart: "Chart", image: "Image", video: "Video", "slide-image": "Slide image", logo: "Logo", furniture: "Header/footer image", speaker: "Speaker photo", "quote-photo": "Quote photo", organization: "Organization logo" })[kind] ?? "Picture";
+var kindLabel = (kind) => ({ chart: "Chart", image: "Image", video: "Video", logo: "Logo", furniture: "Header/footer image", speaker: "Speaker photo", "quote-photo": "Quote photo", organization: "Organization logo" })[kind] ?? "Picture";
 function altFixes(path, value) {
   const decorative = typeof value === "string" ? { id: "mark-decorative", title: "Mark as decorative (empty alt)", kind: "patch", safe: false, patch: [{ op: "replace", path, value: { src: value, alt: "" } }] } : { id: "mark-decorative", title: "Mark as decorative (empty alt)", kind: "patch", safe: false, patch: [{ op: "add", path: `${path}/alt`, value: "" }] };
   return [{ id: "focus-alt", title: "Write alt text", kind: "focus", safe: true, focus: { path, field: "alt", value } }, decorative];
@@ -2471,7 +1946,7 @@ var languageRule = rule(
   "info",
   "The presentation does not declare its language.",
   "Screen readers and text-to-speech choose pronunciation and hyphenation from the declared language; spell checkers and translation tools use it too.",
-  { standard: "WCAG 2.2 SC 3.1.1 Language of Page, level A", approximations: "Only the presentation-level `language` is checked, not the language of individual runs (OPF has no per-run language)." }
+  { standard: "WCAG 2.2 SC 3.1.1 Language of Page, level A", approximations: "Only the presentation-level `language` is checked, not the language of individual runs (`TextRun.lang`; opf/language-tag checks how those tags are written)." }
 );
 var languageRules = [
   {
@@ -2481,7 +1956,7 @@ var languageRules = [
       context.report(languageRule, {
         path: "",
         message: "The presentation has no language set.",
-        help: 'Set `language` to a language id from the languages catalog or a BCP 47 tag, for example "en-US".',
+        help: 'Set `language` to a BCP 47 tag, for example "en-US".',
         fixes: [{ id: "focus-language", title: "Set the language", kind: "focus", safe: true, focus: { path: "/language", field: "language" } }]
       });
     }
@@ -2497,6 +1972,105 @@ var accessibilityRules = [
   ...languageRules
 ];
 
+// src/language-tag.ts
+var REGION_ALIASES = { UK: "GB" };
+var privateRegion = /^(?:AA|Q[M-Z]|X[A-Z]|ZZ)$/;
+var regionNames;
+var assignedRegion = (region) => {
+  if (privateRegion.test(region)) return true;
+  regionNames ??= new Intl.DisplayNames(["en"], { type: "region", fallback: "code" });
+  try {
+    return regionNames.of(region) !== region;
+  } catch {
+    return false;
+  }
+};
+var canonical = (tag) => {
+  try {
+    return Intl.getCanonicalLocales(tag)[0];
+  } catch {
+    return void 0;
+  }
+};
+function regionSubtag(tag) {
+  const subtags = tag.split("-");
+  for (let index = 1; index < subtags.length; index++) {
+    const subtag = subtags[index];
+    if (/^(?:[a-z]{2}|\d{3})$/i.test(subtag)) return { region: subtag.toUpperCase(), index };
+    if (!/^[a-z]{3,4}$/i.test(subtag)) return void 0;
+  }
+  return void 0;
+}
+function languageTagProblem(tag) {
+  if (/^[ix]-/i.test(tag)) return void 0;
+  const parsed = canonical(tag);
+  if (parsed === void 0) return { message: `'${tag}' is not a well-formed BCP 47 language tag (subtags are letters and digits joined by hyphens, such as 'en-US' or 'zh-Hans').`, caseOnly: false };
+  const found = regionSubtag(tag);
+  if (found) {
+    const alias = REGION_ALIASES[found.region];
+    if (alias || !assignedRegion(found.region)) {
+      const subtags = tag.split("-");
+      subtags[found.index] = alias ?? found.region;
+      const suggestion = alias ? canonical(subtags.join("-")) : void 0;
+      return {
+        message: `'${tag}' names the region '${found.region}', which is not an assigned region${suggestion ? `; '${suggestion}' is the tag for ${new Intl.DisplayNames(["en"], { type: "region" }).of(alias)}` : ""}.`,
+        ...suggestion ? { suggestion } : {},
+        caseOnly: false
+      };
+    }
+  }
+  if (parsed === tag) return void 0;
+  if (parsed.toLowerCase() === tag.toLowerCase())
+    return { message: `'${tag}' is not in canonical case; the canonical form is '${parsed}' (language lower case, script title case, region upper case).`, suggestion: parsed, caseOnly: true };
+  const replacement = found && regionSubtag(parsed)?.region;
+  if (found && replacement && replacement !== found.region) {
+    const subtags = tag.split("-");
+    subtags[found.index] = replacement;
+    return { message: `'${tag}' names the region '${found.region}', which is deprecated; use '${replacement}'.`, suggestion: subtags.join("-"), caseOnly: false };
+  }
+  return void 0;
+}
+
+// src/rules-language.ts
+var languageTagRule = rule(
+  "language-tag",
+  "content",
+  "warning",
+  "A language tag is malformed, uses an unassigned region or is not in canonical case.",
+  "Engines read the deck language and each run's `lang` as BCP 47 tags to choose script fonts, text direction, proofing language and the PowerPoint `lang` attribute. A tag such as `en-a`, or a region that does not exist (`en-UK`; the United Kingdom is `GB`), is guessed at or dropped, and a wrong-case tag (`EN-us`) is not what a locale lookup expects.",
+  {
+    standard: "BCP 47 (RFC 5646, section 2.1) and the platform locale data (Intl.getCanonicalLocales, Intl.DisplayNames)",
+    approximations: "Checks the root `language` (a tag string, or the `bcp47` of an inline Language object) and `lang` on the TextRun objects of titles, subtitles, tags, text, lists, tables, quotes, metrics and timelines. A region is assigned when the runtime's CLDR data names it (ISO 3166-1 codes and UN M.49 areas such as 419); private-use regions (`AA`, `QM`-`QZ`, `XA`-`XZ`) and `ZZ` are accepted, as are private-use (`x-...`) tags. Only the spelling of a tag is checked, not whether the language subtag is assigned or whether the language suits the text. The schema rejects tags with characters other than letters, digits and hyphens (`en_US` is a schema error, with no suggestion), and `en-UK` as the deck language is already an error of the schema rule, so those are not reported twice."
+  }
+);
+var report = (context, tag, path, slide) => {
+  if (typeof tag !== "string") return;
+  const problem = languageTagProblem(tag);
+  if (!problem) return;
+  context.report(languageTagRule, {
+    path,
+    slide,
+    message: problem.message,
+    help: problem.suggestion ? `Write '${problem.suggestion}'.` : 'Write a well-formed BCP 47 tag with an assigned region, such as "en-US", "pt-BR" or "es-419".',
+    ...problem.suggestion ? { fixes: [{ id: "use-canonical-tag", title: `Use '${problem.suggestion}'`, kind: "patch", safe: problem.caseOnly, patch: [{ op: "replace", path, value: problem.suggestion }] }] } : {}
+  });
+};
+var isEnUk = (tag) => typeof tag === "string" && tag.toLowerCase() === "en-uk";
+var languageTagRules = [
+  {
+    info: languageTagRule,
+    run(context) {
+      const language = context.document.language;
+      if (typeof language === "string") {
+        if (!isEnUk(language)) report(context, language, "/language");
+      } else if (language !== void 0 && !isEnUk(rec(language).bcp47)) report(context, rec(language).bcp47, "/language/bcp47");
+      for (const slide of context.slides)
+        for (const tv of slide.texts)
+          if (typeof tv.value !== "string") for (const run of runsOf(tv)) report(context, run.style.lang, `${run.path}/lang`, slide);
+    }
+  }
+];
+
 // src/rules-layout-content.ts
 var PX_TO_PT2 = 0.75;
 var round2 = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
@@ -2641,7 +2215,7 @@ var resolutionRule = rule(
   {
     cost: "composition",
     thresholds: ["minImagePpi"],
-    approximations: "Only embedded data: images (and asset: references to them) have readable pixel sizes; URLs and files are never fetched, so they are not checked. The displayed size is the composed box (cropped images are measured as the cover scale, fitted ones as the contain scale). Effective ppi is the image pixels per inch of the 96 px/inch reference slide. SVG is vector and exempt."
+    approximations: "Only embedded data: images (and asset: references to them) have readable pixel sizes; URLs and files are never fetched, so they are not checked. The displayed size is the composed frame (cover and stretch are measured as the cover scale, contain as the contain scale). Effective ppi is the image pixels per inch of the 96 px/inch reference slide. SVG is vector and exempt."
   }
 );
 var resolutionRules = [
@@ -2669,12 +2243,10 @@ var resolutionRules = [
       for (const slide of context.slides) {
         const composition = slide.composition;
         if (composition) {
-          const fill = composition.design.imageFill;
-          for (const item of composition.items) if (item.field === "image") check(pointerOfDotted(item.path), item.value, item.box, fill === "crop", slide);
-          if (composition.slideImage) check(pointerOfDotted(composition.slideImage.sourcePath), composition.slideImage.value, composition.slideImage.box, composition.slideImage.fill === "crop", slide);
+          for (const item of composition.items) if (item.field === "image") check(pointerOfDotted(item.path), item.value, item.image?.box ?? item.box, item.image?.fit !== "contain", slide);
         }
         const background = slide.design.backgroundImage;
-        if (background && background.fit !== "tile") check(background.path, rec({ src: background.source }), slide.design.dimensions, background.fit === "cover", background.path.startsWith("/slides/") ? slide : void 0);
+        if (background && background.fit !== "tile") check(background.path, rec({ src: background.source }), slide.design.dimensions, background.fit !== "contain", background.path.startsWith("/slides/") ? slide : void 0);
       }
     }
   }
@@ -2708,7 +2280,7 @@ var unusedBeatRule = rule(
   "A beat of the narrative has no slide that references it.",
   "The narrative is the plan and the slides are the product. When some slides name a beat (slides[].beat) and a beat of the plan has none, the deck skips a step of the story or the plan is out of date.",
   {
-    approximations: "Resolved offline like every catalog reference: the inline catalogs.narratives.records of the document, then records passed in the `catalogs` option, then the bundled catalog. A narrative given as a URL or a pkg: reference, or an id no local source defines, is not checked. A deck in which no slide references any beat is not checked either, because it has not linked its slides to the plan. A slide that lists several beats covers each of them."
+    approximations: "Resolved like every content reference: the document's catalogs groups, then the registered catalogs. A narrative that resolves nowhere is not checked. A deck in which no slide references any beat is not checked either, because it has not linked its slides to the plan. A slide that lists several beats covers each of them."
   }
 );
 var PLACEHOLDERS = [
@@ -2758,7 +2330,7 @@ var contentRules = [
   {
     info: unusedBeatRule,
     run(context) {
-      const narrative = resolveNarrative(context.document, context.options.catalogs?.narratives);
+      const narrative = resolveNarrative(context.document, context.options);
       if (!narrative) return;
       const id = String(context.document.narrative);
       for (const { beat, index } of unreferencedBeats(context.document, narrative))
@@ -2778,8 +2350,8 @@ var contentRules = [
         const has = (value) => value !== void 0 && value !== null && !(typeof value === "string" && value.trim() === "") && !(Array.isArray(value) && value.length === 0);
         const hasText = slide.texts.some((tv) => plainText(tv.value).trim() !== "");
         const hasObject = slidePayloads(slide.slide, slide.path).some((p) => ["image", "video", "chart", "table", "code", "metric", "quote", "timeline"].some((field) => has(p.node[field])));
-        const hasSlideImage = has(rec(slide.slide.design).slideImage);
-        if (hasText || hasObject || hasSlideImage) continue;
+        const hasBackgroundImage = imageBackground(rec(slide.slide.design).background) !== void 0;
+        if (hasText || hasObject || hasBackgroundImage) continue;
         context.report(emptySlideRule, { path: slide.path, slide, message: `Slide ${slide.index + 1} has no title and no content.`, help: "Add content, delete the slide, or give it the blank layout if it is intentionally empty." });
       }
     }
@@ -2840,6 +2412,9 @@ var formatRules = [
   rule("cite-unknown-reference", "format", "error", "A citation names a reference that does not exist.", "A cited id with no entry in `references` has nothing to show in the footnote area.", { standard: SCHEMA }),
   rule("cite-unsupported-location", "format", "error", "A citation or footnote sits where no engine draws it.", "`cite` and `footnote` apply to runs in text, bullets and list items; table cells, captions, and reference and footnote texts have no marker.", { standard: SCHEMA }),
   rule("caption-unsupported-payload", "format", "error", "A caption is on a payload that cannot carry one.", "A caption belongs to exactly one image, chart, table or video; a group, text or code block has no place to draw it.", { standard: SCHEMA }),
+  rule("image-option-unsupported-payload", "format", "error", "An image option is on a payload that is not an image.", "`fit`, `focus`, the image treatments (`shape`, `cornerRadius`, `border`, `opacity`, `recolor`, `overlay`, `aspectRatio`) and `placement` describe how a picture is drawn; a group, text or chart block has no picture for them to apply to.", { standard: SCHEMA }),
+  rule("image-placement-invalid", "format", "error", "An image placement cannot be honoured.", "A placed image bleeds to a slide edge and the rest of the slide composes beside it. Only a top-level block (slides.N.blocks.I) can do that, and a slide edge holds one placed image; a block in a group or a promoted region, or a second block on the same edge, has nowhere to go.", { standard: SCHEMA }),
+  rule("layout-placeholder-group", "format", "error", "A layout record's placeholder group breaks a nesting rule.", "A placeholder group arranges body regions inside one cell of its layout record. Groups nest at most three levels inside a record, and a group holds body regions and groups only: the headings (title, subtitle, tag) stay at the record's top level, where the engine places them. Composition cannot use a record that breaks either rule.", { standard: SCHEMA }),
   rule("dataset-unknown", "format", "error", "A chart or table names a dataset that does not exist.", "The data cannot be drawn without the dataset it refers to.", { standard: SCHEMA }),
   rule("dataset-field-unknown", "format", "error", "A table asks a dataset for a column it does not have.", "The column cannot be shown when the dataset has no column of that name.", { standard: SCHEMA }),
   rule("data-column-duplicate", "format", "error", "A dataset or table has two columns with the same name.", "Series, mappings and fields address columns by name, so a repeated name makes them ambiguous.", { standard: SCHEMA }),
@@ -2876,23 +2451,30 @@ var referenceRules = [
     "catalog-record",
     "references",
     "error",
-    "A supplied or inline catalog record is invalid, or repeats an id.",
-    "A record that fails its catalog schema cannot be resolved, and a repeated id makes the override ambiguous. Invalid records are left out of the lookup, so the references to them are reported too.",
+    "An embedded or registered catalog record is invalid.",
+    "A record that fails its companion schema cannot be resolved. Invalid records are left out of the lookup, so the references to them are reported too.",
     { standard: "spec/schemas/<kind>.schema.json" }
   ),
   rule(
-    "catalog-reference",
+    "unresolved-reference",
     "references",
     "warning",
-    "A catalog id is not in the available context.",
-    "A theme, layout, font scheme or other catalog id that no record defines falls back to the engine default. Custom ids are legitimate when the host supplies their records, so this is advisory.",
-    { approximations: "Resolved against the document's inline records, the records the host passed in `catalogs`, then the bundled catalogs. External sources and `pkg:` records are never fetched. Free-form audience and purpose text, and BCP 47 language tags, are not catalog references." }
+    "A content reference resolves nowhere.",
+    "A layout, theme, colour scheme, font scheme, narrative, audience, purpose or tone reference that neither the document embeds nor a registered catalog defines falls back: a slide composes automatically, a design uses the engine default. A strict export fails instead. A slide with no layout is automatic composition and is never reported.",
+    { standard: SCHEMA, approximations: "Resolved like every engine resolves it: catalogs.custom, then the records embedded under catalogs.default, then the catalog registered for its source (the first registered catalog when `default` is omitted); `name:id` in catalogs.<name>, then the catalog registered for its source. Nothing is fetched. Free-form audience and purpose text is not a reference." }
   ),
-  rule("deprecated-catalog-id", "references", "warning", "A catalog id is deprecated.", "A deprecated record still resolves, so nothing breaks, but the replacement is the one that will be maintained.", { standard: "spec/catalogs `deprecation.replacedBy`" }),
-  rule("catalog-source", "references", "info", "An external catalog source was not fetched.", "A catalog `source` is a URL or package the checker never loads, so ids defined there are not verified."),
+  rule(
+    "catalog-record-not-in-source",
+    "references",
+    "warning",
+    "A record embedded under a catalog group is not in that catalog.",
+    "A record under catalogs.default or a named group says it came from the catalog its source names. When the catalog the host registered for that source has no record of that kind and id, the record is the document's own and belongs in catalogs.custom, where an update from the catalog never looks for it. Rendering is unchanged: the embedded record still wins.",
+    { standard: SCHEMA, approximations: "Checked only against a catalog the host registered for the group's source (the first registered catalog for an omitted default.source); with none registered for it the check is silent. A record the catalog has with different content is an update difference (updateFromCatalog), not this finding. catalogs.custom is never checked." }
+  ),
+  rule("undeclared-catalog", "format", "error", "A reference names a catalog group the document does not declare.", "The prefix of a `name:id` reference names the group of `catalogs` it resolves in. A prefix with no group can never resolve, whatever the host registers, so it is a format error: engines reject the document at their format check instead of drawing a fallback.", { standard: SCHEMA }),
   rule("unused-reference", "references", "warning", "A reference is never cited.", "A listed reference that no run cites is not drawn anywhere.", { standard: SCHEMA }),
   rule("unused-dataset", "references", "warning", "A dataset is never used.", "A dataset no chart or table references is not drawn anywhere.", { standard: SCHEMA }),
-  rule("unknown-beat", "references", "warning", "A slide names a beat its narrative does not define.", "`slides[].beat` links a slide to a step of the narrative plan. A beat id the narrative does not have links to nothing; nothing is drawn from a beat.", { standard: SCHEMA, approximations: "The narrative resolves offline: the inline catalogs.narratives.records, then the `catalogs` option, then the bundled catalog. A narrative no local source defines is not checked." }),
+  rule("unknown-beat", "references", "warning", "A slide names a beat its narrative does not define.", "`slides[].beat` links a slide to a step of the narrative plan. A beat id the narrative does not have links to nothing; nothing is drawn from a beat.", { standard: SCHEMA, approximations: "The narrative resolves like every content reference: the document's catalogs groups, then the registered catalogs. A narrative that resolves nowhere is not checked." }),
   rule("slide-theme-dimensions", "references", "warning", "A slide theme sets a slide size that differs from the deck.", "A PPTX has one slide size. The size a slide-level theme carries is never used: design.dimensions of the deck (or of its theme) wins in every engine, and without them the exporter stops with mixed slide sizes.", { standard: SCHEMA }),
   rule("variable-unknown", "references", "warning", "A `{{token}}` names a variable that is not declared.", "An undeclared token is shown literally.", { standard: SCHEMA }),
   rule("variable-unknown-value", "references", "warning", "A value was supplied for a variable that is not declared.", "The value is never used.", { standard: SCHEMA }),
@@ -2927,7 +2509,7 @@ var dataRules = [
   rule("duration-outside-narrative", "content", "warning", "The target duration is outside the range the narrative suits.", "A narrative records the talk lengths it suits. A deck whose duration is outside that range probably needs a different narrative or a different length; nothing is drawn or exported differently.", { standard: SCHEMA }),
   rule("narrative-duration-range", "content", "warning", "An inline narrative duration range has min greater than max.", "A range with its bounds swapped matches no duration, so the duration check cannot help.", { standard: "spec/schemas/narrative.schema.json" })
 ];
-var implementations = [...accessibilityRules, ...layoutContentRules];
+var implementations = [...accessibilityRules, ...layoutContentRules, ...languageTagRules];
 var ruleImplementations = implementations;
 var infos = [
   ...formatRules,
@@ -2972,12 +2554,7 @@ function at(value, path) {
   );
 }
 function checkDocumentOptions(options) {
-  if (options.catalogs !== void 0 && (!object(options.catalogs) || Object.entries(options.catalogs).some(
-    ([kind, records]) => !catalogKinds.includes(kind) || !Array.isArray(records)
-  )))
-    throw new TypeError(
-      "Validate catalogs must map known catalog kinds to arrays of loaded records."
-    );
+  checkCatalogsOption(options.catalogs, "validate");
   if (options.contracts !== void 0 && !Array.isArray(options.contracts))
     throw new TypeError("Validate contracts must be an array.");
   for (const contract of options.contracts ?? []) {
@@ -3094,36 +2671,6 @@ function active(cursor, value) {
   const selected = candidates.sort((a, b) => score(b.schema, value) - score(a.schema, value))[0];
   return selected ? { ...selected, baseSchemas: [...selected.baseSchemas ?? [], resolved] } : resolved;
 }
-function catalogIn(schema) {
-  const text = String(schema.description ?? "");
-  if (/\bfont-scheme id\b/.test(text)) return "fontSchemes";
-  return catalogKinds.find(
-    (kind) => text.includes(`catalogs.${kind}`) || new RegExp(`\\b${kind}['\u2019]? catalog`).test(text)
-  );
-}
-var languageTagSyntax = new RegExp(
-  "^(?:(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4}|[a-z]{5,8})(?:-[a-z]{4})?(?:-(?:[a-z]{2}|[0-9]{3}))?(?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*(?:-[0-9a-wy-z](?:-[a-z0-9]{2,8})+)*(?:-x(?:-[a-z0-9]{1,8})+)?|x(?:-[a-z0-9]{1,8})+)$",
-  "i"
-);
-var irregularLanguageTags = /* @__PURE__ */ new Set([
-  "en-gb-oed",
-  "i-ami",
-  "i-bnn",
-  "i-default",
-  "i-enochian",
-  "i-hak",
-  "i-klingon",
-  "i-lux",
-  "i-mingo",
-  "i-navajo",
-  "i-pwn",
-  "i-tao",
-  "i-tay",
-  "i-tsu",
-  "sgn-be-fr",
-  "sgn-be-nl",
-  "sgn-ch-de"
-]);
 function childCursor(cursors, key) {
   for (const keyword of [
     "properties",
@@ -3164,7 +2711,7 @@ function fields(document) {
     const entry = stack.pop();
     if (!entry) break;
     if (entry.ancestors.includes(entry.value)) continue;
-    const resolved = resolve(entry.cursor), selected = active(entry.cursor, entry.value), description = String(resolved.schema.description ?? "");
+    const resolved = resolve(entry.cursor), selected = active(entry.cursor, entry.value);
     const assetReference = [resolved, selected].some(
       (cursor) => cursor.root.$id === schemas.presentation.$id && (cursor.path === "/$defs/Asset" || cursor.path === "/$defs/Asset/oneOf/0" || cursor.path === "/$defs/Watermark/properties/src") || String(cursor.schema.description ?? "").includes("asset:") || Array.isArray(cursor.schema.examples) && cursor.schema.examples.some(
         (example) => typeof example === "string" && example.startsWith("asset:")
@@ -3174,8 +2721,6 @@ function fields(document) {
       path: pointer3(entry.path),
       value: entry.value,
       cursor: resolved,
-      kind: catalogIn(resolved.schema),
-      description,
       assetReference
     });
     const ancestors = [...entry.ancestors, entry.value];
@@ -3209,74 +2754,39 @@ function fields(document) {
   }
   return result;
 }
-function catalogContext(document, options, findings) {
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of catalogEntries) {
-    const kind = entry.kind, map = /* @__PURE__ */ new Map();
-    result.set(kind, map);
-    for (const record of entry.records)
-      map.set(record.id, {
-        value: record.id,
-        label: String(
-          record.name ?? record.id
-        ),
-        origin: "built-in",
-        definition: `spec/${entry.dir}/${entry.index.records.find((item) => item.id === record.id)?.file ?? `${record.id}.json`}`
-      });
-    const local = object(document) && object(document.catalogs) && object(document.catalogs[kind]) ? document.catalogs[kind] : {};
-    if (local.source !== void 0)
-      findings.push(
-        finding("opf/catalog-source", {
-          path: `/catalogs/${kind}/source`,
-          message: "External catalog source was not fetched.",
-          help: "This run checks built-in, supplied and inline records only. Load external catalogs in the host and pass their records explicitly to verify that context."
-        })
-      );
-    for (const group of [
-      {
-        records: options.catalogs?.[kind] ?? [],
-        origin: "loaded",
-        scope: "context",
-        path: `/catalogs/${kind}`
-      },
-      {
-        records: Array.isArray(local.records) ? local.records : [],
-        origin: "document",
-        scope: "document",
-        path: `/catalogs/${kind}/records`
+var recordKey = (group, kind, id) => `${group}/${kind}/${id}`;
+function recordIssues(kind, id, value) {
+  const schemaName = catalogSchemaNames[kind];
+  return validateAgainstSchema(object(value) ? { $schema: schemas[schemaName].$id, id, ...value } : value, kind);
+}
+function embeddedRecordFindings(document, options, findings) {
+  const invalid = /* @__PURE__ */ new Set();
+  if (!object(document) || !object(document.catalogs)) return invalid;
+  for (const [group, value] of Object.entries(document.catalogs)) {
+    if (!object(value)) continue;
+    for (const kind of catalogKinds)
+      for (const [id, record] of Object.entries(object(value[kind]) ? value[kind] : {})) {
+        const path = pointer3(["catalogs", group, kind, id]);
+        if (object(record) && (Object.hasOwn(record, "$schema") || Object.hasOwn(record, "id"))) continue;
+        const validation = recordIssues(kind, id, record);
+        for (const issue2 of validation.errors) findings.push(issueFinding(issue2, "opf/catalog-record", catalogSchemaNames[kind], path, "document"));
+        if (!validation.valid) invalid.add(recordKey(group, kind, id));
+        if (group === "custom") continue;
+        const source = catalogGroupSource(document, group, options);
+        const registered = registeredCatalog(source, options);
+        if (!registered || Object.hasOwn(registered[kind] ?? {}, id)) continue;
+        findings.push(
+          finding("opf/catalog-record-not-in-source", {
+            path,
+            message: `Record ${JSON.stringify(id)} is embedded under catalogs.${group}.${kind}, but the catalog registered for ${source} has no ${kind} record ${JSON.stringify(id)}; move it to catalogs.custom.`,
+            help: `Move the record to catalogs.custom (and drop the ${group === "default" ? "" : `${group}:`}prefix from its references), or use the id the catalog publishes. The embedded record still renders.`,
+            definition: `${schemas.presentation.$id}#/$defs/Catalogs`,
+            lookup: ["opf", "catalog", kind]
+          })
+        );
       }
-    ]) {
-      const seen = /* @__PURE__ */ new Set();
-      group.records.forEach((value, index) => {
-        const path = `${group.path}/${index}`, schemaName = catalogSchemaNames[kind], record = object(value) ? { $schema: schemas[schemaName].$id, ...value } : value;
-        const validation = validateAgainstSchema(record, kind);
-        for (const issue2 of validation.errors)
-          findings.push(issueFinding(issue2, "opf/catalog-record", schemaName, path, group.scope));
-        if (!object(value) || typeof value.id !== "string") return;
-        if (seen.has(value.id))
-          findings.push(
-            finding("opf/catalog-record", {
-              scope: group.scope,
-              path: `${path}/id`,
-              message: `Duplicate ${kind} record id ${JSON.stringify(value.id)} in this catalog.`,
-              help: "Give distinct records distinct IDs, or combine the intended override explicitly. Preserve their authored content."
-            })
-          );
-        seen.add(value.id);
-        if (!validation.valid) {
-          map.delete(value.id);
-          return;
-        }
-        map.set(value.id, {
-          value: value.id,
-          label: typeof value.name === "string" ? value.name : value.id,
-          origin: group.origin,
-          definition: `${group.scope}#${path}`
-        });
-      });
-    }
   }
-  return result;
+  return invalid;
 }
 function distance(a, b) {
   a = a.slice(0, 128);
@@ -3411,14 +2921,59 @@ function variableFindings(document, engine, schemaValid) {
   walk(document, [], 0);
   return findings;
 }
-function hasExternalSource(document, kind) {
-  if (!object(document) || !object(document.catalogs)) return false;
-  const entry = document.catalogs[kind];
-  return object(entry) && (typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0);
+function undeclaredCatalogFindings(document) {
+  const findings = [];
+  const reported = /* @__PURE__ */ new Set();
+  for (const site of catalogReferenceSites(document)) {
+    const parsed = parseReference(site.reference);
+    if (parsed?.group === void 0 || catalogGroupDeclared(document, parsed.group)) continue;
+    const path = pointerPath(site.path);
+    if (reported.has(path)) continue;
+    reported.add(path);
+    findings.push(
+      finding("opf/undeclared-catalog", {
+        path,
+        message: `Reference ${JSON.stringify(site.reference)} names catalog group ${JSON.stringify(parsed.group)}, which the document does not declare, so it can never resolve.`,
+        help: `Declare catalogs.${parsed.group} with the catalog's source (and embed the record), or write the reference without the prefix.`,
+        definition: `${schemas.presentation.$id}#/$defs/CatalogReference`,
+        lookup: ["opf", "schema", "presentation", "/$defs/CatalogReference"]
+      })
+    );
+  }
+  return findings;
+}
+function contentReferenceFindings(document, options, findings) {
+  const invalid = embeddedRecordFindings(document, options, findings);
+  const registeredChecked = /* @__PURE__ */ new Set();
+  for (const site of catalogReferenceSites(document)) {
+    const path = pointerPath(site.path);
+    const parsed = parseReference(site.reference);
+    if (parsed?.group !== void 0 && !catalogGroupDeclared(document, parsed.group)) continue;
+    const found = resolveReference(document, site.kind, site.reference, { ...options, ...site.group !== void 0 ? { group: site.group } : {} });
+    if (found?.origin === "host" && !registeredChecked.has(recordKey(found.group, site.kind, found.id))) {
+      registeredChecked.add(recordKey(found.group, site.kind, found.id));
+      for (const issue2 of recordIssues(site.kind, found.id, found.record).errors)
+        findings.push(issueFinding(issue2, "opf/catalog-record", catalogSchemaNames[site.kind], pointer3(["catalogs", found.group, site.kind, found.id]), "context"));
+    }
+    if (found && !(found.origin === "document" && invalid.has(recordKey(found.group, site.kind, found.id)))) continue;
+    const diagnostic = unresolvedReference(document, site.kind, site.reference, path, options);
+    const suggestions = catalogRecords(document, site.kind, options).map((entry) => ({ value: entry.reference, label: typeof entry.record.name === "string" ? entry.record.name : entry.reference, origin: entry.origin === "host" ? "registered" : "document", definition: entry.origin === "document" ? `document#${pointer3(["catalogs", entry.group, site.kind, entry.id])}` : `${entry.source ?? "context"}#/${site.kind}/${entry.id}` })).sort((a, b) => distance(site.reference, a.value) - distance(site.reference, b.value) || (a.value < b.value ? -1 : a.value > b.value ? 1 : 0)).slice(0, 5);
+    findings.push(
+      finding("opf/unresolved-reference", {
+        path,
+        message: diagnostic.message,
+        help: site.kind === "layouts" ? "Embed the layout record (embed(), or opf embed), register the catalog that defines it, choose one of the suggested layouts, or remove the reference to compose the slide automatically." : "Embed the record (embed(), or opf embed), register the catalog that defines it, or choose one of the suggested records.",
+        definition: `${schemas.presentation.$id}#/$defs/Catalogs`,
+        lookup: ["opf", "catalog", site.kind],
+        suggestions
+      })
+    );
+  }
 }
 function referenceFindings(document, engine, options) {
   const findings = [];
-  const catalogs2 = catalogContext(document, options, findings), seen = /* @__PURE__ */ new Set();
+  const catalogs = { catalogs: options.catalogs ?? [] };
+  contentReferenceFindings(document, catalogs, findings);
   const assetValues = object(document) && object(document.assets) ? document.assets : {};
   for (const field of fields(document)) {
     if (typeof field.value === "string" && field.value.startsWith("asset:") && field.assetReference) {
@@ -3442,30 +2997,6 @@ function referenceFindings(document, engine, options) {
           })
         );
     }
-    if (!field.path || !field.kind) continue;
-    const { kind } = field;
-    if (kind === "languages" && field.path === "/language" && typeof field.value === "string" && (languageTagSyntax.test(field.value) || irregularLanguageTags.has(field.value.toLowerCase())))
-      continue;
-    if (kind !== "layouts" && /free-form/i.test(field.description)) continue;
-    const value = object(field.value) ? field.value.id : field.value, path = object(field.value) ? `${field.path}/id` : field.path;
-    if (typeof value !== "string" || !value || /^(?:https?:|pkg:)/i.test(value) || catalogs2.get(kind)?.has(value) || seen.has(path))
-      continue;
-    seen.add(path);
-    if (!options.catalogs?.[kind]?.length && hasExternalSource(document, kind)) continue;
-    const suggestions = [...catalogs2.get(kind)?.values() ?? []].sort(
-      (a, b) => distance(value, String(a.value)) - distance(value, String(b.value)) || (String(a.value) < String(b.value) ? -1 : String(a.value) > String(b.value) ? 1 : 0)
-    ).slice(0, 5);
-    const definition = String(field.cursor.root.$id) + `#${field.cursor.path}`;
-    findings.push(
-      finding("opf/catalog-reference", {
-        path,
-        message: `Unknown ${kind} catalog id ${JSON.stringify(value)} in the available local context.`,
-        help: kind === "layouts" ? "Choose an available layout or supply the intended custom record. Engine-defined layouts may be valid; preview with the target renderer before changing content." : "Choose an available record or supply the intended custom catalog context. External references and native rendering are not verified by this check.",
-        definition,
-        lookup: ["opf", "catalog", kind],
-        suggestions
-      })
-    );
   }
   const reportedCycles = /* @__PURE__ */ new Set();
   for (const id of Object.keys(assetValues)) {
@@ -3492,33 +3023,7 @@ function referenceFindings(document, engine, options) {
       current = typeof source === "string" && source.startsWith("asset:") ? source.slice(6) : void 0;
     }
   }
-  for (const issue2 of engine.warnings) {
-    if (typeof issue2.params.code === "string") continue;
-    const kind = issue2.params.kind, id = issue2.params.id, replacedBy = issue2.params.replacedBy;
-    if (kind === void 0) continue;
-    if (typeof replacedBy === "string" && typeof id === "string") {
-      const target = catalogs2.get(kind)?.get(replacedBy);
-      findings.push({
-        ...issueFinding(issue2, "opf/deprecated-catalog-id"),
-        message: `Deprecated ${kind} catalog id ${JSON.stringify(id)}; use ${JSON.stringify(replacedBy)} instead.`,
-        help: "The deprecated id still resolves to its original record, so nothing breaks. Switch to the replacement when you next edit this reference.",
-        lookup: ["opf", "catalog", kind],
-        ...target ? { suggestions: [target] } : {}
-      });
-      continue;
-    }
-    if (seen.has(issue2.path) || typeof id === "string" && catalogs2.get(kind)?.has(id))
-      continue;
-    const dir = catalogEntries.find((entry) => entry.kind === kind)?.dir;
-    findings.push({
-      ...issueFinding(issue2, "opf/catalog-reference"),
-      message: `Unknown ${kind} catalog id ${JSON.stringify(id)} in the available local context.`,
-      help: "Inspect the referenced catalog and supply the intended record if this is a custom context.",
-      ...dir ? { definition: `spec/${dir}/index.json` } : {},
-      lookup: ["opf", "catalog", kind]
-    });
-  }
-  findings.push(...narrativeFindings(document, options));
+  findings.push(...narrativeFindings(document, catalogs));
   for (const issue2 of unusedReferenceWarnings(document))
     findings.push(
       finding("opf/unused-reference", {
@@ -3545,16 +3050,16 @@ function referenceFindings(document, engine, options) {
 function narrativeFindings(document, options) {
   const findings = [];
   if (!object(document)) return findings;
-  const narrative = resolveNarrative(document, options.catalogs?.narratives);
+  const narrative = resolveNarrative(document, options);
   if (narrative) {
     const id = String(document.narrative);
-    const beatSuggestions = (beat) => narrative.beats.slice().sort((a, b) => distance(beat, a) - distance(beat, b) || (a < b ? -1 : a > b ? 1 : 0)).slice(0, 5).map((value) => ({ value, label: value, origin: narrative.origin === "built-in" ? "built-in" : narrative.origin, definition: `narratives/${id}#/beats` }));
+    const beatSuggestions = (beat) => narrative.beats.slice().sort((a, b) => distance(beat, a) - distance(beat, b) || (a < b ? -1 : a > b ? 1 : 0)).slice(0, 5).map((value) => ({ value, label: value, origin: narrative.origin, definition: `narratives/${id}#/beats` }));
     for (const reference of unknownBeatReferences(document, narrative))
       findings.push(
         finding("opf/unknown-beat", {
           path: reference.path,
           message: `Slide ${reference.slide + 1} names beat ${JSON.stringify(reference.beat)}, which narrative ${JSON.stringify(id)} does not define.`,
-          help: `Use one of the narrative's beat ids (${narrative.beats.join(", ")}), add the beat to the narrative record (an inline record in catalogs.narratives.records), or remove the beat link. Nothing is drawn from a beat.`,
+          help: `Use one of the narrative's beat ids (${narrative.beats.join(", ")}), add the beat to the narrative record (a record the document embeds or defines in catalogs.custom.narratives), or remove the beat link. Nothing is drawn from a beat.`,
           definition: schemas.presentation.$id + "#/$defs/Slide/properties/beat",
           lookup: ["opf", "catalog", "narratives"],
           suggestions: beatSuggestions(reference.beat)
@@ -3572,20 +3077,19 @@ function narrativeFindings(document, options) {
         })
       );
   }
-  const inlineNarratives = object(document.catalogs) && object(document.catalogs.narratives) ? document.catalogs.narratives.records : void 0;
-  if (Array.isArray(inlineNarratives))
-    inlineNarratives.forEach((record, index) => {
+  for (const [group, value] of Object.entries(object(document.catalogs) ? document.catalogs : {}))
+    for (const [id, record] of Object.entries(object(value) && object(value.narratives) ? value.narratives : {})) {
       if (durationRangeInverted(record))
         findings.push(
           finding("opf/narrative-duration-range", {
-            path: `/catalogs/narratives/records/${index}/duration`,
+            path: pointer3(["catalogs", group, "narratives", id, "duration"]),
             message: "The narrative duration range has min greater than max.",
             help: "Swap the bounds so min is the shortest and max the longest talk length, in minutes.",
             definition: schemas.narrative.$id + "#/properties/duration",
             lookup: ["opf", "schema", "narrative", "/properties/duration"]
           })
         );
-    });
+    }
   return findings;
 }
 function contractFindings(document, contracts) {
@@ -3742,52 +3246,27 @@ function parseSource(source) {
 }
 
 // src/slide-context.ts
-var DEFAULT_THEME = "minimal";
-var DEFAULT_COLOR_SCHEME = "cool-horizon";
 var rec2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function resolveSlideContext(presentation, index, options = {}) {
   const deck = rec2(presentation);
   const slides = Array.isArray(deck.slides) ? deck.slides : [];
   if (!Number.isInteger(index) || index < 0 || index >= slides.length) throw new RangeError(`Slide index ${String(index)} is outside the presentation's ${slides.length} slides.`);
   const slide = rec2(slides[index]);
-  const diagnostics = [];
-  const lookup = (kind, id) => {
-    const inline = rec2(rec2(deck.catalogs)[kind]).records;
-    const found = (Array.isArray(inline) ? inline : []).find((record) => record?.id === id) ?? (options.catalogs?.[kind] ?? []).find((record) => rec2(record).id === id) ?? catalogs[kind].find((record) => rec2(record).id === id);
-    return found === void 0 ? void 0 : rec2(found);
-  };
+  const catalogs = { catalogs: checkCatalogsOption(options.catalogs, "resolveSlideContext") };
+  const records = resolveDesignRecords(presentation, index, catalogs);
+  const diagnostics = [...records.diagnostics];
+  const { theme, colorScheme, fontScheme } = records;
   const design = { ...rec2(deck.design), ...rec2(slide.design) };
-  const own2 = rec2(slide.design), shared = rec2(deck.design);
-  const resolveReference = (kind, reference, path, code, fallbackId) => {
-    const object2 = typeof reference === "object" && reference !== null && !Array.isArray(reference) ? rec2(reference) : {};
-    const id = typeof reference === "string" ? reference : typeof object2.id === "string" ? object2.id : void 0;
-    if (id === void 0 && typeof reference === "object" && reference !== null && !Array.isArray(reference)) return { ...lookup(kind, fallbackId), ...object2 };
-    const found = id === void 0 ? void 0 : lookup(kind, id);
-    const inline = Object.keys(object2).some((key) => key !== "id");
-    if (id !== void 0 && found === void 0 && !inline) {
-      diagnostics.push({
-        code,
-        path,
-        id,
-        fallback: fallbackId,
-        message: `${kind === "themes" ? "Theme" : "Colour scheme"} '${id}' is not in the inline, host or bundled catalogs; using '${fallbackId}'.`
-      });
-      return { ...lookup(kind, fallbackId), ...object2 };
-    }
-    return { ...found, ...object2 };
-  };
-  const themePath = own2.theme !== void 0 ? `slides.${index}.design.theme` : "design.theme";
-  const theme = resolveReference("themes", design.theme ?? DEFAULT_THEME, themePath, "unresolved-theme", DEFAULT_THEME);
-  const colorSchemePath = own2.colorScheme !== void 0 ? `slides.${index}.design.colorScheme` : shared.colorScheme !== void 0 ? "design.colorScheme" : themePath;
-  const colorScheme = resolveReference("colorSchemes", design.colorScheme ?? theme.colorScheme ?? DEFAULT_COLOR_SCHEME, colorSchemePath, "unresolved-color-scheme", DEFAULT_COLOR_SCHEME);
-  const fontSchemePath = own2.fontScheme !== void 0 ? `slides.${index}.design.fontScheme` : shared.fontScheme !== void 0 ? "design.fontScheme" : themePath;
-  const font = resolveFontSchemeReference(design.fontScheme ?? theme.fontScheme ?? DEFAULT_FONT_SCHEME, (id) => lookup("fontSchemes", id), fontSchemePath);
-  if (font.diagnostic) diagnostics.push(font.diagnostic);
   let layout;
+  let layoutProvenance;
   if (typeof slide.layout === "string") {
-    layout = lookup("layouts", slide.layout);
-    if (!layout) diagnostics.push({ code: "unresolved-layout", path: `slides.${index}.layout`, id: slide.layout, message: `Layout '${slide.layout}' is not in the inline or bundled catalogs.` });
+    const found = resolveReference(presentation, "layouts", slide.layout, catalogs);
+    if (found) {
+      layout = { ...found.record };
+      layoutProvenance = provenanceOf(found);
+    } else diagnostics.push(unresolvedReference(presentation, "layouts", slide.layout, `slides.${index}.layout`, catalogs));
   }
+  if (options.strictReferences && diagnostics.length) throw new OPFUnresolvedReferenceError(diagnostics);
   const composeOptions = {
     ...resolveCanvasDimensions(design.dimensions ?? theme.dimensions),
     ...layout ? { layout } : {},
@@ -3795,13 +3274,13 @@ function resolveSlideContext(presentation, index, options = {}) {
     slideIndex: index,
     slideNumber: options.slideNumber ?? index + 1,
     slideCount: options.slideCount ?? slides.length,
-    fontFamilies: resolveFontFamilies(font.scheme),
+    fontFamilies: resolveFontFamilies(fontScheme),
     darkBackground: resolveColorRoles(colorScheme, { background: decisionColor(design.background ?? theme.background, colorScheme, rec2(deck.variables)) }).dark,
-    socialPlatforms: catalogs.socialPlatforms,
+    ...theme.background !== void 0 ? { themeBackground: theme.background } : {},
     ...options.fonts?.textMeasurement ? { textMeasurement: options.fonts.textMeasurement } : {},
     ...options.date !== void 0 ? { date: options.date } : {}
   };
-  return { options: composeOptions, diagnostics, resolved: { theme, colorScheme, fontScheme: font.scheme, fontSchemePath } };
+  return { options: composeOptions, diagnostics, resolved: { theme, colorScheme, fontScheme, fontSchemePath: records.fontSchemePath, ...layout ? { layout } : {}, provenance: { ...layoutProvenance ? { layout: layoutProvenance } : {}, ...records.provenance } } };
 }
 
 // src/rule-slides.ts
@@ -3897,12 +3376,12 @@ var OPFValidationError = class extends Error {
   report;
   /** The error-severity findings of the report. */
   findings;
-  constructor(report) {
-    const errors = report.findings.filter((entry) => entry.severity === "error");
+  constructor(report2) {
+    const errors = report2.findings.filter((entry) => entry.severity === "error");
     const first = errors[0];
     super(first ? `OPF validation failed at ${first.path || "/"}: ${first.message}` : "OPF validation failed");
     this.name = "OPFValidationError";
-    this.report = report;
+    this.report = report2;
     this.findings = errors;
   }
 };
@@ -4023,7 +3502,7 @@ function syntaxReport(parsed, run) {
   return { valid: tally.error === 0, schemaValid: null, findings, counts: tally, checks };
 }
 function validateDocument(document, run, parsed) {
-  const engine = validateAgainstSchema(document, "presentation", { template: run.options.template, values: run.options.values });
+  const engine = validateAgainstSchema(document, "presentation", { template: run.options.template, values: run.options.values, ...run.options.catalogs ? { catalogs: run.options.catalogs } : {} });
   const schemaValid = engine.errors.length === 0;
   const slides = isObject(document) && Array.isArray(document.slides) ? document.slides : [];
   const auditWanted = auditInfos.some((info) => run.enabled(info));
@@ -4032,6 +3511,7 @@ function validateDocument(document, run, parsed) {
   const findings = [];
   findings.push(...engineFindings(document, engine, (ruleId) => enabledRule(findValidationRule(ruleId))));
   if (enabledRule(findValidationRule("opf/variable-unfilled"))) findings.push(...variableFindings(document, engine, schemaValid));
+  if (enabledRule(findValidationRule("opf/undeclared-catalog"))) findings.push(...undeclaredCatalogFindings(document));
   if (parsed) {
     findings.push(...parsed.duplicates.filter((entry) => enabledRule(findValidationRule(entry.ruleId))));
   }
@@ -4048,13 +3528,11 @@ function validateDocument(document, run, parsed) {
   const auditRan = /* @__PURE__ */ new Set();
   if (schemaValid && auditWanted) {
     const doc = document;
-    const lookup = createLookup(doc, run.options.catalogs);
     const context = {
       document: doc,
       slides: buildSlides(doc, run.options),
       thresholds: run.thresholds,
       options: run.options,
-      lookup,
       chartPalette: run.chartPalette,
       report(info, input) {
         const severity = run.severity(info) ?? input.severity ?? info.severity;
@@ -4136,16 +3614,14 @@ function validate(input, options = {}) {
 }
 function assertValid(value, options = {}) {
   if (typeof value === "string") throw new TypeError("assertValid takes a parsed presentation. Use validate(text) for JSON text.");
-  const report = validate(value, options);
-  if (!report.valid) throw new OPFValidationError(report);
+  const report2 = validate(value, options);
+  if (!report2.valid) throw new OPFValidationError(report2);
 }
 function validateCatalogRecord(kind, value) {
-  if (!catalogKinds.includes(kind)) throw new TypeError(`Unknown catalog kind ${JSON.stringify(kind)}. Kinds: ${catalogKinds.join(", ")}.`);
+  const kinds = Object.keys(catalogSchemaNames);
+  if (!kinds.includes(kind)) throw new TypeError(`Unknown catalog kind ${JSON.stringify(kind)}. Kinds: ${kinds.join(", ")}.`);
   const engine = validateAgainstSchema(value, kind);
-  const findings = [
-    ...engine.errors.map((issue2) => issueFinding(issue2, issueRuleId(issue2), engine.schemaName)),
-    ...engine.warnings.map((issue2) => issueFinding(issue2, "opf/catalog-reference", engine.schemaName, "", "document", "warning"))
-  ];
+  const findings = engine.errors.map((issue2) => issueFinding(issue2, issueRuleId(issue2), engine.schemaName));
   const tally = counts(findings);
   const checks = {
     syntax: "not-applicable",
@@ -4160,8 +3636,8 @@ function validateCatalogRecord(kind, value) {
   return { valid: tally.error === 0, schemaValid: engine.valid, findings, counts: tally, checks };
 }
 function assertValidCatalogRecord(kind, value) {
-  const report = validateCatalogRecord(kind, value);
-  if (!report.valid) throw new OPFValidationError(report);
+  const report2 = validateCatalogRecord(kind, value);
+  if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules };
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, parseSource, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules };