@openpresentation/opf 0.26.10 → 0.28.0

package/dist/{chunk-IVPA6NG6.js → chunk-WPKCWQ6W.js}

@@ -1,7 +1,7 @@
-import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, normalizeColorVariant, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, defaultSlideBackground, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-XRMV2GMB.js';
-import { schemas, schemaEntries } from './chunk-F4HFDP6I.js';
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
+import { original } from './chunk-JBARNYFR.js';
+import { schemas, schemaEntries } from './chunk-5Q4IYLMW.js';
+import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, chartLeadFromScheme, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, normalizeColorVariant, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, defaultSlideBackground, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-2CUCYENF.js';
+import { schemaEngine } from '#schema-engine';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
 
 // src/catalog-schemas.ts
@@ -88,38 +88,9 @@ function unusedReferenceWarnings(value) {
 }
 
 // src/union-errors.ts
-var compiled = /* @__PURE__ */ new WeakMap();
-var origin = /* @__PURE__ */ new WeakMap();
 var isUnion = (error) => (error.keyword === "oneOf" || error.keyword === "anyOf") && Array.isArray(error.schema);
 var key = (error) => `${error.instancePath}\0${error.keyword}\0${error.message}\0${JSON.stringify(error.params)}`;
 var depth = (pointer4) => pointer4 ? pointer4.split("/").length - 1 : 0;
-var original = (node) => {
-  let current = node;
-  while (current && typeof current === "object" && origin.has(current)) current = origin.get(current);
-  return current;
-};
-function qualify(node, rootId) {
-  if (Array.isArray(node)) {
-    const copy = node.map((item) => qualify(item, rootId));
-    origin.set(copy, node);
-    return copy;
-  }
-  if (node && typeof node === "object") {
-    const copy = {};
-    for (const [name, value] of Object.entries(node)) copy[name] = name === "$ref" && typeof value === "string" && value.startsWith("#") ? rootId + value : qualify(value, rootId);
-    origin.set(copy, node);
-    return copy;
-  }
-  return node;
-}
-function branchValidator(ajv2, rootId, branch) {
-  let validate2 = compiled.get(branch);
-  if (!validate2) {
-    validate2 = ajv2.compile(qualify(branch, rootId));
-    compiled.set(branch, validate2);
-  }
-  return validate2;
-}
 function branchLabel(branch, index) {
   if (typeof branch.$ref === "string") return branch.$ref.slice(branch.$ref.lastIndexOf("/") + 1);
   if (typeof branch.type === "string") return branch.type;
@@ -135,12 +106,12 @@ function describe(errors, base) {
   const rest = shallow.instancePath.split("/").slice(base + 1).join("/");
   return depth(shallow.instancePath) === base || !rest ? shallow.message ?? "does not match" : `${shallow.message} at /${rest}`;
 }
-function bestMatchErrors(ajv2, rootId, errors) {
+function bestMatchErrors(engine, rootId, errors) {
   const unions = errors.filter(isUnion);
   if (!unions.length) return errors;
   const analyses = [];
   for (const union of unions) {
-    const analysis = analyze(ajv2, rootId, union);
+    const analysis = analyze(engine, rootId, union);
     if (analysis) analyses.push(analysis);
   }
   if (!analyses.length) return errors;
@@ -156,19 +127,20 @@ function bestMatchErrors(ajv2, rootId, errors) {
   }
   return result;
 }
-function analyze(ajv2, rootId, union) {
+function analyze(engine, rootId, union) {
   const branches = union.schema;
   const base = depth(union.instancePath);
   const results = [];
   for (const [index, branch] of branches.entries()) {
     if (!branch || typeof branch !== "object") return void 0;
-    const validate2 = branchValidator(ajv2, rootId, branch);
+    const validate2 = engine.branch(branch, rootId);
+    if (!validate2) return void 0;
     if (validate2(union.data) === true) return void 0;
     const raw = (validate2.errors ?? []).map((error) => ({ ...error, instancePath: union.instancePath + error.instancePath }));
     results.push({ label: branchLabel(branch, index), errors: raw });
   }
   const span = /* @__PURE__ */ new Set([key(union), ...results.flatMap((result) => result.errors.map(key))]);
-  const reduced = results.map((result) => ({ label: result.label, errors: bestMatchErrors(ajv2, rootId, result.errors) }));
+  const reduced = results.map((result) => ({ label: result.label, errors: bestMatchErrors(engine, rootId, result.errors) }));
   const mismatch = (error) => {
     const level = depth(error.instancePath) - base;
     return level === 0 && (error.keyword === "type" || isUnion(error)) || level === 1 && error.keyword === "const";
@@ -248,7 +220,6 @@ function validationDefinition(issue2) {
 
 // src/schema-check.ts
 var schemaNameByCatalogKind = catalogSchemaNames;
-var ajv;
 var promotedRegionKeySet = new Set(promotedRegionKeys);
 var rootPayloadFields = [
   "type",
@@ -326,23 +297,6 @@ var rowSpans = {
   "middle+bottom": [1, 2],
   "top+middle+bottom": [0, 1, 2]
 };
-function getAjv() {
-  if (ajv) {
-    return ajv;
-  }
-  const instance = new Ajv2020({
-    allErrors: true,
-    verbose: true,
-    strict: false,
-    allowUnionTypes: true
-  });
-  addFormats(instance);
-  for (const schema of Object.values(schemas)) {
-    instance.addSchema(schema);
-  }
-  ajv = instance;
-  return instance;
-}
 function isSchemaName(value) {
   return typeof value === "string" && hasOwn(schemas, value);
 }
@@ -350,17 +304,12 @@ function isCatalogKind(value) {
   return typeof value === "string" && hasOwn(schemaNameByCatalogKind, value);
 }
 function resolveValidator(schemaOrKind) {
-  const instance = getAjv();
   if (isSchemaName(schemaOrKind)) {
-    const schema = schemas[schemaOrKind];
-    const validator = instance.getSchema(schema.$id) ?? instance.compile(schema);
-    return { validate: validator, schemaName: schemaOrKind };
+    return { validate: schemaEngine().root(schemaOrKind), schemaName: schemaOrKind };
   }
   if (isCatalogKind(schemaOrKind)) {
     const schemaName = schemaNameByCatalogKind[schemaOrKind];
-    const schema = schemas[schemaName];
-    const validator = instance.getSchema(schema.$id) ?? instance.compile(schema);
-    return { validate: validator, schemaName, catalogKind: schemaOrKind };
+    return { validate: schemaEngine().root(schemaName), schemaName, catalogKind: schemaOrKind };
   }
   throw new TypeError(`Unknown schema or catalog kind ${JSON.stringify(schemaOrKind)}.`);
 }
@@ -983,7 +932,6 @@ function typedVariableErrors(errors, value) {
   if (!errors.some((error) => error.instancePath.startsWith("/variables/"))) return errors;
   const variables = value.variables;
   const kept = errors.filter((error) => !error.instancePath.startsWith("/variables/"));
-  const schemaId = schemas.presentation.$id;
   for (const [id, entry2] of Object.entries(variables)) {
     if (typeof entry2 === "string") {
       if (!hexColorPattern.test(entry2)) kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
@@ -999,7 +947,7 @@ function typedVariableErrors(errors, value) {
       continue;
     }
     const definition = `${kind.charAt(0).toUpperCase()}${kind.slice(1)}Variable`;
-    const check = getAjv().getSchema(`${schemaId}#/$defs/${definition}`);
+    const check = schemaEngine().definition("presentation", definition);
     if (!check || check(entry2) === true) continue;
     for (const error of check.errors ?? []) {
       kept.push({ ...error, instancePath: `/variables/${id.replaceAll("~", "~0").replaceAll("/", "~1")}${error.instancePath}`, schemaPath: `#/$defs/${definition}${error.schemaPath.replace(/^#/, "")}` });
@@ -1020,7 +968,6 @@ function pointerValue(root, pointer4) {
 var datasetTableMessage = (field) => `'${field}' is not allowed on a dataset-backed table: it takes its headers, rows and column formats from the dataset`;
 function dataUnionErrors(errors, value) {
   let kept = errors;
-  const schemaId = schemas.presentation.$id;
   for (const union of errors) {
     if (union.keyword !== "oneOf") continue;
     const chartData = /\/chart\/data$/.test(union.instancePath) && /\/properties\/data\/oneOf$/.test(union.schemaPath);
@@ -1029,7 +976,7 @@ function dataUnionErrors(errors, value) {
     const target = pointerValue(value, union.instancePath);
     if (!isRecord(target)) continue;
     const branch = chartData ? hasOwn(target, "dataset") ? "DatasetRef" : hasOwn(target, "rows") ? "ChartData" : void 0 : hasOwn(target, "value") ? "StyledTableCell" : hasOwn(target, "name") ? "DataColumn" : void 0;
-    const check = branch ? getAjv().getSchema(`${schemaId}#/$defs/${branch}`) : void 0;
+    const check = branch ? schemaEngine().definition("presentation", branch) : void 0;
     if (!check || check(target) === true) continue;
     const branchErrors = (check.errors ?? []).map((error) => ({ ...error, instancePath: `${union.instancePath}${error.instancePath}`, schemaPath: `#/$defs/${branch}${error.schemaPath.replace(/^#/, "")}` }));
     const prefix = `${union.instancePath}/`;
@@ -1076,7 +1023,7 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options2 =
   const valid = resolved.validate(subject) === true;
   const ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
   const specific = resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors;
-  const mapped = bestMatchErrors(getAjv(), schemas[resolved.schemaName].$id, specific).map(toIssue);
+  const mapped = bestMatchErrors(schemaEngine(), schemas[resolved.schemaName].$id, specific).map(toIssue);
   const errors = mapped;
   if (resolved.schemaName === "layout" && valid) for (const issue2 of layoutTemplateIssues(subject)) errors.push(semanticIssue(issue2.path, issue2.message, { code: issue2.code }));
   const warnings = [];
@@ -1625,7 +1572,7 @@ var formatRules = [
     "error",
     "The document breaks the OPF schema or a structural rule the schema cannot express.",
     "The schema is the contract every engine, exporter and editor relies on. A field of the wrong type, a missing required field, an unknown property or content fields that cannot be mixed make the document ambiguous or undrawable.",
-    { standard: SCHEMA, approximations: "All alternatives of a union are reported, with the failing schema location in `validation`. A required variable with no value is reported by `opf/variable-unfilled`, in the same category." }
+    { standard: SCHEMA, approximations: "All alternatives of a union are reported, with the failing schema location in `validation`. A required variable with no value is reported by `opf/variable-unfilled`, in the same category. A chart written in the Chart.js or ECharts shape (`categories` and `series`, or `labels` and `datasets`, and no `data`) is one finding on the chart whose hint shows its own values as `data: { columns, rows }`, with a patch fix; the additional-property findings that repeat it are dropped." }
   ),
   rule("reference-id-duplicate", "format", "error", "Two references share an id.", "A citation names a reference by id; a repeated id makes it ambiguous which entry is cited.", { standard: SCHEMA }),
   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 }),
@@ -1707,7 +1654,7 @@ var referenceRules = [
     "warning",
     "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." }
+    { 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. It is a warning, not an error, because catalogs are open and a host may register the id; `--fail-on warning` is the check that a deck is done. With a catalog registered, the hint names the nearest records that exist ("Did you mean `two-column`?").' }
   ),
   rule(
     "catalog-record-not-in-source",
@@ -1825,7 +1772,7 @@ var readingOrderRule = rule(
   {
     standard: 'WCAG 2.2 SC 1.3.2 Meaningful Sequence, level A (PowerPoint: "Check reading order")',
     cost: "composition",
-    approximations: "Compares the composed content order with a visual order recomputed from the composed boxes: items whose vertical centres fall in the same row are ordered along the reading direction (a right-to-left deck is checked by rows only), rows from top to bottom. Headings are expected first. Free-form overlap is not analysed. On a slide with a template layout (OPF 0.19) the expected order is the binding order instead (the regions in reading order, then the blocks of each region), and items outside a region (placed images, the row below the grid) are not compared."
+    approximations: "Compares the composed content order with a visual order recomputed from the composed boxes: items whose vertical centres fall in the same row are ordered along the reading direction (a right-to-left deck is checked by rows only), rows from top to bottom. Headings are expected first. Content drawn entirely above the title, over the columns of the title, is reported; content in a column beside the title is read after it. Free-form overlap is not analysed. On a slide with a template layout (OPF 0.19) the expected order is the binding order instead (the regions in reading order, then the blocks of each region), and items outside a region (placed images, the row below the grid) are not compared."
   }
 );
 var linkRule = rule(
@@ -2358,8 +2305,9 @@ var readingOrderRules = [
         if (!composition) continue;
         const body = composition.items.filter((item) => !["title", "subtitle", "tag"].includes(item.field));
         const title = composition.items.find((item) => item.field === "title");
-        if (title && body.some((item) => item.box.y + item.box.height <= title.box.y + 1)) {
-          const above = body.find((item) => item.box.y + item.box.height <= title.box.y + 1);
+        const isAbove = (item) => item.box.y + item.box.height <= title.box.y + 1 && item.box.x < title.box.x + title.box.width && title.box.x < item.box.x + item.box.width;
+        if (title && body.some(isAbove)) {
+          const above = body.find(isAbove);
           context.report(readingOrderRule, {
             path: pointerOfDotted(above.path),
             slide,
@@ -2457,7 +2405,8 @@ var chartRules = [
           const count = slices ? data.rows.length : data.columns.length - 1;
           if (count < 2) continue;
           const surface = slide.design.colors.surface;
-          const palette = chartPaletteForFill(surface, context.chartPalette ?? chartSeriesPalette(slide.design.colorScheme, chart.colors, chartColorContext(slide.design)));
+          const paletteContext = chartColorContext(slide.design);
+          const palette = chartPaletteForFill(surface, context.chartPalette ?? chartSeriesPalette(slide.design.colorScheme, chart.colors, paletteContext), { legibleLead: context.chartPalette === void 0 && chartLeadFromScheme(chart.colors, slide.design.colorScheme, paletteContext) });
           if (!palette.length) continue;
           const used = Array.from({ length: Math.min(count, 24) }, (_, i) => palette[i % palette.length]);
           const pairs = [];
@@ -2897,6 +2846,60 @@ var layoutContentRules = [
 // src/validation-rules.ts
 var ruleImplementations = [...accessibilityRules, ...layoutContentRules, ...languageTagRules];
 
+// src/chart-shape.ts
+var FOREIGN_CHART_KEYS = ["categories", "series", "labels", "datasets"];
+var CHART_DEFINITION = "https://openpresentation.org/schema/opf/v1#/$defs/Chart";
+var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isCell = (value) => value === null || ["string", "number", "boolean"].includes(typeof value);
+function foreignChartKeys(chart) {
+  if (!isRecord2(chart) || Object.hasOwn(chart, "data")) return [];
+  return FOREIGN_CHART_KEYS.filter((key2) => Object.hasOwn(chart, key2));
+}
+function convertChartData(chart) {
+  const labels = chart.categories ?? chart.labels;
+  const series = chart.series ?? chart.datasets;
+  if (!Array.isArray(labels) || !labels.length || !labels.every(isCell) || !Array.isArray(series) || !series.length) return void 0;
+  const columns = ["Category"];
+  const values = [];
+  for (const [index, entry2] of series.entries()) {
+    if (!isRecord2(entry2)) return void 0;
+    const list = entry2.values ?? entry2.data;
+    const name = entry2.name ?? entry2.label;
+    if (!Array.isArray(list) || list.length !== labels.length || !list.every(isCell)) return void 0;
+    columns.push(typeof name === "string" && name ? name : `Series ${index + 1}`);
+    values.push(list);
+  }
+  if (new Set(columns).size !== columns.length) return void 0;
+  return { columns, rows: labels.map((label, row) => [label, ...values.map((list) => list[row])]) };
+}
+function chartShapePatch(chart, path) {
+  if (!isRecord2(chart)) return void 0;
+  const data = convertChartData(chart);
+  const keys = foreignChartKeys(chart);
+  if (!data || !keys.length) return void 0;
+  return [{ op: "add", path: `${path}/data`, value: data }, ...keys.map((key2) => ({ op: "remove", path: `${path}/${key2}` }))];
+}
+var SHOWN_ROWS = 3;
+var json = (value) => JSON.stringify(value);
+function dataExample(chart) {
+  const data = convertChartData(chart);
+  if (!data) return '"data": { "columns": ["Category", "Series name"], "rows": [["Q1", 3], ["Q2", 8]] }';
+  const rows = data.rows.slice(0, SHOWN_ROWS).map(json);
+  return `"data": { "columns": ${json(data.columns)}, "rows": [${rows.join(",")}${data.rows.length > SHOWN_ROWS ? ",..." : ""}] }`;
+}
+function chartShapeHelp(chart) {
+  const keys = foreignChartKeys(chart);
+  if (!keys.length || !isRecord2(chart)) return void 0;
+  const names2 = keys.map((key2) => `"${key2}"`).join(" and ");
+  const example = dataExample(chart);
+  const next = `replace ${names2} with ${example}. The first column holds the category labels and each further column is one series.`;
+  return {
+    message: `The chart has ${names2} (the Chart.js and ECharts shape), but an OPF chart keeps its values in "data": { "columns", "rows" }.`,
+    next,
+    help: `OPF charts use "data": { "columns", "rows" }, not ${names2}. Replace ${names2} with ${example}; the first column holds the category labels and each further column is one series. See the Chart definition: ${CHART_DEFINITION} (opf schema presentation '/$defs/Chart').`
+  };
+}
+
 // src/check-document.ts
 var own = (value, key2) => Object.hasOwn(value, key2);
 var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3219,12 +3222,42 @@ var HELP = {
   "numbering-start-ignored": "Add a 'numbering' field to the payload, or remove 'start'.",
   "slide-size-out-of-range": "Use a custom widthInches and heightInches between 1 and 56, or a preset. PowerPoint stores the slide size in 914400 to 51206400 EMU per side."
 };
+function collapseChartShape(document, findings) {
+  const chartAt = (path) => {
+    let node = document;
+    for (const segment of splitPointer(path)) node = Array.isArray(node) ? node[Number(segment)] : isRecord(node) ? node[segment] : void 0;
+    return node;
+  };
+  const collapsed = /* @__PURE__ */ new Set();
+  for (const [index, entry2] of findings.entries()) {
+    if (entry2.ruleId !== "opf/schema" || entry2.validation?.keyword !== "required" || entry2.validation.params.missingProperty !== "data") continue;
+    const chart = chartAt(entry2.path);
+    const hint = chartShapeHelp(chart);
+    if (!hint) continue;
+    const patch2 = chartShapePatch(chart, entry2.path);
+    findings[index] = {
+      ...entry2,
+      message: hint.message,
+      help: hint.help,
+      ...patch2 ? { fixes: [{ id: "convert-chart-data", title: "Convert to data: { columns, rows }", kind: "patch", safe: false, patch: patch2 }] } : {}
+    };
+    collapsed.add(entry2.path);
+  }
+  if (!collapsed.size) return;
+  for (let index = findings.length - 1; index >= 0; index--) {
+    const entry2 = findings[index];
+    if (entry2?.ruleId !== "opf/schema" || entry2.validation?.keyword !== "additionalProperties") continue;
+    const at2 = entry2.path.lastIndexOf("/");
+    if (collapsed.has(entry2.path.slice(0, at2)) && FOREIGN_CHART_KEYS.includes(entry2.path.slice(at2 + 1))) findings.splice(index, 1);
+  }
+}
 function engineFindings(document, engine, enabled) {
   const findings = [];
   for (const issue2 of engine.errors) {
     const ruleId = issueRuleId(issue2);
     if (enabled(ruleId)) findings.push(issueFinding(issue2, ruleId));
   }
+  collapseChartShape(document, findings);
   let numberFixes;
   for (const issue2 of engine.warnings) {
     const code2 = issue2.params.code;
@@ -3326,6 +3359,13 @@ function undeclaredCatalogFindings(document) {
   }
   return findings;
 }
+var KIND_PLURAL = { layouts: "layouts", themes: "themes", colorSchemes: "color schemes", fontSchemes: "font schemes", narratives: "narratives", audiences: "audiences", purposes: "purposes", tones: "tones" };
+function nearestRecords(kind, reference, candidates) {
+  if (!candidates.length) return "";
+  const close = candidates.filter((value) => distance(reference, value) <= Math.max(2, Math.floor(reference.length / 4))).slice(0, 3);
+  const quote = (values) => values.map((value) => `'${value}'`).join(", ");
+  return close.length ? `Did you mean ${quote(close)}? ` : `The nearest ${KIND_PLURAL[kind]} that exist: ${quote(candidates.slice(0, 3))}. `;
+}
 function contentReferenceFindings(document, options2, findings) {
   const invalid = embeddedRecordFindings(document, options2, findings);
   const registeredChecked = /* @__PURE__ */ new Set();
@@ -3346,7 +3386,7 @@ function contentReferenceFindings(document, options2, findings) {
       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.",
+        help: `${nearestRecords(site.kind, site.reference, suggestions.map((entry2) => entry2.value))}${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
@@ -3526,6 +3566,157 @@ function contractFindings(document, contracts) {
   return findings;
 }
 
+// src/document-hash.ts
+function canonicalJson(value) {
+  const stack = [];
+  const write = (item) => {
+    if (item === null || typeof item === "boolean" || typeof item === "string") return JSON.stringify(item);
+    if (typeof item === "number") return JSON.stringify(item);
+    if (typeof item === "bigint") throw new TypeError("A BigInt is not JSON.");
+    if (typeof item !== "object") return void 0;
+    if (stack.includes(item)) throw new TypeError("A cyclic value has no canonical JSON.");
+    stack.push(item);
+    let text2;
+    if (Array.isArray(item)) {
+      text2 = `[${item.map((entry2) => write(entry2) ?? "null").join(",")}]`;
+    } else {
+      const record = item;
+      const members = [];
+      for (const key2 of Object.keys(record).sort()) {
+        const member = write(record[key2]);
+        if (member !== void 0) members.push(`${JSON.stringify(key2)}:${member}`);
+      }
+      text2 = `{${members.join(",")}}`;
+    }
+    stack.pop();
+    return text2;
+  };
+  return write(value) ?? "null";
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(bytes) {
+  const length = bytes.length;
+  const padded = new Uint8Array(length + 9 + 63 >> 6 << 6);
+  padded.set(bytes);
+  padded[length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(length / 536870912), false);
+  view.setUint32(padded.length - 4, length << 3 >>> 0, false);
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 64; i += 1) {
+      const a2 = w[i - 15], b2 = w[i - 2];
+      const s0 = (a2 >>> 7 | a2 << 25) ^ (a2 >>> 18 | a2 << 14) ^ a2 >>> 3;
+      const s1 = (b2 >>> 17 | b2 << 15) ^ (b2 >>> 19 | b2 << 13) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+    }
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const choose = e & f ^ ~e & g;
+      const t1 = hh + s1 + choose + K[i] + w[i] | 0;
+      const s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const majority = a & b ^ a & c ^ b & c;
+      const t2 = s0 + majority | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  let hex = "";
+  for (const word of h) hex += word.toString(16).padStart(8, "0");
+  return hex;
+}
+function documentHash(document) {
+  return `sha256:${sha256Hex(new TextEncoder().encode(canonicalJson(document)))}`;
+}
+var HASH_PATTERN = /^(?:sha256:)?([0-9a-fA-F]{64})$/;
+function normalizeDocumentHash(value) {
+  if (typeof value !== "string") return void 0;
+  const match2 = HASH_PATTERN.exec(value);
+  return match2 ? `sha256:${match2[1].toLowerCase()}` : void 0;
+}
+
 // src/patch.ts
 var OPFPatchError = class extends Error {
   code;
@@ -3552,6 +3743,18 @@ var OPFPatchValidationError = class extends OPFPatchError {
     this.validation = validation;
   }
 };
+var OPFPatchHashError = class extends OPFPatchError {
+  /** The hash the caller expected, in the form `documentHash` returns. */
+  expected;
+  /** The hash of the document the patch was given. */
+  actual;
+  constructor(expected, actual) {
+    super("patch-hash-mismatch", "The document changed since it was read: its hash is not the expected hash. Nothing was applied.");
+    this.name = "OPFPatchHashError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
 var own2 = (value, key2) => Object.prototype.hasOwnProperty.call(value, key2);
 var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var clone = (value) => structuredClone(value);
@@ -3597,13 +3800,83 @@ function splitPointer2(pointer4) {
   if (!tokens.length) throw new OPFPatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer4 });
   return { parent: formatPointer(tokens.slice(0, -1)), token: tokens[tokens.length - 1] };
 }
+var isIdToken = (token) => token.length > 1 && token.startsWith("@");
+var idToken = (id) => `@${id}`;
+var INDEX_TOKEN = /^(0|[1-9][0-9]*)$/;
+function indexOfId(array, id) {
+  let found = -1;
+  for (let i = 0; i < array.length; i += 1) {
+    const item = array[i];
+    if (isObject(item) && own2(item, "id") && item.id === id) {
+      if (found !== -1) return -2;
+      found = i;
+    }
+  }
+  return found;
+}
+function uniqueIdAt(array, at2) {
+  const item = array[at2];
+  if (!isObject(item) || !own2(item, "id") || typeof item.id !== "string" || item.id === "") return void 0;
+  return indexOfId(array, item.id) === at2 ? item.id : void 0;
+}
+function resolveTokens(document, tokens, pointer4) {
+  const out = [];
+  let cursor = document, walking = true;
+  for (const token of tokens) {
+    let resolved = token;
+    if (walking && Array.isArray(cursor) && isIdToken(token)) {
+      const at2 = indexOfId(cursor, token.slice(1));
+      if (at2 === -1) throw new OPFPatchError("patch-id-not-found", `No element of ${formatPointer(out) || "/"} has the id '${token.slice(1)}'.`, { path: pointer4 });
+      if (at2 === -2) throw new OPFPatchError("patch-id-ambiguous", `More than one element of ${formatPointer(out) || "/"} has the id '${token.slice(1)}'.`, { path: pointer4 });
+      resolved = String(at2);
+    }
+    out.push(resolved);
+    if (walking) {
+      const next = readPointer(cursor, [resolved]);
+      if (next.found) cursor = next.value;
+      else walking = false;
+    }
+  }
+  return out;
+}
+function resolveIdPointer(document, pointer4) {
+  const tokens = parsePointer(pointer4);
+  return tokens.some(isIdToken) ? formatPointer(resolveTokens(document, tokens, pointer4)) : pointer4;
+}
+function idTokens(document, tokens, convertLast) {
+  const out = [];
+  let cursor = document, walking = true;
+  tokens.forEach((token, i) => {
+    let named = token;
+    if (walking && Array.isArray(cursor) && INDEX_TOKEN.test(token) && (convertLast || i < tokens.length - 1)) {
+      const id = uniqueIdAt(cursor, Number(token));
+      if (id !== void 0) named = idToken(id);
+    }
+    out.push(named);
+    if (walking) {
+      const next = readPointer(cursor, [token]);
+      if (next.found) cursor = next.value;
+      else walking = false;
+    }
+  });
+  return out;
+}
+function toIdPointer(document, pointer4, options2 = {}) {
+  return formatPointer(idTokens(document, resolveTokens(document, parsePointer(pointer4), pointer4), !options2.keepLast));
+}
 function readPointer(document, pointer4) {
   const tokens = typeof pointer4 === "string" ? parsePointer(pointer4) : pointer4;
   let value = document;
   for (const token of tokens) {
     if (Array.isArray(value)) {
-      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { found: false };
-      const at2 = Number(token);
+      let at2;
+      if (isIdToken(token)) {
+        at2 = indexOfId(value, token.slice(1));
+        if (at2 < 0) return { found: false };
+      } else {
+        if (!INDEX_TOKEN.test(token)) return { found: false };
+        at2 = Number(token);
+      }
       if (!Number.isSafeInteger(at2) || at2 >= value.length) return { found: false };
       value = value[at2];
     } else if (value && typeof value === "object" && own2(value, token)) value = value[token];
@@ -3622,7 +3895,7 @@ function getAtPointer(document, pointer4) {
 var hasPointer = (document, pointer4) => readPointer(document, pointer4).found;
 function arrayIndex(token, length, allowEnd, path) {
   if (allowEnd && token === "-") return length;
-  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
+  if (!INDEX_TOKEN.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
   const at2 = Number(token);
   if (!Number.isSafeInteger(at2) || at2 > length || !allowEnd && at2 >= length) throw new OPFPatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
   return at2;
@@ -3667,38 +3940,42 @@ function parentOf(document, tokens, path) {
 }
 var NONE = /* @__PURE__ */ Symbol("none");
 function addAt(document, path, value) {
-  const tokens = parsePointer(path);
-  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const tokens = resolveTokens(document, parsePointer(path), path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) }, pointer: "" };
   const { parent, key: key2 } = parentOf(document, tokens, path);
   if (Array.isArray(parent)) {
     const at2 = arrayIndex(key2, parent.length, true, path);
     parent.splice(at2, 0, clone(value));
-    return { document, inverse: { op: "remove", path: formatPointer([...tokens.slice(0, -1), at2]) } };
+    const pointer5 = formatPointer([...tokens.slice(0, -1), at2]);
+    return { document, inverse: { op: "remove", path: pointer5 }, pointer: pointer5 };
   }
   const record = parent;
   const previous = own2(record, key2) ? record[key2] : NONE;
   Object.defineProperty(record, key2, { value: clone(value), enumerable: true, configurable: true, writable: true });
-  return { document, inverse: previous === NONE ? { op: "remove", path } : { op: "replace", path, value: clone(previous) } };
+  const pointer4 = formatPointer(tokens);
+  return { document, inverse: previous === NONE ? { op: "remove", path: pointer4 } : { op: "replace", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function replaceAt(document, path, value) {
-  const tokens = parsePointer(path);
-  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const tokens = resolveTokens(document, parsePointer(path), path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) }, pointer: "" };
   const { parent, key: key2 } = parentOf(document, tokens, path);
   let previous;
+  let pointer4 = formatPointer(tokens);
   if (Array.isArray(parent)) {
     const at2 = arrayIndex(key2, parent.length, false, path);
     previous = parent[at2];
     parent[at2] = clone(value);
+    pointer4 = formatPointer([...tokens.slice(0, -1), at2]);
   } else {
     const record = parent;
     if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
     previous = record[key2];
     Object.defineProperty(record, key2, { value: clone(value), enumerable: true, configurable: true, writable: true });
   }
-  return { document, inverse: { op: "replace", path, value: clone(previous) } };
+  return { document, inverse: { op: "replace", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function removeAt(document, path) {
-  const tokens = parsePointer(path);
+  const tokens = resolveTokens(document, parsePointer(path), path);
   if (!tokens.length) throw new OPFPatchError("patch-root-remove", "The document root cannot be removed.", { path });
   const { parent, key: key2 } = parentOf(document, tokens, path);
   let previous;
@@ -3706,60 +3983,71 @@ function removeAt(document, path) {
     const at2 = arrayIndex(key2, parent.length, false, path);
     previous = parent[at2];
     parent.splice(at2, 1);
-    return { document, inverse: { op: "add", path: formatPointer([...tokens.slice(0, -1), at2]), value: clone(previous) } };
+    const pointer5 = formatPointer([...tokens.slice(0, -1), at2]);
+    return { document, inverse: { op: "add", path: pointer5, value: clone(previous) }, pointer: pointer5 };
   }
   const record = parent;
   if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
   previous = record[key2];
   delete record[key2];
-  return { document, inverse: { op: "add", path, value: clone(previous) } };
+  const pointer4 = formatPointer(tokens);
+  return { document, inverse: { op: "add", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function applyOne(document, operation) {
   switch (operation.op) {
     case "add": {
       const r = addAt(document, operation.path, operation.value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "add", path: r.pointer, value: operation.value } };
     }
     case "replace": {
       const r = replaceAt(document, operation.path, operation.value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "replace", path: r.pointer, value: operation.value } };
     }
     case "remove": {
       const r = removeAt(document, operation.path);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "remove", path: r.pointer } };
     }
     case "test": {
       const found = readPointer(document, operation.path);
       if (!found.found || !jsonEqual(found.value, operation.value)) throw new OPFPatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
-      return { document, inverse: [] };
+      return { document, inverse: [], resolved: { op: "test", path: resolveIdPointer(document, operation.path), value: operation.value } };
     }
     case "copy": {
-      const value = clone(getAtPointer(document, operation.from));
+      const from = resolveIdPointer(document, operation.from);
+      const value = clone(getAtPointer(document, from));
       const r = addAt(document, operation.path, value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "copy", from, path: r.pointer } };
     }
     case "move": {
-      const from = parsePointer(operation.from), to = parsePointer(operation.path);
+      const from = resolveTokens(document, parsePointer(operation.from), operation.from);
+      let to;
+      try {
+        to = resolveTokens(document, parsePointer(operation.path), operation.path);
+      } catch {
+        to = parsePointer(operation.path);
+      }
       const value = clone(getAtPointer(document, from));
-      if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [] };
+      if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [], resolved: { op: "move", from: formatPointer(from), path: formatPointer(to) } };
       if (to.length > from.length && from.every((token, i) => to[i] === token)) {
         throw new OPFPatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
       }
-      const removed = removeAt(document, operation.from);
+      const removed = removeAt(document, formatPointer(from));
       const added = addAt(removed.document, operation.path, value);
-      return { document: added.document, inverse: [added.inverse, removed.inverse] };
+      return { document: added.document, inverse: [added.inverse, removed.inverse], resolved: { op: "move", from: removed.pointer, path: added.pointer } };
     }
   }
 }
-function applyPatchWithInverse(document, patch2, options2 = {}) {
+function walkPatch(document, patch2, hooks = {}) {
   const operations = normalizePatch(patch2);
   let working = clone(document);
   const inverse = [];
   for (const [index, operation] of operations.entries()) {
     try {
-      const step = applyOne(working, operation);
-      working = step.document;
-      inverse.unshift(...step.inverse);
+      hooks.before?.(index, operation, working);
+      const applied = applyOne(working, operation);
+      working = applied.document;
+      inverse.unshift(...applied.inverse);
+      hooks.after?.({ index, operation, resolved: applied.resolved, inverse: applied.inverse }, working);
     } catch (error) {
       if (error instanceof OPFPatchError && error.index === void 0) {
         const wrapped = new OPFPatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
@@ -3768,6 +4056,17 @@ function applyPatchWithInverse(document, patch2, options2 = {}) {
       throw error;
     }
   }
+  return { document: working, operations, inverse };
+}
+function assertExpectedHash(document, expectHash) {
+  const expected = normalizeDocumentHash(expectHash);
+  if (expected === void 0) throw new OPFPatchError("invalid-expect-hash", "expectHash must be a document hash: the value documentHash(document) returns.");
+  const actual = documentHash(document);
+  if (actual !== expected) throw new OPFPatchHashError(expected, actual);
+}
+function applyPatchWithInverse(document, patch2, options2 = {}) {
+  if (options2.expectHash !== void 0) assertExpectedHash(document, options2.expectHash);
+  const { document: working, operations, inverse } = walkPatch(document, patch2);
   const result = { presentation: working, inverse, patch: operations };
   if (options2.validate) {
     const validator = typeof options2.validate === "function" ? options2.validate : (value) => validate(value, { only: options2.strict ? ["format", "references"] : ["format"] });
@@ -3783,6 +4082,50 @@ function applyPatch(document, patch2, options2 = {}) {
 function invertPatch(document, patch2) {
   return applyPatchWithInverse(document, patch2).inverse;
 }
+function resolveIdPatch(document, patch2) {
+  const resolved = [];
+  walkPatch(document, patch2, { after: (step) => {
+    resolved.push(step.resolved);
+  } });
+  return resolved;
+}
+function toIdPatch(document, patch2) {
+  const out = [];
+  const pending = /* @__PURE__ */ new Map();
+  walkPatch(document, patch2, {
+    before: (index, operation, working) => {
+      const named = (pointer4) => toIdPointer(working, pointer4);
+      switch (operation.op) {
+        case "replace":
+        case "remove":
+        case "test":
+          pending.set(index, { ...operation, path: named(operation.path) });
+          break;
+        case "copy":
+          pending.set(index, { ...operation, from: named(operation.from), path: toIdPointer(working, operation.path, { keepLast: true }) });
+          break;
+        case "add":
+          pending.set(index, { ...operation, path: toIdPointer(working, operation.path, { keepLast: true }) });
+          break;
+        case "move":
+          pending.set(index, { ...operation, from: named(operation.from) });
+          break;
+      }
+    },
+    after: (step, working) => {
+      const early = pending.get(step.index);
+      pending.delete(step.index);
+      if (step.operation.op !== "move") {
+        out.push(early);
+        return;
+      }
+      const appended = parsePointer(step.operation.path).at(-1) === "-";
+      const destination = toIdPointer(working, step.resolved.path, { keepLast: true });
+      out.push({ ...early, path: appended ? formatPointer([...parsePointer(destination).slice(0, -1), "-"]) : destination });
+    }
+  });
+  return out;
+}
 
 // src/schema-catalog-kinds.ts
 var schemaCatalogKinds = {
@@ -5473,12 +5816,12 @@ function asNext(text2) {
   const trimmed = text2.trim();
   return /^[A-Z][a-z]/.test(trimmed) ? trimmed.charAt(0).toLowerCase() + trimmed.slice(1) : trimmed;
 }
-var isRecord2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isRecord3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 function readAt(document, segments) {
   let value = document;
   for (const segment of segments) {
     if (Array.isArray(value)) value = value[Number(segment)];
-    else if (isRecord2(value)) value = value[segment];
+    else if (isRecord3(value)) value = value[segment];
     else return void 0;
   }
   return value;
@@ -5543,11 +5886,11 @@ function dotted(segments) {
 }
 function keysAt(helpers, path) {
   const value = helpers.valueAt(path);
-  return isRecord2(value) ? Object.keys(value) : [];
+  return isRecord3(value) ? Object.keys(value) : [];
 }
 function idsAt(helpers, path) {
   const value = helpers.valueAt(path);
-  return Array.isArray(value) ? value.flatMap((entry2) => isRecord2(entry2) && typeof entry2.id === "string" ? [entry2.id] : []) : [];
+  return Array.isArray(value) ? value.flatMap((entry2) => isRecord3(entry2) && typeof entry2.id === "string" ? [entry2.id] : []) : [];
 }
 function codeList(names2, max = 5, joiner = "and") {
   const shown = names2.slice(0, max).map(code);
@@ -5588,7 +5931,7 @@ function freshName(base, taken = []) {
 }
 var BLOCK_KINDS = ["chart", "image", "video", "table", "code", "metric", "quote", "timeline", "items", "bullets", "text"];
 function blockKind(node) {
-  if (!isRecord2(node)) return void 0;
+  if (!isRecord3(node)) return void 0;
   if (typeof node.type === "string" && node.type !== "group") return node.type;
   const found = BLOCK_KINDS.find((key2) => node[key2] !== void 0);
   if (found === "items" || found === "bullets") return "list";
@@ -5797,13 +6140,13 @@ function regionNamesOf(slideLayout, helpers) {
   const colon = slideLayout.indexOf(":");
   const group = colon > 0 ? slideLayout.slice(0, colon) : void 0;
   const id = colon > 0 ? slideLayout.slice(colon + 1) : slideLayout;
-  const record = (group ? [group] : ["custom", "default"]).map((name) => helpers.valueAt(["catalogs", name, "layouts", id])).find(isRecord2);
+  const record = (group ? [group] : ["custom", "default"]).map((name) => helpers.valueAt(["catalogs", name, "layouts", id])).find(isRecord3);
   if (!record) return void 0;
   const names2 = [];
   const walk2 = (list) => {
     if (!Array.isArray(list)) return;
     for (const entry2 of list) {
-      if (!isRecord2(entry2)) continue;
+      if (!isRecord3(entry2)) continue;
       if (typeof entry2.name === "string" && !["title", "subtitle", "tag"].includes(entry2.name)) names2.push(entry2.name);
       walk2(entry2.regions);
     }
@@ -5917,7 +6260,7 @@ var codeHighlightRangeReversed = (finding2) => {
   };
 };
 var variableBuiltinMissing = (finding2, _context, helpers) => {
-  const idParam = isRecord2(finding2.validation?.params) ? finding2.validation.params.id : void 0;
+  const idParam = isRecord3(finding2.validation?.params) ? finding2.validation.params.id : void 0;
   const id = (typeof idParam === "string" ? idParam : void 0) ?? match(finding2.message, /^Built-in '(.+?)' has no value/)?.[1] ?? match(finding2.message, /'\{\{(.+?)\}\}'/)?.[1];
   if (!id) return void 0;
   const root = id.split(".")[0];
@@ -5939,7 +6282,7 @@ var durationOutsideNarrative2 = (finding2) => {
 };
 var narrativeDurationRange = (_finding, _context, helpers) => {
   const range = helpers.valueAt(helpers.segments);
-  if (isRecord2(range) && typeof range.min === "number" && typeof range.max === "number") {
+  if (isRecord3(range) && typeof range.min === "number" && typeof range.max === "number") {
     return {
       message: `The duration range has min ${range.min} greater than max ${range.max}.`,
       next: `swap them: ${code(`min: ${range.max}`)} and ${code(`max: ${range.min}`)}.`
@@ -6032,7 +6375,7 @@ var AUDIT_TEXT = {
 };
 
 // src/finding-text-format.ts
-var params = (finding2) => isRecord2(finding2.validation?.params) ? finding2.validation.params : {};
+var params = (finding2) => isRecord3(finding2.validation?.params) ? finding2.validation.params : {};
 var text = (value) => typeof value === "string" ? value : void 0;
 var jsonSyntax = (finding2) => ({
   message: keep(finding2.message),
@@ -6153,7 +6496,7 @@ var dataColumnDuplicate = (finding2, _context, helpers) => {
   const name = unquote(match(finding2.message, /^column name ("(?:[^"\\]|\\.)*") is used by an earlier column/)?.[1]);
   if (!name) return void 0;
   const columns = helpers.valueAt(helpers.segments.slice(0, -1));
-  const taken = Array.isArray(columns) ? columns.map((entry2) => isRecord2(entry2) ? String(entry2.name) : String(entry2)) : [];
+  const taken = Array.isArray(columns) ? columns.map((entry2) => isRecord3(entry2) ? String(entry2.name) : String(entry2)) : [];
   return {
     message: `Two columns are named ${code(name)}. Series and mappings address columns by name.`,
     next: `rename the second one (for example ${code(freshName(name, taken))}).`
@@ -6431,7 +6774,7 @@ var unresolvedReference2 = (finding2, _context, helpers) => {
   const group = colon > 0 ? reference.slice(0, colon) : void 0;
   const bare = colon > 0 ? reference.slice(colon + 1) : reference;
   const embeddedIn = group ? [group] : ["custom", "default"];
-  const embedded = kind && embeddedIn.some((name) => isRecord2(helpers.valueAt(["catalogs", name, kind, bare])));
+  const embedded = kind && embeddedIn.some((name) => isRecord3(helpers.valueAt(["catalogs", name, kind, bare])));
   const suggestions = (finding2.suggestions ?? []).slice(0, 5).map((entry2) => String(entry2.value));
   if (embedded) {
     return {
@@ -6796,6 +7139,8 @@ function describeSchema(finding2, context, helpers) {
     case "required": {
       const property = String(params2.missingProperty ?? "");
       const where = containerName(segments);
+      const shape = property === "data" ? chartShapeHelp(actual) : void 0;
+      if (shape) return { message: shape.message, next: shape.next };
       const schema = context.schemaAt ? context.schemaAt([...segments, property]) : attempt(() => schemaAtPath(context.document, [...segments, property]), void 0);
       if (format === "json") {
         const sample2 = property === "slides" ? '[ { "title": "\u2026" } ]' : starterText(schema, property, "json");
@@ -6936,7 +7281,7 @@ function schemaFixes(finding2, document) {
   switch (validation.keyword) {
     case "required": {
       const property = String(params2.missingProperty ?? "");
-      if (!property || !isRecord2(readAt(document, segments)) || Object.hasOwn(readAt(document, segments), property)) return [];
+      if (!property || !isRecord3(readAt(document, segments)) || Object.hasOwn(readAt(document, segments), property)) return [];
       const value = starterValue(document, segments, property);
       if (value === void 0) return [];
       return [patch(`add:${property}`, `Add \`${property}\``, [{ op: "add", path: pointerOf([...segments, property]), value }])];
@@ -6952,7 +7297,7 @@ function schemaFixes(finding2, document) {
       const name = String(params2.additionalProperty ?? segments.at(-1) ?? "");
       const parent = segments.slice(0, -1);
       const owner = readAt(document, parent);
-      if (!name || !isRecord2(owner) || !Object.hasOwn(owner, name)) return [];
+      if (!name || !isRecord3(owner) || !Object.hasOwn(owner, name)) return [];
       const fixes = [];
       for (const suggestion of finding2.suggestions ?? []) {
         const target = String(suggestion.value);
@@ -6961,14 +7306,14 @@ function schemaFixes(finding2, document) {
       if (allowsKey(document, parent, "extensions") && name !== "extensions") {
         const existing = owner.extensions;
         if (existing === void 0) fixes.push(patch("move-to-extensions", "Move into extensions", [{ op: "add", path: pointerOf([...parent, "extensions"]), value: {} }, { op: "move", from: finding2.path, path: pointerOf([...parent, "extensions", name]) }]));
-        else if (isRecord2(existing) && !Object.hasOwn(existing, name)) fixes.push(patch("move-to-extensions", "Move into extensions", [{ op: "move", from: finding2.path, path: pointerOf([...parent, "extensions", name]) }]));
+        else if (isRecord3(existing) && !Object.hasOwn(existing, name)) fixes.push(patch("move-to-extensions", "Move into extensions", [{ op: "move", from: finding2.path, path: pointerOf([...parent, "extensions", name]) }]));
       }
       return fixes;
     }
     case "type": {
       const current = readAt(document, segments);
       if (current === void 0) return [];
-      if (params2.type === "array" && (typeof current === "string" || isRecord2(current))) return [patch("wrap-in-list", "Wrap in a list", [{ op: "replace", path: finding2.path, value: [current] }], typeof current === "string")];
+      if (params2.type === "array" && (typeof current === "string" || isRecord3(current))) return [patch("wrap-in-list", "Wrap in a list", [{ op: "replace", path: finding2.path, value: [current] }], typeof current === "string")];
       if (params2.type === "string" && (typeof current === "number" || typeof current === "boolean")) return [patch("convert-to-string", "Convert to string", [{ op: "replace", path: finding2.path, value: String(current) }], true)];
       return [];
     }
@@ -6987,6 +7332,30 @@ function schemaFixes(finding2, document) {
   }
 }
 
+// src/drawn-font-families.ts
+function resolveDrawnFontFamilies(families, measurement, keepsName) {
+  const resolve2 = measurement?.resolveStyle;
+  if (typeof resolve2 !== "function") return families;
+  const drawn = { ...families };
+  for (const role of ["heading", "body", "code", "accent"]) {
+    const named = families[role];
+    if (typeof named !== "string" || !named) continue;
+    try {
+      const resolved = resolve2.call(measurement, { fontFamily: named, fontWeight: role === "heading" ? 700 : 400 });
+      let keep3;
+      if (keepsName) keep3 = keepsName(named, resolved.fontFamily);
+      else {
+        const regular = role === "heading" ? resolve2.call(measurement, { fontFamily: named, fontWeight: 400 }) : resolved;
+        const encoded = resolved.symbolEncoding != null;
+        keep3 = encoded || regular.fontWeight !== void 0 && regular.fontWeight !== 400 && resolved.fontFamily.toLowerCase() !== named.toLowerCase();
+      }
+      if (!keep3) drawn[role] = resolved.fontFamily;
+    } catch {
+    }
+  }
+  return drawn;
+}
+
 // src/script-measurement.ts
 function scriptProfile(presentation, slideIndex, options2, language) {
   let resolved;
@@ -7139,7 +7508,12 @@ function buildSlides(document, options2) {
     const layout = lazy(() => resolved().options.layout);
     const composed = lazy(() => {
       const result = { layoutDiagnostics: [] };
-      const compose = (input, withLayout) => composeSlide(input, { ...resolved().options, layout: withLayout });
+      let fontFamilies;
+      const compose = (input, withLayout) => {
+        const options3 = resolved().options;
+        fontFamilies ??= options3.fontFamilies && resolveDrawnFontFamilies(options3.fontFamilies, options3.textMeasurement);
+        return composeSlide(input, { ...options3, ...fontFamilies ? { fontFamilies } : {}, layout: withLayout });
+      };
       try {
         result.composition = compose(resolved().slide, layout());
         result.layoutDiagnostics.push(...result.composition.diagnostics.map((diagnostic) => ({ diagnostic, strict: false })));
@@ -7457,4 +7831,4 @@ function assertValidCatalogRecord(kind, value) {
   if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, CATALOG_SCHEMA, COMMON_KEYS, DEFAULT_VALIDATION_THRESHOLDS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, OPFPatchError, OPFPatchValidationError, OPFValidationError, PATTERN_PHRASES, SLIDE_OPTION_KEYS, SOURCE_EXPLAIN, SPAN_FLAGS, SPAN_VALUES, UNRANKED_PRIORITY, activeSchema, analyzeJsonSyntax, applyPatch, applyPatchWithInverse, applyTextEdits, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogKindAt, catalogSchemaNames, createLocator, createSchemaValue, describeField, describeFinding, distance2 as distance, escapePointerToken, findValidationRule, formatPointer, getAtPointer, hasPointer, invertPatch, isPromotedRegionKey, jsonEqual, listSchemaFields, nearest, normalizePatch, parsePointer, parseSource, pointerFromPath, readPointer, rememberByText, resolveSchema, resolveSlideContext, resolveSlideScriptMeasurement, ruleDocumentation, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, segmentsOf, splitOpfPath, splitPointer2 as splitPointer, starterValue, unescapePointerToken, us, validate, validateCatalogRecord, validationCategories, validationRules };
+export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, CATALOG_SCHEMA, COMMON_KEYS, DEFAULT_VALIDATION_THRESHOLDS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, OPFPatchError, OPFPatchHashError, OPFPatchValidationError, OPFValidationError, PATTERN_PHRASES, SLIDE_OPTION_KEYS, SOURCE_EXPLAIN, SPAN_FLAGS, SPAN_VALUES, UNRANKED_PRIORITY, activeSchema, analyzeJsonSyntax, applyPatch, applyPatchWithInverse, applyTextEdits, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogKindAt, catalogSchemaNames, createLocator, createSchemaValue, describeField, describeFinding, distance2 as distance, documentHash, escapePointerToken, findValidationRule, formatPointer, getAtPointer, hasPointer, idToken, invertPatch, isIdToken, isPromotedRegionKey, jsonEqual, listSchemaFields, nearest, normalizePatch, parsePointer, parseSource, pointerFromPath, readPointer, rememberByText, resolveDrawnFontFamilies, resolveIdPatch, resolveIdPointer, resolveSchema, resolveSlideContext, resolveSlideScriptMeasurement, ruleDocumentation, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, segmentsOf, splitOpfPath, splitPointer2 as splitPointer, starterValue, toIdPatch, toIdPointer, unescapePointerToken, us, validate, validateCatalogRecord, validationCategories, validationRules, walkPatch };