@openpresentation/opf 0.13.0 → 0.15.1

package/dist/chunk-QDI75P2M.js

@@ -0,0 +1,3515 @@
+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, OPFCompositionError, composeSlide, resolveScriptFonts } from './chunk-O744SXXA.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-2CJPC4HI.js';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
+
+// src/annotation-validation.ts
+var issue = (path, message, params) => ({ path, message, keyword: "opf", schemaPath: "#/x-opf-semantics", params });
+var pointer = (dotted) => `/${dotted.split(".").map((part) => part.replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}`;
+function markedRuns(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((run, index) => isRecord(run) && (run.cite !== void 0 || run.footnote !== void 0) ? [index] : []);
+}
+function annotationIssues(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) return [];
+  const issues = [];
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(value.references)) value.references.forEach((reference, index) => {
+    if (!isRecord(reference) || typeof reference.id !== "string") return;
+    if (ids.has(reference.id)) issues.push(issue(`/references/${index}/id`, `reference id '${reference.id}' is used by an earlier references entry; ids must be unique`, { code: "reference-id-duplicate", id: reference.id }));
+    ids.add(reference.id);
+    for (const runIndex of markedRuns(reference.text)) issues.push(issue(`/references/${index}/text/${runIndex}`, "reference text cannot cite or carry a footnote", { code: "cite-unsupported-location" }));
+  });
+  const unsupported = (runs, path, where) => {
+    for (const runIndex of markedRuns(runs)) issues.push(issue(`${path}/${runIndex}`, `cite and footnote are not supported in ${where}; markers are drawn only in the slide title, subtitle and tag, text, bullets, list items and quote text`, { code: "cite-unsupported-location" }));
+  };
+  const cell = (entry, path) => {
+    if (Array.isArray(entry)) unsupported(entry, path, "table cells");
+    else if (isRecord(entry) && Array.isArray(entry.value)) unsupported(entry.value, pathFor(path, "value"), "table cells");
+  };
+  const payload = (node, path) => {
+    if (isRecord(node.table)) {
+      const table = node.table, tablePath = pathFor(path, "table");
+      if (Array.isArray(table.columns)) table.columns.forEach((column, index) => {
+        cell(column, `${pathFor(tablePath, "columns")}/${index}`);
+      });
+      if (Array.isArray(table.rows)) table.rows.forEach((row, rowIndex) => {
+        if (Array.isArray(row)) row.forEach((entry, cellIndex) => {
+          cell(entry, `${pathFor(tablePath, "rows")}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+    if (node.caption !== void 0) {
+      const caption = node.caption, captionPath = pathFor(path, "caption");
+      if (Array.isArray(caption)) unsupported(caption, captionPath, "captions");
+      else if (isRecord(caption) && Array.isArray(caption.text)) unsupported(caption.text, pathFor(captionPath, "text"), "captions");
+    }
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+    walkCitationRuns(slide, `slides.${index}`, (entry) => {
+      const runPath = pointer(entry.path);
+      const cite = entry.run.cite;
+      if (typeof cite === "string") {
+        if (!ids.has(cite)) issues.push(issue(`${runPath}/cite`, `unknown reference '${cite}'; add it to the top-level references list`, { code: "cite-unknown-reference", id: cite }));
+      } else if (Array.isArray(cite)) cite.forEach((id, position) => {
+        if (typeof id === "string" && !ids.has(id)) issues.push(issue(`${runPath}/cite/${position}`, `unknown reference '${id}'; add it to the top-level references list`, { code: "cite-unknown-reference", id }));
+      });
+      if (Array.isArray(entry.footnote)) unsupported(entry.footnote, `${runPath}/footnote`, "footnote text");
+    });
+  });
+  return issues;
+}
+function unusedReferenceWarnings(value) {
+  if (!isRecord(value) || !Array.isArray(value.references) || !Array.isArray(value.slides)) return [];
+  const { unused } = collectCitations(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/validation-definitions.ts
+var schemaLocations;
+var issueLocations = /* @__PURE__ */ new WeakMap();
+function rememberValidationDefinition(issue2, parentSchema, keyword) {
+  if (!parentSchema || typeof parentSchema !== "object") return;
+  if (!schemaLocations) {
+    schemaLocations = /* @__PURE__ */ new WeakMap();
+    for (const entry of schemaEntries) {
+      const stack = [
+        { value: entry.schema, pointer: "" }
+      ];
+      while (stack.length) {
+        const current = stack.pop();
+        if (!current?.value || typeof current.value !== "object")
+          continue;
+        schemaLocations.set(current.value, {
+          schemaName: entry.name,
+          pointer: current.pointer,
+          uri: `${entry.schema.$id}#${current.pointer}`
+        });
+        for (const [key, value] of Object.entries(current.value)) {
+          const segment = key.replaceAll("~", "~0").replaceAll("/", "~1");
+          stack.push({ value, pointer: `${current.pointer}/${segment}` });
+        }
+      }
+    }
+  }
+  const parent = schemaLocations.get(parentSchema);
+  if (!parent) return;
+  const suffix = `/${keyword.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+  issueLocations.set(issue2, {
+    ...parent,
+    pointer: parent.pointer + suffix,
+    uri: parent.uri + suffix
+  });
+}
+function validationDefinition(issue2) {
+  return issueLocations.get(issue2);
+}
+
+// src/schema-check.ts
+var schemaNameByCatalogKind = catalogSchemaNames;
+var ajv;
+var promotedRegionKeySet = new Set(promotedRegionKeys);
+var rootPayloadFields = [
+  "type",
+  "text",
+  "items",
+  "bullets",
+  "image",
+  "video",
+  "chart",
+  "table",
+  "code",
+  "metric",
+  "quote",
+  "timeline",
+  "blocks"
+];
+var contentKindSpecs = {
+  text: {
+    fields: ["text", "bullets"],
+    required: [],
+    requireAny: ["text", "bullets"]
+  },
+  list: {
+    fields: ["items"],
+    required: ["items"]
+  },
+  image: {
+    fields: ["image"],
+    required: ["image"]
+  },
+  chart: {
+    fields: ["chart"],
+    required: ["chart"]
+  },
+  table: {
+    fields: ["table"],
+    required: ["table"]
+  },
+  video: {
+    fields: ["video"],
+    required: ["video"]
+  },
+  code: {
+    fields: ["code"],
+    required: ["code"]
+  },
+  metric: {
+    fields: ["metric"],
+    required: ["metric"]
+  },
+  quote: {
+    fields: ["quote"],
+    required: ["quote"]
+  },
+  timeline: {
+    fields: ["timeline"],
+    required: ["timeline"]
+  }
+};
+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],
+  right: [2],
+  "left+center": [0, 1],
+  "center+right": [1, 2],
+  "left+center+right": [0, 1, 2]
+};
+var rowSpans = {
+  top: [0],
+  middle: [1],
+  bottom: [2],
+  "top+middle": [0, 1],
+  "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" && value in schemas;
+}
+function isCatalogKind(value) {
+  return typeof value === "string" && value in schemaNameByCatalogKind;
+}
+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 };
+  }
+  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 };
+  }
+  throw new TypeError(`Unknown schema or catalog kind ${JSON.stringify(schemaOrKind)}.`);
+}
+var slideDimensionsSchemaPath = /\/allOf\/1\/not$/;
+var designInstancePath = /\/design$/;
+function toIssue(error) {
+  const slideDimensions = error.keyword === "not" && slideDimensionsSchemaPath.test(error.schemaPath) && designInstancePath.test(error.instancePath);
+  const issue2 = {
+    path: error.instancePath || "/",
+    message: slideDimensions ? "a slide's design cannot set 'dimensions': a PPTX has one slide size, so set design.dimensions on the deck (or its theme)" : error.message ?? "failed validation",
+    keyword: error.keyword,
+    schemaPath: error.schemaPath,
+    params: error.params
+  };
+  rememberValidationDefinition(issue2, error.parentSchema, error.keyword);
+  return issue2;
+}
+function semanticIssue(path, message, params = {}) {
+  return {
+    path,
+    message,
+    keyword: "opf",
+    schemaPath: "#/x-opf-semantics",
+    params
+  };
+}
+function hasOwn(value, key) {
+  return Object.hasOwn(value, key);
+}
+function isEnUkTag(value) {
+  return typeof value === "string" && value.toLowerCase() === "en-uk";
+}
+function presentFields(value, fields2) {
+  return fields2.filter((field) => hasOwn(value, field));
+}
+function isContentKind(value) {
+  return typeof value === "string" && value in contentKindSpecs;
+}
+function inferredKinds(value) {
+  const kinds = [];
+  if (presentFields(value, contentKindSpecs.text.fields).length > 0) kinds.push("text");
+  if (hasOwn(value, "items")) kinds.push("list");
+  if (hasOwn(value, "image")) kinds.push("image");
+  if (hasOwn(value, "video")) kinds.push("video");
+  if (hasOwn(value, "chart")) kinds.push("chart");
+  if (hasOwn(value, "table")) kinds.push("table");
+  if (hasOwn(value, "code")) kinds.push("code");
+  if (hasOwn(value, "metric")) kinds.push("metric");
+  if (hasOwn(value, "quote")) kinds.push("quote");
+  if (hasOwn(value, "timeline")) kinds.push("timeline");
+  return kinds;
+}
+function isImplicitBlocksComposition(value, inferred, options) {
+  if (options.slideRoot !== true || hasOwn(value, "blocks")) {
+    return false;
+  }
+  return inferred.length > 1;
+}
+function validateContentPayload(value, path, options = {}) {
+  const issues = [];
+  const explicitType = value.type;
+  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}`, { 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"));
+  if (explicitType !== void 0 && !isContentKind(explicitType)) {
+    return issues;
+  }
+  const kind = isContentKind(explicitType) ? explicitType : void 0;
+  const inferred = kind ? [kind] : inferredKinds(value);
+  if (!kind && inferred.length === 0) {
+    if (payloadFields.length > 0 || path !== "/") {
+      issues.push(semanticIssue(path, "content payload must include concrete content fields", {
+        fields: payloadFields
+      }));
+    }
+    return issues;
+  }
+  if (!kind && inferred.length > 1) {
+    if (isImplicitBlocksComposition(value, inferred, options)) {
+      if (hasOwn(value, "caption")) issues.push(captionIssue("a slide root with several payloads cannot carry one; put the caption on a block", { inferredTypes: inferred }));
+      return issues;
+    }
+    issues.push(semanticIssue(path, "content payload mixes fields from incompatible content types", {
+      inferredTypes: inferred
+    }));
+    return issues;
+  }
+  const resolvedKind = inferred[0];
+  if (!resolvedKind) {
+    return issues;
+  }
+  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
+  ]);
+  for (const required of spec.required) {
+    if (!hasOwn(value, required)) {
+      issues.push(semanticIssue(path, `content payload type '${resolvedKind}' requires '${required}'`, {
+        type: resolvedKind,
+        required
+      }));
+    }
+  }
+  if (spec.requireAny && presentFields(value, spec.requireAny).length === 0) {
+    issues.push(semanticIssue(path, `content payload type '${resolvedKind}' requires one of: ${spec.requireAny.join(", ")}`, {
+      type: resolvedKind,
+      requiredAny: spec.requireAny
+    }));
+  }
+  const incompatible = payloadFields.filter((field) => !allowedFields.has(field));
+  if (incompatible.length > 0) {
+    issues.push(semanticIssue(path, `content payload type '${resolvedKind}' cannot include incompatible fields: ${incompatible.join(", ")}`, {
+      type: resolvedKind,
+      incompatible
+    }));
+  }
+  return issues;
+}
+function slideRegion(key) {
+  if (key.includes(":")) {
+    const [rowPart, columnPart] = key.split(":");
+    if (!rowPart || !columnPart) return void 0;
+    const rows = rowSpans[rowPart];
+    const columns = columnSpans[columnPart];
+    return rows && columns ? { rows, columns } : void 0;
+  }
+  if (key in columnSpans) {
+    const columns = columnSpans[key];
+    return columns ? { rows: [0, 1, 2], columns } : void 0;
+  }
+  if (key in rowSpans) {
+    const rows = rowSpans[key];
+    return rows ? { rows, columns: [0, 1, 2] } : void 0;
+  }
+  return void 0;
+}
+function intersects(left, right) {
+  return left.some((value) => right.includes(value));
+}
+function regionsOverlap(left, right) {
+  return intersects(left.rows, right.rows) && intersects(left.columns, right.columns);
+}
+function validateSlideRegions(slide, slidePath) {
+  const issues = [];
+  const regionKeys = Object.keys(slide).filter((key) => promotedRegionKeySet.has(key));
+  const rootFields = presentFields(slide, rootPayloadFields);
+  if (regionKeys.length > 0 && rootFields.length > 0) {
+    issues.push(semanticIssue(slidePath, "root content payload fields cannot be mixed with promoted region keys", {
+      rootFields,
+      regionKeys
+    }));
+  }
+  if (regionKeys.length === 0 && rootFields.length > 0) {
+    issues.push(...validateContentPayload(slide, slidePath, { slideRoot: true }));
+  }
+  for (const key of regionKeys) {
+    const value = slide[key];
+    if (isRecord(value)) {
+      issues.push(...validateContentPayload(value, pathFor(slidePath, key)));
+    }
+  }
+  for (let leftIndex = 0; leftIndex < regionKeys.length; leftIndex += 1) {
+    const leftKey = regionKeys[leftIndex];
+    if (!leftKey) continue;
+    const leftRegion = slideRegion(leftKey);
+    if (!leftRegion) continue;
+    for (let rightIndex = leftIndex + 1; rightIndex < regionKeys.length; rightIndex += 1) {
+      const rightKey = regionKeys[rightIndex];
+      if (!rightKey) continue;
+      const rightRegion = slideRegion(rightKey);
+      if (!rightRegion) continue;
+      if (regionsOverlap(leftRegion, rightRegion)) {
+        issues.push(semanticIssue(slidePath, `promoted region keys '${leftKey}' and '${rightKey}' overlap`, {
+          regionKeys: [leftKey, rightKey]
+        }));
+      }
+    }
+  }
+  return issues;
+}
+function deckMetadataIssues(value) {
+  const issues = [];
+  const entries = (key) => {
+    const field = value[key];
+    if (Array.isArray(field)) return field.flatMap((entry, index) => isRecord(entry) ? [{ entry, path: `/${key}/${index}` }] : []);
+    return isRecord(field) ? [{ entry: field, path: `/${key}` }] : [];
+  };
+  const organizationIds = /* @__PURE__ */ new Set();
+  for (const key of ["organization", "speaker"]) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const { entry, path } of entries(key)) {
+      if (typeof entry.id !== "string") continue;
+      if (seen.has(entry.id)) issues.push(semanticIssue(`${path}/id`, `${key} ids must be unique within a presentation`, { id: entry.id }));
+      seen.add(entry.id);
+      if (key === "organization") organizationIds.add(entry.id);
+    }
+  }
+  for (const { entry, path } of entries("speaker")) {
+    if (typeof entry.organizationId === "string" && !organizationIds.has(entry.organizationId)) {
+      issues.push(semanticIssue(`${path}/organizationId`, `organizationId '${entry.organizationId}' names no organization in the presentation; use the id of an entry in organization`, { id: entry.organizationId }));
+    }
+  }
+  return issues;
+}
+function presentationSemanticIssues(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) {
+    return [];
+  }
+  const issues = [];
+  if (isEnUkTag(value.language)) {
+    issues.push(semanticIssue("/language", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    }));
+  } else if (isRecord(value.language) && isEnUkTag(value.language.bcp47)) {
+    issues.push(semanticIssue("/language/bcp47", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    }));
+  }
+  issues.push(...deckMetadataIssues(value));
+  if (isRecord(value.variables) && hasOwn(value.variables, "speakers")) {
+    issues.push(semanticIssue("/variables/speakers", "'speakers' is reserved for the built-in list of speaker names; choose another variable id", { id: "speakers" }));
+  }
+  const documentIds = /* @__PURE__ */ new Map();
+  value.slides.forEach((slide, index) => {
+    if (isRecord(slide)) {
+      const slidePath = `/slides/${index}`;
+      if (typeof slide.id === "string") {
+        const seen = documentIds.get(slide.id);
+        if (seen === "slide") issues.push(semanticIssue(`${slidePath}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
+        else if (seen === "payload") issues.push(semanticIssue(`${slidePath}/id`, "slide id duplicates a content payload id; ids must be unique among slide and payload ids within a presentation", { id: slide.id }));
+        else documentIds.set(slide.id, "slide");
+      }
+      visitContentPayloads(slide, slidePath, (payload, path) => {
+        if (typeof payload.id === "string") {
+          if (documentIds.has(payload.id)) issues.push(semanticIssue(`${path}/id`, "content payload ids must be unique among slide and payload ids within a presentation", { id: payload.id }));
+          else documentIds.set(payload.id, "payload");
+        }
+      });
+      issues.push(...validateSlideRegions(slide, slidePath));
+      const payloadTableIssues = (payload, path) => {
+        if (isRecord(payload.table)) for (const issue2 of tableGrid(payload.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue2.path.slice(5).replaceAll(".", "/"), issue2.message));
+      };
+      payloadTableIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadTableIssues);
+      const payloadNumberingIssues = (payload, path) => {
+        for (const finding2 of numberingFindings(payload).errors) issues.push(semanticIssue(pathFor(path, finding2.key), finding2.message, finding2.params));
+      };
+      payloadNumberingIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadNumberingIssues);
+    }
+  });
+  issues.push(...annotationIssues(value));
+  return issues;
+}
+function canvasSize(dimensions) {
+  try {
+    const { width, height } = resolveCanvasDimensions(dimensions);
+    return `${Math.round(width * 100) / 100}x${Math.round(height * 100) / 100} px`;
+  } catch {
+    return "invalid";
+  }
+}
+function slideThemeDimensionsWarnings(document, slide, index, catalogs) {
+  const slidePath = `/slides/${index}`;
+  const slideDesign = isRecord(slide.design) ? slide.design : void 0;
+  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 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;
+  return [semanticIssue(
+    pathFor(pathFor(slidePath, "design"), "theme"),
+    explicit ? `this slide's theme sets a slide size (${slideSize}) that differs from the deck's design.dimensions (${deckSize}); a PPTX has one slide size, so the deck's size is used` : `this slide's theme sets a slide size (${slideSize}) that differs from the deck's (${deckSize}); a PPTX has one slide size, so set design.dimensions on the deck`,
+    { code: "slide-theme-dimensions", slideDimensions: slideSize, deckDimensions: deckSize }
+  )];
+}
+function chartTypeWarnings(payload, path) {
+  if (!isRecord(payload)) {
+    return [];
+  }
+  const issues = [];
+  if (isRecord(payload.chart)) {
+    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}`));
+    });
+  }
+  return issues;
+}
+function dataIssues(value) {
+  const out = { errors: [], warnings: [] };
+  if (!isRecord(value) || !Array.isArray(value.slides)) return out;
+  const seen = /* @__PURE__ */ new Set();
+  const add = (diagnostics) => {
+    for (const diagnostic of diagnostics) {
+      const key = `${diagnostic.code}|${diagnostic.path}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      (diagnostic.severity === "error" ? out.errors : out.warnings).push(semanticIssue(diagnostic.path, diagnostic.message, { code: diagnostic.code }));
+    }
+  };
+  add(datasetDiagnostics(value));
+  const payload = (node, path) => {
+    if (isRecord(node.chart)) add(resolveChartData(node.chart, value, { path: pathFor(path, "chart") }).diagnostics);
+    if (isRecord(node.table)) add(resolveTableData(node.table, value, { path: pathFor(path, "table") }).diagnostics);
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+  });
+  return out;
+}
+var cellBorderEdges = ["top", "right", "bottom", "left"];
+var variableIdPattern = /^[a-z][a-z0-9-]*$/;
+var hexColorPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var schemeColorNames = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink",
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+function variableReferenceWarnings(value) {
+  if (!Array.isArray(value.slides)) {
+    return [];
+  }
+  const variables = isRecord(value.variables) ? value.variables : {};
+  const issues = [];
+  const colorRef = (entry, path) => {
+    if (typeof entry !== "string" || !entry.startsWith("var:")) return;
+    const id = entry.slice("var:".length);
+    if (!variableIdPattern.test(id) || hasOwn(variables, id)) return;
+    issues.push(semanticIssue(path, `unknown variable '${id}'; declare it in the top-level variables map`, { id, code: "variable-reference-unknown" }));
+  };
+  const runColor = (entry, path) => {
+    if (typeof entry !== "string") return;
+    if (hexColorPattern.test(entry) || schemeColorNames.has(entry)) return;
+    if (entry.startsWith("var:") && variableIdPattern.test(entry.slice("var:".length))) {
+      colorRef(entry, path);
+      return;
+    }
+    issues.push(semanticIssue(
+      path,
+      `run color '${entry}' is not a hex color, a color-scheme name, or a 'var:' reference; renderers fall back to the theme color`,
+      { color: entry, code: "run-color-unrecognized" }
+    ));
+  };
+  const richText = (entry, path) => {
+    if (!Array.isArray(entry)) return;
+    entry.forEach((run, index) => {
+      if (isRecord(run)) runColor(run.color, `${path}/${index}/color`);
+    });
+  };
+  const cellStyle = (style, path) => {
+    if (!isRecord(style)) return;
+    colorRef(style.fill, pathFor(path, "fill"));
+    colorRef(style.color, pathFor(path, "color"));
+    if (!isRecord(style.borders)) return;
+    const bordersPath = pathFor(path, "borders");
+    for (const edge of cellBorderEdges) {
+      const border = style.borders[edge];
+      if (isRecord(border)) colorRef(border.color, `${pathFor(bordersPath, edge)}/color`);
+    }
+  };
+  const tableCell = (cell, path) => {
+    if (Array.isArray(cell)) {
+      richText(cell, path);
+      return;
+    }
+    if (!isRecord(cell)) return;
+    richText(cell.value, pathFor(path, "value"));
+    cellStyle(cell.style, pathFor(path, "style"));
+  };
+  const table = (node, path) => {
+    if (!isRecord(node)) return;
+    if (Array.isArray(node.columns)) {
+      const columnsPath = pathFor(path, "columns");
+      node.columns.forEach((column, index) => {
+        tableCell(column, `${columnsPath}/${index}`);
+      });
+    }
+    if (Array.isArray(node.rows)) {
+      const rowsPath = pathFor(path, "rows");
+      node.rows.forEach((row, rowIndex) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, cellIndex) => {
+          tableCell(cell, `${rowsPath}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+  };
+  const textEntries = (entries, path) => {
+    if (!Array.isArray(entries)) return;
+    entries.forEach((entry, index) => {
+      const entryPath = `${path}/${index}`;
+      if (Array.isArray(entry)) {
+        richText(entry, entryPath);
+        return;
+      }
+      if (!isRecord(entry)) return;
+      richText(entry.text, pathFor(entryPath, "text"));
+      richText(entry.description, pathFor(entryPath, "description"));
+    });
+  };
+  const backgroundColors = (background, path) => {
+    if (!isRecord(background)) return;
+    colorRef(background.color, pathFor(path, "color"));
+    const stops = isRecord(background.gradient) ? background.gradient.stops : void 0;
+    if (Array.isArray(stops)) stops.forEach((stop, index) => {
+      if (isRecord(stop)) colorRef(stop.color, `${path}/gradient/stops/${index}/color`);
+    });
+    if (isRecord(background.pattern)) {
+      colorRef(background.pattern.foregroundColor, `${path}/pattern/foregroundColor`);
+      colorRef(background.pattern.backgroundColor, `${path}/pattern/backgroundColor`);
+    }
+  };
+  const designColors = (design, path) => {
+    if (!isRecord(design)) return;
+    backgroundColors(design.background, pathFor(path, "background"));
+    if (isRecord(design.theme)) backgroundColors(design.theme.background, `${path}/theme/background`);
+  };
+  designColors(value.design, "/design");
+  const payload = (node, path) => {
+    richText(node.text, pathFor(path, "text"));
+    textEntries(node.items, pathFor(path, "items"));
+    textEntries(node.bullets, pathFor(path, "bullets"));
+    table(node.table, pathFor(path, "table"));
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    designColors(slide.design, pathFor(slidePath, "design"));
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+  });
+  return issues;
+}
+function presentationReferenceWarnings(value, catalogs) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) {
+    return [];
+  }
+  const issues = [];
+  issues.push(...variableReferenceWarnings(value));
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) {
+      return;
+    }
+    const slidePath = `/slides/${index}`;
+    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" }));
+    };
+    numberingWarnings(slide, slidePath);
+    visitContentPayloads(slide, slidePath, numberingWarnings);
+    const highlightWarnings = (payload, path) => {
+      const code = payload.code;
+      if (!isRecord(code) || !Array.isArray(code.highlight) || typeof code.source !== "string") return;
+      for (const finding2 of codeHighlightLines(code.highlight, code.source).issues) {
+        if (finding2.code === "code-highlight-invalid") continue;
+        issues.push(semanticIssue(pathFor(pathFor(pathFor(path, "code"), "highlight"), String(finding2.index)), finding2.message, { code: finding2.code }));
+      }
+    };
+    highlightWarnings(slide, slidePath);
+    visitContentPayloads(slide, slidePath, highlightWarnings);
+    for (const key of Object.keys(slide)) {
+      if (promotedRegionKeySet.has(key)) {
+        issues.push(...chartTypeWarnings(slide[key], pathFor(slidePath, key)));
+      }
+    }
+  });
+  return issues;
+}
+function validateLanguageSemantics(value) {
+  if (!isRecord(value)) {
+    return [];
+  }
+  if (isEnUkTag(value.bcp47)) {
+    return [semanticIssue("/bcp47", "Use 'en-GB' for UK English; 'en-UK' is not a valid BCP-47 region tag", {
+      replacement: "en-GB"
+    })];
+  }
+  return [];
+}
+function contentDepthIssues(value) {
+  if (!isRecord(value) || !Array.isArray(value.slides)) return [];
+  const stack = [];
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    if (Array.isArray(slide.blocks)) slide.blocks.forEach((block, i) => {
+      stack.push({ value: block, path: `/slides/${index}/blocks/${i}`, depth: 0, ancestors: [] });
+    });
+    for (const key of promotedRegionKeys) if (hasOwn(slide, key)) stack.push({ value: slide[key], path: `/slides/${index}/${key}`, depth: 0, ancestors: [] });
+  });
+  while (stack.length) {
+    const entry = stack.pop();
+    if (!isRecord(entry.value) || !Array.isArray(entry.value.blocks)) continue;
+    if (entry.ancestors.includes(entry.value) || entry.depth >= MAX_COMPOSITION_DEPTH) return [semanticIssue(entry.path, `content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels`)];
+    const ancestors = [...entry.ancestors, entry.value];
+    entry.value.blocks.forEach((block, i) => {
+      stack.push({ value: block, path: `${entry.path}/blocks/${i}`, depth: entry.depth + 1, ancestors });
+    });
+  }
+  return [];
+}
+var variableTypeList = VARIABLE_KINDS.join(", ");
+function variableIssue(id, suffix, keyword, message, params) {
+  return {
+    instancePath: `/variables/${id.replaceAll("~", "~0").replaceAll("/", "~1")}${suffix}`,
+    schemaPath: "#/$defs/Variable/oneOf",
+    keyword,
+    params,
+    message
+  };
+}
+function typedVariableErrors(errors, value) {
+  if (!isRecord(value) || !isRecord(value.variables)) return errors;
+  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, entry] of Object.entries(variables)) {
+    if (typeof entry === "string") {
+      if (!hexColorPattern.test(entry)) kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
+      continue;
+    }
+    if (!isRecord(entry)) {
+      kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
+      continue;
+    }
+    const kind = entry.type;
+    if (typeof kind !== "string" || !VARIABLE_KINDS.includes(kind)) {
+      kept.push(variableIssue(id, "/type", "enum", `must be one of: ${variableTypeList} (a hex string is shorthand for a color variable)`, { allowedValues: [...VARIABLE_KINDS] }));
+      continue;
+    }
+    const definition = `${kind.charAt(0).toUpperCase()}${kind.slice(1)}Variable`;
+    const check = getAjv().getSchema(`${schemaId}#/$defs/${definition}`);
+    if (!check || check(entry) === 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(/^#/, "")}` });
+    }
+  }
+  return kept;
+}
+function pointerValue(root, pointer4) {
+  let current = root;
+  for (const token of pointer4.split("/").slice(1)) {
+    const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (Array.isArray(current)) current = current[Number(key)];
+    else if (isRecord(current) && hasOwn(current, key)) current = current[key];
+    else return void 0;
+  }
+  return current;
+}
+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);
+    const header = /\/table\/columns\/\d+$/.test(union.instancePath) && /\/properties\/columns\/items\/oneOf$/.test(union.schemaPath);
+    if (!chartData && !header) continue;
+    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;
+    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}/`;
+    kept = [...kept.filter((error) => error.instancePath !== union.instancePath && !error.instancePath.startsWith(prefix)), ...branchErrors];
+  }
+  const exclusions = kept.filter((error) => error.keyword === "false schema" && /\/table\/(rows|columns|fields)$/.test(error.instancePath) && /\/(then|else)\/properties\/(rows|columns|fields)\//.test(`${error.schemaPath}/`));
+  if (!exclusions.length) return kept;
+  const tables = new Set(exclusions.map((error) => error.instancePath.replace(/\/[^/]+$/, "")));
+  return kept.filter((error) => !(error.keyword === "if" && tables.has(error.instancePath))).map((error) => {
+    if (!exclusions.includes(error)) return error;
+    const field = error.instancePath.slice(error.instancePath.lastIndexOf("/") + 1);
+    return { ...error, message: field === "fields" ? "'fields' applies only to a dataset-backed table; add 'dataset' or remove 'fields'" : datasetTableMessage(field) };
+  });
+}
+function validateAgainstSchema(value, schemaOrKind = "presentation", options = {}) {
+  const resolved = resolveValidator(schemaOrKind);
+  if (resolved.schemaName === "presentation") {
+    const errors2 = contentDepthIssues(value);
+    if (errors2.length) return { valid: false, errors: errors2, warnings: [], unfilled: [], schemaName: resolved.schemaName };
+  }
+  const variableIssues = { errors: [], warnings: [] };
+  const unfilled = [];
+  let subject = value;
+  let template;
+  let unfilledVariables;
+  if (resolved.schemaName === "presentation" && isRecord(value) && (hasContentVariables(value) || options.values !== void 0 || options.template !== void 0)) {
+    template = options.template ?? isTemplate(value);
+    const view = instantiateForValidation(value, options.values ?? {}, template);
+    subject = view.presentation;
+    unfilledVariables = view.unfilled;
+    for (const entry of view.diagnostics) {
+      if (entry.code === "variable-example-used" || entry.code === "variable-rich-flattened" || entry.code === "variable-unfilled") continue;
+      const issue2 = semanticIssue(entry.path, entry.message, { id: entry.id, code: entry.code });
+      (entry.severity === "error" ? variableIssues.errors : variableIssues.warnings).push(issue2);
+    }
+    if (!template) {
+      const declared = isRecord(value.variables) ? value.variables : {};
+      for (const id of view.unfilled) {
+        if (isRecord(declared[id]) && declared[id].value !== void 0) continue;
+        unfilled.push(semanticIssue(`/variables/${id}`, `required variable '${id}' has no value; give it a value, fill it before use, or mark the document as a template ("template": true)`, { id, code: "variable-unfilled" }));
+      }
+    }
+  }
+  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 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, options.catalogs));
+    warnings.push(...data.warnings);
+    warnings.push(...variableIssues.warnings);
+  } else if (resolved.schemaName === "language") {
+    errors.push(...validateLanguageSemantics(value));
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    unfilled,
+    schemaName: resolved.schemaName,
+    catalogKind: resolved.catalogKind,
+    ...template !== void 0 ? { template, unfilledVariables } : {}
+  };
+}
+
+// src/narrative-plan.ts
+var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function resolveNarrative(document, options = {}) {
+  if (!isRec(document) || typeof document.narrative !== "string") 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 [];
+  const references = [];
+  document.slides.forEach((slide, index) => {
+    if (!isRec(slide)) return;
+    const path = `/slides/${index}/beat`;
+    if (typeof slide.beat === "string") references.push({ path, slide: index, beat: slide.beat });
+    else if (Array.isArray(slide.beat))
+      slide.beat.forEach((beat, at2) => {
+        if (typeof beat === "string") references.push({ path: `${path}/${at2}`, slide: index, beat });
+      });
+  });
+  return references;
+}
+function unknownBeatReferences(document, narrative) {
+  const known = new Set(narrative.beats);
+  return slideBeatReferences(document).filter((reference) => !known.has(reference.beat));
+}
+function unreferencedBeats(document, narrative) {
+  const referenced = new Set(slideBeatReferences(document).map((reference) => reference.beat));
+  if (referenced.size === 0) return [];
+  return narrative.beats.flatMap((beat, index) => referenced.has(beat) ? [] : [{ beat, index }]);
+}
+function durationRange(record) {
+  if (!isRec(record) || !isRec(record.duration)) return void 0;
+  const bound = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+  const min = bound(record.duration.min), max = bound(record.duration.max);
+  return min === void 0 && max === void 0 ? void 0 : { ...min !== void 0 ? { min } : {}, ...max !== void 0 ? { max } : {} };
+}
+function durationRangeInverted(record) {
+  const range = durationRange(record);
+  return range?.min !== void 0 && range.max !== void 0 && range.min > range.max;
+}
+function durationOutsideNarrative(document, narrative) {
+  if (!isRec(document) || typeof document.duration !== "number" || !Number.isFinite(document.duration)) return void 0;
+  const range = durationRange(narrative.record);
+  if (!range || durationRangeInverted(narrative.record)) return void 0;
+  const duration = document.duration;
+  if (range.min !== void 0 && duration < range.min || range.max !== void 0 && duration > range.max) return { duration, range };
+  return void 0;
+}
+function describeDurationRange(range) {
+  if (range.min !== void 0 && range.max !== void 0) return `${range.min}-${range.max} minutes`;
+  return range.min !== void 0 ? `at least ${range.min} minutes` : `at most ${range.max} minutes`;
+}
+
+// src/rule-context.ts
+var rule = (id, category, severity, summary, rationale, extra = {}) => ({ id: `opf/${id}`, name: id, category, severity, cost: extra.cost ?? "structure", summary, rationale, ...extra });
+
+// src/rule-design.ts
+var rec = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var toRgb = (hex) => {
+  const n = normalizeHexColor(hex) ?? "#000000";
+  return [1, 3, 5].map((at2) => Number.parseInt(n.slice(at2, at2 + 2), 16));
+};
+var toHex = (rgb) => `#${rgb.map((c) => Math.max(0, Math.min(255, Math.round(c))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+var linear = (c) => {
+  const n = c / 255;
+  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
+};
+var delinear = (c) => {
+  const v = Math.max(0, Math.min(1, c));
+  return 255 * (v <= 31308e-7 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055);
+};
+function blend(fg, bg, alpha) {
+  const a = Math.max(0, Math.min(1, alpha)), f = toRgb(fg), b = toRgb(bg);
+  return toHex(f.map((c, i) => c * a + (b[i] ?? 0) * (1 - a)));
+}
+var relativeLuminance = (hex) => {
+  const [r, g, b] = toRgb(hex);
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+};
+function contrastRatio(a, b) {
+  const x = relativeLuminance(a), y = relativeLuminance(b);
+  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+}
+function lab(hex) {
+  const [r, g, b] = toRgb(hex).map(linear);
+  const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047, y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b, z = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
+  const f = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
+  const fx = f(x), fy = f(y), fz = f(z);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function colorDifference(a, b) {
+  const [l1, a1, b1] = lab(a), [l2, a2, b2] = lab(b);
+  return Math.hypot(l1 - l2, a1 - a2, b1 - b2);
+}
+var CVD_MATRICES = {
+  // Machado, Oliveira and Fernandes (2009), severity 1.0, applied to linear sRGB.
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-3882e-6, -0.048116, 1.051998]
+  ],
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.01182, 0.04294, 0.968881]
+  ],
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [4733e-6, 0.691367, 0.3039]
+  ]
+};
+var visionModels = ["protanopia", "deuteranopia", "tritanopia", "greyscale"];
+function simulateVision(hex, model) {
+  const rgb = toRgb(hex).map(linear);
+  if (model === "greyscale") {
+    const y = 0.2126 * (rgb[0] ?? 0) + 0.7152 * (rgb[1] ?? 0) + 0.0722 * (rgb[2] ?? 0);
+    const v = delinear(y);
+    return toHex([v, v, v]);
+  }
+  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))));
+}
+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) {
+    case "theme":
+      return { kind: "solid", color: blend(colorFrom(scheme, bg.slot, canvas), PAGE, opacity) };
+    case "solid":
+      return { kind: "solid", color: blend(resolve2(bg.color, PAGE), PAGE, opacity) };
+    case "gradient": {
+      const stops = Array.isArray(rec(bg.gradient).stops) ? rec(bg.gradient).stops : [];
+      return {
+        kind: "gradient",
+        angle: Number(rec(bg.gradient).angle ?? 0),
+        stops: stops.map((stop, index) => ({
+          color: blend(resolve2(stop.color, canvas), PAGE, opacity),
+          position: typeof stop.position === "number" ? stop.position : index / Math.max(1, stops.length - 1)
+        }))
+      };
+    }
+    case "pattern": {
+      const pattern = rec(bg.pattern);
+      return {
+        kind: "pattern",
+        colors: [
+          blend(resolve2(pattern.backgroundColor, PAGE), PAGE, opacity),
+          blend(resolve2(pattern.foregroundColor, text), PAGE, opacity)
+        ]
+      };
+    }
+    case "image":
+      return { kind: "image", opacity, base: PAGE };
+    default:
+      return { kind: "solid", color: canvas };
+  }
+}
+function backgroundColorRef(value, scheme, variables, fallback) {
+  if (typeof value !== "string") return fallback;
+  const literal = normalizeHexColor(value);
+  if (literal) return literal;
+  const roles = resolveColorRoles(scheme);
+  return resolveColorRef(value.trim(), {
+    colorScheme: scheme,
+    roles: { primary: roles.primary, secondary: roles.secondary, accent: roles.accent },
+    variables,
+    fallback
+  });
+}
+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) {
+    case "theme":
+      return colorFrom(scheme, bg.slot, canvas);
+    case "solid":
+      return reference(bg.color);
+    case "pattern":
+      return reference(rec(bg.pattern).backgroundColor);
+    default:
+      return void 0;
+  }
+}
+function resolveDesign(document, index, context) {
+  const deck = rec(document.design), own2 = rec(rec(rec(document.slides)[index]).design);
+  const { options, diagnostics, resolved } = context;
+  const { theme, colorScheme, fontScheme, fontSchemePath } = resolved;
+  const fontPath = `/${fontSchemePath.split(".").join("/")}`;
+  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 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,
+    fontScheme,
+    fonts: options.fontFamilies,
+    dimensions,
+    backdrop,
+    dark,
+    colors: {
+      background: roles.background,
+      surface: roles.surface,
+      text,
+      mutedText: roles.textSecondary,
+      primary: roles.primary,
+      secondary: roles.secondary,
+      accent: roles.accent
+    },
+    variables,
+    ...backgroundImage ? { backgroundImage } : {},
+    fontSchemePath: fontPath,
+    ...fontDiagnostic ? { unresolvedFontScheme: fontDiagnostic.reference } : {}
+  };
+}
+function resolveTextColor(reference, design, fallback) {
+  if (typeof reference !== "string" || !reference.trim()) return void 0;
+  const literal = normalizeHexColor(reference);
+  if (literal) return literal;
+  return resolveColorRef(reference.trim(), {
+    colorScheme: design.colorScheme,
+    roles: {
+      primary: design.colors.primary,
+      secondary: design.colors.secondary,
+      accent: design.colors.accent,
+      background: design.colors.background,
+      surface: design.colors.surface,
+      text: design.colors.text,
+      textSecondary: design.colors.mutedText
+    },
+    variables: design.variables,
+    fallback
+  });
+}
+var GREY_RAMP = [0, 32, 64, 96, 128, 160, 192, 224, 255].map((v) => toHex([v, v, v]));
+function backdropColors(backdrop, box, size, layer) {
+  switch (backdrop.kind) {
+    case "solid":
+      return { colors: [backdrop.color], unknown: false };
+    case "pattern":
+      return { colors: [...backdrop.colors], unknown: false };
+    case "gradient": {
+      const stops = [...backdrop.stops].sort((a, b) => a.position - b.position);
+      if (!stops.length) return { colors: [PAGE], unknown: false };
+      const angle = backdrop.angle * Math.PI / 180, c = Math.cos(angle), s = Math.sin(angle), region = box ?? { x: 0, y: 0, width: size.width, height: size.height };
+      const colors = /* @__PURE__ */ new Set();
+      for (let i = 0; i <= 4; i++)
+        for (let j = 0; j <= 4; j++) {
+          const px = (region.x + region.width * i / 4) / size.width, py = (region.y + region.height * j / 4) / size.height, t = Math.max(0, Math.min(1, 0.5 + (px - 0.5) * c + (py - 0.5) * s));
+          const after = stops.findIndex((stop) => stop.position >= t);
+          if (after <= 0) colors.add(stops[Math.max(0, after)]?.color ?? PAGE);
+          else {
+            const lo = stops[after - 1], hi = stops[after], span = hi.position - lo.position || 1;
+            colors.add(blend(hi.color, lo.color, (t - lo.position) / span));
+          }
+        }
+      return { colors: [...colors], unknown: false };
+    }
+    case "image": {
+      const opacity = layer?.opacity ?? backdrop.opacity;
+      const colors = GREY_RAMP.map((grey) => {
+        let color = blend(grey, backdrop.base, opacity);
+        if (layer?.overlay) color = blend(layer.overlay.color, color, layer.overlay.opacity);
+        return color;
+      });
+      return { colors, unknown: true };
+    }
+  }
+}
+function worstContrast(text, sample) {
+  let worst = { ratio: Infinity, against: sample.colors[0] ?? PAGE };
+  for (const color of sample.colors) {
+    const ratio = contrastRatio(text, color);
+    if (ratio < worst.ratio) worst = { ratio, against: color };
+  }
+  return worst;
+}
+function readableColor(candidates, sample, minimum) {
+  for (const candidate of [...candidates, "#000000", "#FFFFFF"])
+    if (worstContrast(candidate, sample).ratio >= minimum) return candidate;
+  return void 0;
+}
+var DEFAULT_CHART_PALETTE = [
+  "#2874A6",
+  "#1B4F72",
+  "#5499C7",
+  "#7BDBB2",
+  "#3AC67A",
+  "#24A89E",
+  "#F59E0B",
+  "#EF4444",
+  "#8B5CF6",
+  "#14B8A6",
+  "#0F172A",
+  "#64748B"
+];
+
+// src/rule-content.ts
+var pointer2 = (...parts2) => parts2.length ? "/" + parts2.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
+var pointerOfDotted = (path) => "/" + path.split(".").map((part) => part.replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
+function slidePayloads(slide, slidePath) {
+  const out = [{ path: slidePath, node: slide, root: true }];
+  visitContentPayloads(slide, slidePath, (node, path) => out.push({ path, node, root: false }));
+  return out;
+}
+var isText = (value) => typeof value === "string" || Array.isArray(value);
+function textValues(slide, slidePath) {
+  const out = [];
+  for (const field of ["title", "subtitle", "tag"])
+    if (isText(slide[field])) out.push({ path: pointer2(...splitPointer(slidePath), field), value: slide[field], role: field, payload: slidePath, field });
+  for (const payload of slidePayloads(slide, slidePath)) {
+    const node = payload.node, at2 = (...tail) => pointer2(...splitPointer(payload.path), ...tail);
+    const push = (path, value, role, field) => {
+      if (isText(value)) out.push({ path, value, role, payload: payload.path, field });
+    };
+    push(at2("text"), node.text, "body", "text");
+    for (const field of ["items", "bullets"])
+      if (Array.isArray(node[field]))
+        node[field].forEach((entry, index) => {
+          if (isText(entry)) push(at2(field, index), entry, "list", field);
+          else if (entry && typeof entry === "object") {
+            push(at2(field, index, "text"), entry.text, "list", field);
+            push(at2(field, index, "description"), entry.description, "list-description", field);
+          }
+        });
+    const table = rec(node.table);
+    if (Array.isArray(table.columns))
+      table.columns.forEach((cell, c) => {
+        const styled = rec(cell);
+        if (!Object.hasOwn(styled, "value") && typeof styled.name === "string") push(at2("table", "columns", c, "name"), styled.name, "table-header", "table");
+        else {
+          const value = Object.hasOwn(styled, "value") ? styled.value : cell;
+          push(at2("table", "columns", c, ...Object.hasOwn(styled, "value") ? ["value"] : []), value, "table-header", "table");
+        }
+      });
+    if (Array.isArray(table.rows))
+      table.rows.forEach((row, r) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, c) => {
+          const styled = rec(cell);
+          const value = Object.hasOwn(styled, "value") ? styled.value : cell;
+          push(at2("table", "rows", r, c, ...Object.hasOwn(styled, "value") ? ["value"] : []), value, "table", "table");
+        });
+      });
+    const quote = node.quote;
+    if (typeof quote === "string") push(at2("quote"), quote, "quote", "quote");
+    else if (quote && typeof quote === "object") {
+      push(at2("quote", "text"), quote.text, "quote", "quote");
+      push(at2("quote", "attribution"), quote.attribution, "quote-footer", "quote");
+      push(at2("quote", "role"), quote.role, "quote-footer", "quote");
+      push(at2("quote", "source"), quote.source, "quote-footer", "quote");
+    }
+    const metric = node.metric;
+    if (typeof metric === "string") push(at2("metric"), metric, "metric", "metric");
+    else if (metric && typeof metric === "object")
+      for (const key of ["value", "label", "unit", "delta"]) {
+        const value = metric[key];
+        if (typeof value === "string") push(at2("metric", key), value, "metric", "metric");
+      }
+    const timeline = node.timeline, events = Array.isArray(timeline) ? timeline : Array.isArray(rec(timeline).events) ? rec(timeline).events : [];
+    if (typeof rec(timeline).name === "string") push(at2("timeline", "name"), rec(timeline).name, "timeline", "timeline");
+    events.forEach((event, index) => {
+      const base = Array.isArray(timeline) ? ["timeline", index] : ["timeline", "events", index];
+      push(at2(...base, "when"), event?.when, "timeline", "timeline");
+      push(at2(...base, "what"), event?.what, "timeline", "timeline");
+    });
+  }
+  return out;
+}
+function splitPointer(path) {
+  return path === "" ? [] : path.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+var plainText = (value) => typeof value === "string" ? value : value.map((run) => typeof run === "string" ? run : typeof rec(run).text === "string" ? rec(run).text : "").join("");
+function runsOf(tv) {
+  if (typeof tv.value === "string") return [{ path: tv.path, text: tv.value, style: {}, index: -1, valuePath: tv.path }];
+  return tv.value.map((run, index) => ({
+    path: pointer2(...splitPointer(tv.path), index),
+    text: typeof run === "string" ? run : typeof rec(run).text === "string" ? rec(run).text : "",
+    style: typeof run === "string" ? {} : rec(run),
+    index,
+    valuePath: tv.path
+  }));
+}
+function altOf(value, assets) {
+  const own2 = typeof value === "object" && value !== null ? value.alt : void 0;
+  if (typeof own2 === "string") return own2;
+  let source = typeof value === "string" ? value : rec(value).src;
+  for (let hop = 0; typeof source === "string" && source.startsWith("asset:") && hop < 8; hop++) {
+    const entry = rec(assets)[source.slice(6)];
+    if (typeof rec(entry).alt === "string") return rec(entry).alt;
+    source = typeof entry === "string" ? entry : rec(entry).src;
+  }
+  return void 0;
+}
+var sourceOfAsset = (value) => {
+  const source = typeof value === "string" ? value : rec(value).src;
+  return typeof source === "string" ? source : void 0;
+};
+var LOGO_VARIANTS = ["default", "light", "dark", "stacked", "stackedLight", "stackedDark", "icon", "iconLight", "iconDark", "wordmark", "wordmarkLight", "wordmarkDark"];
+function assetRefs(document, slide, slidePath, includeDeck) {
+  const out = [];
+  for (const payload of slidePayloads(slide, slidePath)) {
+    const at2 = (...tail) => pointer2(...splitPointer(payload.path), ...tail);
+    if (payload.node.image !== void 0) out.push({ path: at2("image"), value: payload.node.image, kind: "image" });
+    if (payload.node.video !== void 0) out.push({ path: at2("video"), value: payload.node.video, kind: "video" });
+    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 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") {
+      for (const variant of LOGO_VARIANTS)
+        if (logo[variant] !== void 0) out.push({ path: `${base}/logo/${variant}`, value: logo[variant], kind: "logo" });
+    }
+    for (const kind of ["header", "footer"])
+      for (const zone of ["left", "center", "right"]) {
+        const item = rec(rec(design[kind])[zone]);
+        if (item.image !== void 0) out.push({ path: `${base}/${kind}/${zone}/image`, value: item.image, kind: "furniture" });
+      }
+  };
+  designRefs(rec(slide.design), `${slidePath}/design`);
+  if (includeDeck) {
+    designRefs(rec(document.design), "/design");
+    const organizations = Array.isArray(document.organization) ? document.organization : document.organization ? [document.organization] : [];
+    organizations.forEach((organization, index) => {
+      if (organization?.logo !== void 0)
+        out.push({
+          path: Array.isArray(document.organization) ? `/organization/${index}/logo` : "/organization/logo",
+          value: organization.logo,
+          kind: "organization"
+        });
+    });
+    const speakers = Array.isArray(document.speaker) ? document.speaker : document.speaker ? [document.speaker] : [];
+    speakers.forEach((speaker, index) => {
+      if (speaker?.photo !== void 0)
+        out.push({ path: Array.isArray(document.speaker) ? `/speaker/${index}/photo` : "/speaker/photo", value: speaker.photo, kind: "speaker" });
+    });
+  }
+  return out;
+}
+
+// src/rules-accessibility.ts
+var PX_TO_PT = 0.75;
+var isLarge = (sizePx, bold) => {
+  const pt = sizePx * PX_TO_PT;
+  return pt >= 18 || bold && pt >= 14;
+};
+function slideBackdrop(context, box) {
+  const { design, composition } = context;
+  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);
+}
+function inkBox(item, measurement) {
+  const fit = item.text;
+  if (!fit || !Array.isArray(fit.lines) || !fit.lines.length || !item.textStyle || item.quoteLayout || item.metricLayout || item.timelineLayout) return item.box;
+  try {
+    const measure = textWidthMeasurer(item.textStyle, measurement);
+    const width = Math.min(item.box.width, Math.max(...fit.lines.map((line) => measure(line, fit.fontSize))));
+    const height = Math.min(item.box.height, fit.lines.length * fit.lineHeight);
+    const x = item.alignment === "center" ? item.box.x + (item.box.width - width) / 2 : item.alignment === "right" ? item.box.x + item.box.width - width : item.box.x;
+    return { x, y: item.box.y, width, height };
+  } catch {
+    return item.box;
+  }
+}
+function collectSamples(context) {
+  const measurement = context.measurement;
+  const { design, composition } = context;
+  if (!composition) return [];
+  const samples = [];
+  const surface = { colors: [design.colors.surface], unknown: false };
+  const scale = Math.min(design.dimensions.width, design.dimensions.height) / 720;
+  for (const item of composition.items) {
+    if (["chart", "image", "video", "code"].includes(item.field) || item.type === "chart" || item.type === "image" || item.type === "video" || item.type === "code") continue;
+    const backdrop = item.frameBox ? surface : slideBackdrop(context, inkBox(item, measurement));
+    const itemPath = pointerOfDotted(item.path);
+    const heading = item.field === "title" || item.field === "subtitle" || item.field === "tag";
+    const baseSize = (item.text?.fontSize ?? 25 * scale) / scale;
+    const bold = item.field === "title";
+    const label = item.field === "title" ? "Title" : item.field === "subtitle" ? "Subtitle" : item.field === "tag" ? "Tag" : "Text";
+    if (item.field === "table") {
+      const grid = tableGrid(item.value, item.path);
+      for (const row of grid.rows)
+        for (const cell of row) {
+          const fillRef = resolveTextColor(cell.style.fill, design, "");
+          const fill = fillRef || (cell.header ? design.colors.primary : design.colors.surface);
+          const cellBackdrop = { colors: [fill], unknown: false };
+          const cellPath = pointerOfDotted(cell.valuePath);
+          const stylePath = pointerOfDotted(cell.path) + "/style/color";
+          if (cell.style.color != null) {
+            const color = resolveTextColor(cell.style.color, design, design.colors.text);
+            if (color) samples.push({ path: stylePath, color, sizePx: 15, bold: cell.header, backdrop: cellBackdrop, source: "override", colorPath: stylePath, label: "Table cell text" });
+          }
+          if (Array.isArray(cell.value))
+            cell.value.forEach((run, index) => {
+              const colorRef = rec(run).color;
+              if (typeof colorRef !== "string") return;
+              const color = resolveTextColor(colorRef, design, design.colors.text);
+              if (color) samples.push({ path: `${cellPath}/${index}/color`, color, sizePx: rec(run).fontSize ? Number(rec(run).fontSize) / PX_TO_PT : 15, bold: Boolean(rec(run).bold) || cell.header, backdrop: cellBackdrop, source: "override", colorPath: `${cellPath}/${index}/color`, label: "Table cell text" });
+            });
+        }
+      continue;
+    }
+    const parts2 = [];
+    const layoutOf = item.quoteLayout ?? item.metricLayout ?? item.timelineLayout;
+    if (layoutOf)
+      for (const part of layoutOf.parts) {
+        if (!part.fit || part.visible === false) continue;
+        const role = String(part.role ?? "");
+        parts2.push({
+          path: typeof part.path === "string" && part.path.startsWith("slides.") ? pointerOfDotted(part.path) : itemPath,
+          sizePx: part.fit.fontSize / scale,
+          color: role === "footer" ? design.colors.mutedText : role === "value" && item.metricLayout ? design.colors.primary : item.timelineLayout ? timelineTextColor(part, { background: design.colors.background, primary: design.colors.primary, text: design.colors.text, mutedText: design.colors.mutedText }) : design.colors.text,
+          label: item.field === "quote" ? role === "footer" ? "Quote attribution" : "Quote" : item.field === "metric" ? role === "value" ? "Metric value" : "Metric label" : "Timeline text"
+        });
+      }
+    else parts2.push({ path: itemPath, sizePx: baseSize, color: design.colors.text, label: heading || item.field === "text" ? label : item.field === "items" || item.field === "bullets" ? "List text" : label });
+    for (const part of parts2) samples.push({ path: part.path, color: part.color, sizePx: part.sizePx, bold, backdrop, source: "default", label: part.label });
+    const owners = textValues({ [item.field]: item.value }, "");
+    for (const owner of owners) {
+      if (typeof owner.value === "string") continue;
+      const relative = splitPointer(owner.path).slice(1);
+      const base = pointer2(...splitPointer(itemPath), ...relative);
+      for (const run of runsOf({ ...owner, path: base })) {
+        if (typeof run.style.color !== "string") continue;
+        const color = resolveTextColor(run.style.color, design, design.colors.text);
+        if (!color) continue;
+        const size = typeof run.style.fontSize === "number" ? run.style.fontSize / PX_TO_PT : baseSize;
+        samples.push({ path: `${run.path}/color`, color, sizePx: size, bold: Boolean(run.style.bold) || bold, backdrop, source: "override", colorPath: `${run.path}/color`, label: "Coloured text" });
+      }
+    }
+  }
+  for (const part of composition.furniture?.parts ?? [])
+    if (part.type === "text")
+      samples.push({ path: pointerOfDotted(part.sourcePath ?? part.path), color: design.colors.mutedText, sizePx: (part.fit?.fontSize ?? 13 * scale) / scale, bold: false, backdrop: slideBackdrop(context, part.box), source: "default", label: part.kind === "header" ? "Header text" : "Footer text" });
+  return samples;
+}
+var contrastRule = rule(
+  "text-contrast",
+  "accessibility",
+  "warning",
+  "Text colour has too little contrast against the background it sits on.",
+  "Low-contrast text is hard or impossible to read for people with low vision, colour-vision differences, glare on a projector or a poor display. WCAG sets 4.5:1 for normal text and 3:1 for large text.",
+  {
+    standard: "WCAG 2.2 SC 1.4.3 Contrast (Minimum), level AA",
+    thresholds: ["contrastNormal", "contrastLarge"],
+    cost: "composition",
+    approximations: "Computed on sRGB colours with the WCAG relative-luminance formula, against the background the preview draws: a solid or theme colour, the card surface, a table cell fill, every colour a gradient takes under the text box (sampled on a 5x5 grid, angle respected), or both colours of a pattern. Anti-aliasing, text shadows and font weight are not modelled. Text colour is the preview's (the scheme's text role or dark1 on a light background and light1 on a dark one, chosen from the background luminance, where a gradient or picture background uses the scheme's default background colour), so a default can fail on a dark gradient. A link with no colour of its own is measured in the scheme's hyperlink colour."
+  }
+);
+var onImageRule = rule(
+  "text-on-image",
+  "accessibility",
+  "info",
+  "Text sits on a background picture whose pixels cannot be measured.",
+  "Contrast over a photograph depends on the photograph. Without a full-frame overlay that guarantees readability for every possible image, the result cannot be certified from the document.",
+  {
+    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.background overlay; the text passes only when every step of that ramp passes. An edge-banded overlay is not counted."
+  }
+);
+var contrastRules = [
+  {
+    info: contrastRule,
+    also: [onImageRule],
+    run(context) {
+      const { thresholds } = context;
+      for (const slide of context.slides) {
+        const aggregated = /* @__PURE__ */ new Map();
+        const imageReported = { done: false };
+        for (const sample of collectSamples(slide)) {
+          const large = isLarge(sample.sizePx, sample.bold), needed = large ? thresholds.contrastLarge : thresholds.contrastNormal;
+          const worst = worstContrast(sample.color, sample.backdrop);
+          if (worst.ratio >= needed) continue;
+          if (sample.backdrop.unknown) {
+            if (!imageReported.done) {
+              imageReported.done = true;
+              context.report(onImageRule, {
+                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 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 }
+              });
+            }
+            continue;
+          }
+          const key = `${sample.source === "default" ? "default" : sample.path}|${sample.color}|${worst.against}|${large}`;
+          const known = aggregated.get(key);
+          if (known && sample.source === "default") {
+            known.extra++;
+            continue;
+          }
+          const fixes = [];
+          if (sample.colorPath) {
+            const preferred = readableColor([slide.design.colors.text], sample.backdrop, needed);
+            if (preferred !== void 0) {
+              const value = preferred.toUpperCase() === slide.design.colors.text.toUpperCase() ? "text" : preferred;
+              fixes.push({ id: "use-readable-color", title: value === "text" ? "Use the slide text colour" : `Use ${preferred}`, kind: "patch", safe: true, patch: [{ op: "replace", path: sample.colorPath, value }] });
+            }
+          }
+          const diagnostic = context.report(contrastRule, {
+            path: sample.path,
+            slide,
+            message: `${sample.label} colour ${sample.color} on ${worst.against} has a contrast ratio of ${worst.ratio.toFixed(2)}:1; ${needed}:1 is needed for ${large ? "large" : "normal"} text.`,
+            help: sample.source === "override" ? "Pick a colour with enough contrast against the background, or remove this colour override so the theme chooses a readable text colour." : "The theme text colour is unreadable on this background. Change the slide or deck background, the colour scheme (dark1/light1), or give the text an explicit readable colour.",
+            measured: { ratio: round(worst.ratio), needed, large, sizePt: round(sample.sizePx * PX_TO_PT), textColor: sample.color, backgroundColor: worst.against },
+            fixes
+          });
+          if (sample.source === "default") aggregated.set(key, { diagnostic, extra: 0 });
+        }
+        for (const { diagnostic, extra } of aggregated.values())
+          if (extra) {
+            diagnostic.message += ` ${extra} more text element${extra === 1 ? "" : "s"} on this slide ${extra === 1 ? "has" : "have"} the same problem.`;
+            if (diagnostic.measured) diagnostic.measured.alsoAffected = extra;
+          }
+      }
+    }
+  }
+];
+var round = (value) => Math.round(value * 100) / 100;
+var altRule = rule(
+  "missing-alt-text",
+  "accessibility",
+  "warning",
+  "A picture has no alt text and is not marked decorative.",
+  '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 (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(
+  "poor-alt-text",
+  "accessibility",
+  "info",
+  "Alt text is a file name, a URL, a generic word or very long.",
+  'Alt text such as "image", "IMG_2041.png" or a 400-character paragraph does not do the job of describing a picture: it is read out and adds noise without information.',
+  { standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A", approximations: 'Pattern checks only: file extensions and camera-style names, a bare generic word, a URL, a leading "image of", and more than 250 characters. Chart alt text (chart.alt) is checked too: a bare chart word, a URL, a leading "chart of" or more than 250 characters. It cannot tell whether a plausible sentence is accurate.' }
+);
+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", 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];
+}
+var altRules = [
+  {
+    info: altRule,
+    run(context) {
+      const seen = /* @__PURE__ */ new Set();
+      context.slides.forEach((slide, index) => {
+        for (const ref of assetRefs(context.document, slide.slide, slide.path, index === 0)) {
+          if (seen.has(ref.path)) continue;
+          seen.add(ref.path);
+          let alt = altOf(ref.value, context.document.assets);
+          if (ref.kind === "video" && !alt) alt = typeof rec(ref.value).title === "string" ? rec(ref.value).title : void 0;
+          if (alt !== void 0 && alt.trim() !== "") continue;
+          if (alt === "") continue;
+          const hasText = alt !== void 0;
+          const organization = ref.kind === "organization" || ref.kind === "logo" ? rec(Array.isArray(context.document.organization) ? context.document.organization[0] : context.document.organization).name : void 0;
+          context.report(altRule, {
+            path: ref.path,
+            slide: ref.path.startsWith("/slides/") ? slide : void 0,
+            message: `${kindLabel(ref.kind)} has ${hasText ? "blank" : "no"} alt text.`,
+            help: `Describe what the ${ref.kind === "logo" || ref.kind === "organization" ? "logo shows" : "picture shows or why it is here"}${typeof organization === "string" ? ` (for a logo, the organization name, ${organization}, is usually right)` : ""}, or set alt to "" if it is purely decorative.`,
+            fixes: altFixes(ref.path, ref.value)
+          });
+        }
+      });
+    }
+  },
+  {
+    info: poorAltRule,
+    run(context) {
+      const seen = /* @__PURE__ */ new Set();
+      context.slides.forEach((slide, index) => {
+        for (const ref of assetRefs(context.document, slide.slide, slide.path, index === 0)) {
+          if (seen.has(ref.path)) continue;
+          seen.add(ref.path);
+          const alt = altOf(ref.value, context.document.assets)?.trim();
+          if (!alt) continue;
+          const source = sourceOfAsset(ref.value);
+          const problem = GENERIC_ALT.test(alt) ? "is a generic word" : FILE_ALT.test(alt) ? "looks like a file name" : /^(https?:\/\/|data:|www\.)/i.test(alt) || source && alt === source ? "is a URL" : /^(image|picture|photo|graphic) of\b/i.test(alt) ? 'starts with "image of", which a screen reader already announces' : alt.length > 250 ? `is ${alt.length} characters long; aim for a sentence or two` : void 0;
+          if (!problem) continue;
+          context.report(poorAltRule, {
+            path: `${ref.path}${typeof ref.value === "object" ? "/alt" : ""}`,
+            slide: ref.path.startsWith("/slides/") ? slide : void 0,
+            message: `${kindLabel(ref.kind)} alt text ${JSON.stringify(alt.length > 60 ? `${alt.slice(0, 57)}...` : alt)} ${problem}.`,
+            help: 'Write what a person who cannot see the picture needs to know, in plain words and without a leading "image of".',
+            fixes: [{ id: "focus-alt", title: "Edit alt text", kind: "focus", safe: true, focus: { path: ref.path, field: "alt", value: ref.value } }]
+          });
+        }
+        for (const payload of slidePayloads(slide.slide, slide.path)) {
+          const chart = rec(payload.node.chart);
+          const alt = typeof chart.alt === "string" ? chart.alt.trim() : "";
+          if (!alt) continue;
+          const problem = GENERIC_ALT.test(alt) || GENERIC_CHART_ALT.test(alt) ? "is a generic word, not what the data shows" : /^(https?:\/\/|data:|www\.)/i.test(alt) ? "is a URL" : /^(image|picture|photo|graphic|chart|graph) of\b/i.test(alt) ? 'starts with "chart of" or "image of", which a screen reader already announces' : alt.length > 250 ? `is ${alt.length} characters long; aim for a sentence or two` : void 0;
+          if (!problem) continue;
+          const path = `${payload.path}/chart/alt`;
+          if (seen.has(path)) continue;
+          seen.add(path);
+          context.report(poorAltRule, {
+            path,
+            slide,
+            message: `Chart alt text ${JSON.stringify(alt.length > 60 ? `${alt.slice(0, 57)}...` : alt)} ${problem}.`,
+            help: "State what the chart shows: its point and the key numbers, in a sentence or two.",
+            fixes: [{ id: "focus-alt", title: "Edit alt text", kind: "focus", safe: true, focus: { path: `${payload.path}/chart`, field: "alt", value: chart.alt } }]
+          });
+        }
+      });
+    }
+  }
+];
+var missingTitleRule = rule(
+  "missing-slide-title",
+  "accessibility",
+  "warning",
+  "A slide has no title.",
+  "Slide titles are how people using a screen reader, an outline view or keyboard navigation find and tell slides apart; PowerPoint's own accessibility checker reports a missing title too.",
+  { standard: 'WCAG 2.2 SC 2.4.2 Page Titled and SC 2.4.6 Headings and Labels, level AA (PowerPoint: "Missing slide title")', approximations: "Only the slide-level title field counts. Text that merely looks like a heading inside a block does not." }
+);
+var duplicateTitleRule = rule(
+  "duplicate-slide-title",
+  "accessibility",
+  "info",
+  "Two slides have the same title.",
+  "Identical titles make slides indistinguishable in an outline or a screen reader's slide list.",
+  { approximations: 'Titles are compared case-insensitively with whitespace collapsed. Slides that continue one another are not exempt; give a continuation a distinct title such as "(continued)".' }
+);
+var titleRules = [
+  {
+    info: missingTitleRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const title = slide.slide.title;
+        if ((typeof title === "string" || Array.isArray(title)) && plainText(title).trim() !== "") continue;
+        context.report(missingTitleRule, {
+          path: slide.path,
+          slide,
+          message: `Slide ${slide.index + 1} has no title.`,
+          help: "Give the slide a short, specific title. If the design has no room for a visible title, keep it short; the title also names the slide for assistive technology.",
+          fixes: [{ id: "focus-title", title: "Write a title", kind: "focus", safe: true, focus: { path: `${slide.path}/title`, field: "title" } }]
+        });
+      }
+    }
+  },
+  {
+    info: duplicateTitleRule,
+    run(context) {
+      const first = /* @__PURE__ */ new Map();
+      for (const slide of context.slides) {
+        const title = typeof slide.slide.title === "string" || Array.isArray(slide.slide.title) ? plainText(slide.slide.title).trim().replace(/\s+/g, " ").toLowerCase() : "";
+        if (!title) continue;
+        const earlier = first.get(title);
+        if (earlier === void 0) first.set(title, slide.index);
+        else
+          context.report(duplicateTitleRule, {
+            path: `${slide.path}/title`,
+            slide,
+            message: `Slide ${slide.index + 1} has the same title as slide ${earlier + 1}: ${JSON.stringify(plainText(slide.slide.title).trim())}.`,
+            help: "Make the titles distinct so each slide can be told apart in an outline or by assistive technology.",
+            fixes: [{ id: "focus-title", title: "Edit the title", kind: "focus", safe: true, focus: { path: `${slide.path}/title`, field: "title" } }]
+          });
+      }
+    }
+  }
+];
+var readingOrderRule = rule(
+  "reading-order",
+  "accessibility",
+  "warning",
+  "The order content is read differs from the order it appears on the slide.",
+  "Screen readers, keyboard focus and PowerPoint's selection pane follow the composed order. When it differs from the visual order (top to bottom, then start to end of the reading direction), the slide is read out of sequence.",
+  {
+    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."
+  }
+);
+var readingOrderRules = [
+  {
+    info: readingOrderRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const composition = slide.composition;
+        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);
+          context.report(readingOrderRule, {
+            path: pointerOfDotted(above.path),
+            slide,
+            message: `Content ${JSON.stringify(shortField(above.path))} is drawn above the title but is read after it.`,
+            help: "Move the title above the content or change the layout so the title is the first thing on the slide."
+          });
+        }
+        if (body.length < 2) continue;
+        const visual = visualOrder(body, slide.rtl);
+        const composed = body.map((item) => item.path);
+        const index = composed.findIndex((path, i) => path !== visual[i]);
+        if (index < 0) continue;
+        const name = (path) => shortField(path);
+        context.report(readingOrderRule, {
+          path: pointerOfDotted(composed[index]),
+          slide,
+          message: `Reading order differs from visual order: ${JSON.stringify(name(composed[index]))} is read at ${ordinal(index)} but appears at ${ordinal(visual.indexOf(composed[index]))}. Composed order: ${composed.map(name).join(", ")}; visual order: ${visual.map(name).join(", ")}.`,
+          help: "Reorder the blocks (or rename promoted regions) so the composed order follows the visual order, or use blocks with an explicit composition instead of region keys.",
+          measured: { firstMismatch: index, composed: composed.length }
+        });
+      }
+    }
+  }
+];
+function visualOrder(items, rtl) {
+  if (rtl) return readingRows(items).flatMap((row) => row.map((item) => item.path));
+  return visualReadingOrder(items).map((item) => item.path);
+}
+var shortField = (path) => path.replace(/^slides\.\d+\./, "");
+var ordinal = (index) => `position ${index + 1}`;
+var linkRule = rule(
+  "link-text",
+  "accessibility",
+  "warning",
+  "Link text does not say where the link goes.",
+  `People who scan links out of context (a screen reader's links list, a link tab order) hear only the text. "click here", "read more" or a long raw URL tells them nothing about the destination.`,
+  { standard: 'WCAG 2.2 SC 2.4.4 Link Purpose (In Context), level A; PowerPoint: "Hyperlink text is not meaningful"', approximations: "Matches a short list of generic phrases in English (after lower-casing and removing punctuation), blank link text, and raw URLs longer than 40 characters. Adjacent runs sharing one link are read as one link." }
+);
+var GENERIC_LINKS = /* @__PURE__ */ new Set(["click here", "click", "here", "link", "this link", "this", "read more", "more", "learn more", "see more", "more info", "more information", "details", "download", "url", "website", "web site", "page", "this page", "visit", "go"]);
+var linkRules = [
+  {
+    info: linkRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          if (typeof tv.value === "string") continue;
+          const runs = runsOf(tv);
+          for (let i = 0; i < runs.length; i++) {
+            const run = runs[i];
+            const link = run.style.link;
+            if (typeof link !== "string") continue;
+            let text = run.text;
+            let last = i;
+            while (runs[last + 1] && runs[last + 1].style.link === link) text += runs[++last].text;
+            const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/g, " ").trim();
+            const problem = !text.trim() ? "is blank" : GENERIC_LINKS.has(normalized) ? "is generic" : /^(https?:\/\/|www\.)\S{30,}$/i.test(text.trim()) ? "is a long raw URL" : void 0;
+            i = last;
+            if (!problem) continue;
+            context.report(linkRule, {
+              path: run.path,
+              slide,
+              message: `Link text ${JSON.stringify(text.trim().slice(0, 50))} ${problem}; the destination is ${link.length > 60 ? `${link.slice(0, 57)}...` : link}.`,
+              help: 'Use text that names the destination or action, for example "Q3 financial results (PDF)", instead of "click here".',
+              fixes: [{ id: "focus-link", title: "Edit the text", kind: "focus", safe: true, focus: { path: run.valuePath, field: "link", value: link } }]
+            });
+          }
+        }
+    }
+  }
+];
+var chartColorRule = rule(
+  "chart-color-only",
+  "accessibility",
+  "info",
+  "Chart series may be indistinguishable without colour vision.",
+  "OPF charts have no data labels or patterns, so series are told apart by colour alone (and legend order). Colours that look alike to someone with colour-vision deficiency, or when printed in greyscale, make series impossible to tell apart.",
+  {
+    standard: "WCAG 2.2 SC 1.4.1 Use of Color, level A",
+    thresholds: ["minSeriesColorDifference"],
+    approximations: "Uses the engine's series palette (ValidateOptions.chartPalette; default the opf-render/opf-pptx palette, adjusted for the card surface like the preview does) in series order: series i takes colour i, pie/doughnut/treemap/funnel slices take colours per category. Pairs are compared by CIE76 distance after simulating protanopia, deuteranopia, tritanopia (Machado 2009, severity 1) and greyscale. Single-series charts and chart types without a series legend are skipped."
+  }
+);
+var chartAltRule = rule(
+  "chart-text-alternative",
+  "accessibility",
+  "info",
+  "A chart has no text alternative, or is marked decorative.",
+  "A chart conveys a message; people who cannot see it need the message and ideally the numbers in text. The chart's alt field is that text alternative (the preview exposes it as the chart's accessible name and the PowerPoint export writes it as the frame's alternative text); a sentence or table beside the chart also serves. An empty alt marks a chart decorative, which is reported as info so the choice is reviewed: a chart rarely carries no message.",
+  { standard: "WCAG 2.2 SC 1.1.1 Non-text Content, level A", approximations: `A chart passes when chart.alt has text. Without alt, it passes when the slide has any other text, list, table, quote or metric content besides title and tag, or a subtitle. It does not judge whether alt or that text states the chart's point (see opf/poor-alt-text for generic alt text). alt: "" is reported as a decorative chart, whatever else is on the slide.` }
+);
+var chartSkip = /(histogram|box|pareto|waterfall|world|map)/;
+var perCategory = /(pie|doughnut|treemap|funnel)/;
+var chartRules = [
+  {
+    info: chartColorRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const payload of slidePayloads(slide.slide, slide.path)) {
+          const chart = rec(payload.node.chart);
+          const resolved = resolveChartData(chart, context.document);
+          if (!resolved.ok) continue;
+          const data = { columns: resolved.columns.filter((_, index) => !(resolved.hasX && index === 1)), rows: resolved.rows };
+          const type = String(chart.type ?? "").toLowerCase();
+          if (chartSkip.test(type)) continue;
+          const slices = perCategory.test(type);
+          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);
+          if (!palette.length) continue;
+          const used = Array.from({ length: Math.min(count, 24) }, (_, i) => palette[i % palette.length]);
+          const pairs = [];
+          for (let a = 0; a < used.length; a++)
+            for (let b = a + 1; b < used.length; b++) {
+              let worst = { model: "normal vision", difference: colorDifference(used[a], used[b]) };
+              for (const model of visionModels) {
+                const difference = colorDifference(simulateVision(used[a], model), simulateVision(used[b], model));
+                if (difference < worst.difference) worst = { model, difference };
+              }
+              if (worst.difference < context.thresholds.minSeriesColorDifference) pairs.push({ a, b, ...worst });
+            }
+          const cycles = count > palette.length;
+          if (!pairs.length && !cycles) continue;
+          pairs.sort((x, y) => x.difference - y.difference);
+          const names2 = slices ? data.rows.map((row) => String(row?.[0] ?? "")) : data.columns.slice(1).map(String);
+          const describe = (p) => `${JSON.stringify(names2[p.a] ?? `#${p.a + 1}`)} and ${JSON.stringify(names2[p.b] ?? `#${p.b + 1}`)} (${p.model}, difference ${p.difference.toFixed(1)})`;
+          context.report(chartColorRule, {
+            path: `${payload.path === slide.path ? slide.path : payload.path}/chart`,
+            slide,
+            message: `${slices ? "Slices" : "Series"} may be hard to tell apart without colour: ${pairs.slice(0, 3).map(describe).join("; ")}${cycles ? `${pairs.length ? "; " : ""}${count} ${slices ? "slices" : "series"} exceed the ${palette.length}-colour palette, so colours repeat` : ""}.`,
+            help: "Show fewer series per chart (split into two charts), state the key values in the slide text or a table next to the chart, or choose a chart type whose categories sit on an axis instead of in a legend.",
+            measured: { series: count, confusablePairs: pairs.length, minDifference: pairs[0] ? round(pairs[0].difference) : null }
+          });
+        }
+    }
+  },
+  {
+    info: chartAltRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const payloads = slidePayloads(slide.slide, slide.path).filter((p) => !p.node.blocks && !p.node.composition || p.root);
+        const charts = payloads.filter((p) => p.node.chart !== void 0);
+        if (!charts.length) continue;
+        const textual = (p) => ["text", "items", "bullets", "table", "quote", "metric", "timeline"].some((field) => p.node[field] !== void 0 && p.node[field] !== "" && !(Array.isArray(p.node[field]) && p.node[field].length === 0));
+        const textBeside = payloads.some(textual) || (typeof slide.slide.subtitle === "string" || Array.isArray(slide.slide.subtitle)) && plainText(slide.slide.subtitle).trim() !== "";
+        const where = (chart) => charts.length > 1 ? `chart ${charts.indexOf(chart) + 1} on slide ${slide.index + 1}` : `chart on slide ${slide.index + 1}`;
+        const focusAlt = (chart) => ({ id: "focus-alt", title: "Write alt text", kind: "focus", safe: true, focus: { path: `${chart.path}/chart`, field: "alt", value: rec(chart.node.chart).alt } });
+        let reported = false;
+        for (const chart of charts) {
+          const alt = rec(chart.node.chart).alt;
+          if (typeof alt === "string" && alt.trim() !== "") continue;
+          if (alt === "") {
+            context.report(chartAltRule, {
+              path: `${chart.path}/chart/alt`,
+              slide,
+              message: `The ${where(chart)} is marked decorative (empty alt), so assistive technology skips it.`,
+              help: "Keep the empty alt only if the chart adds nothing the slide text does not already say. Otherwise describe what it shows: its point and the key numbers.",
+              fixes: [focusAlt(chart)]
+            });
+            continue;
+          }
+          if (textBeside || reported) continue;
+          reported = true;
+          context.report(chartAltRule, {
+            path: `${chart.path}/chart`,
+            slide,
+            message: `The ${where(chart)} has no alt text and no text beside it that states what it shows.`,
+            help: "Set chart.alt to a sentence with the chart's point and key numbers, or add a subtitle, text block or table with them, so the message does not depend on seeing the chart.",
+            fixes: [focusAlt(chart), { id: "focus-subtitle", title: "Write a subtitle", kind: "focus", safe: true, focus: { path: `${slide.path}/subtitle`, field: "text" } }]
+          });
+        }
+      }
+    }
+  }
+];
+var languageRule = rule(
+  "missing-language",
+  "accessibility",
+  "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)." }
+);
+var languageRules = [
+  {
+    info: languageRule,
+    run(context) {
+      if (context.document.language !== void 0) return;
+      context.report(languageRule, {
+        path: "",
+        message: "The presentation has no language set.",
+        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" } }]
+      });
+    }
+  }
+];
+var accessibilityRules = [
+  ...contrastRules,
+  ...altRules,
+  ...titleRules,
+  ...readingOrderRules,
+  ...linkRules,
+  ...chartRules,
+  ...languageRules
+];
+
+// src/rules-layout-content.ts
+var PX_TO_PT2 = 0.75;
+var round2 = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
+var overflowRule = rule(
+  "text-overflow",
+  "layout",
+  "warning",
+  "Text or a table does not fit its space at the smallest allowed size.",
+  "Core composition shrinks text to the readable minimum and then reports what still does not fit. Overflowing text is clipped or runs over other content in the preview and in PowerPoint.",
+  {
+    cost: "composition",
+    approximations: "Uses composeSlide at the deck's slide size with the fonts of the resolved font scheme. Without a host-supplied text measurement (ValidateOptions.fonts.textMeasurement) widths are core's portable estimate, which can differ from the real font by a few percent; pass the renderer's measurement for font-exact results. A composition that sets overflow: \"error\" is reported as a warning here, so that `valid` never depends on font metrics; rendering and export still refuse such a slide when it does not fit."
+  }
+);
+var unresolvedRule = rule(
+  "unresolved-content",
+  "layout",
+  "warning",
+  "Content cannot be drawn as authored.",
+  "composeSlide reports content it cannot place or an effect it does not support (for example a picture bullet without a logo, a date field without a date, or an unsupported image treatment). The preview and the export fall back.",
+  { cost: "composition" }
+);
+var layoutFailedRule = rule(
+  "layout-failed",
+  "layout",
+  "warning",
+  "The slide layout could not be computed.",
+  "Composition threw for a slide that passed schema validation, so geometry-based rules (contrast, overflow, reading order, resolution) were skipped for it.",
+  { cost: "composition" }
+);
+var minFontRule = rule(
+  "min-font-size",
+  "layout",
+  "warning",
+  "Text is drawn smaller than the readable minimum.",
+  "Small type is unreadable from the back of a room and on a phone. The engine's own default floor is 12 pt (16 px); anything much below that was lowered on purpose or by a composition that could not fit the text.",
+  {
+    cost: "composition",
+    standard: "Common presentation guidance (12 pt minimum for body text; 18 pt or more is easier to read from a distance).",
+    thresholds: ["minFontSizePt"],
+    approximations: "Sizes are those composeSlide fitted, expressed on the 13.33 x 7.5 in reference slide (96 px per inch, so 1 px is 0.75 pt; a smaller canvas scales type down with it) and explicit run fontSize values in points. Per payload, the smallest part (a metric label or a quote attribution) is reported. Table cell text (default 11.25 pt), code and header/footer furniture are not checked."
+  }
+);
+var layoutRules = [
+  {
+    info: overflowRule,
+    also: [unresolvedRule, layoutFailedRule, minFontRule],
+    run(context) {
+      const deckLevel = /* @__PURE__ */ new Set();
+      for (const slide of context.slides) {
+        if (slide.layoutError)
+          context.report(layoutFailedRule, { path: slide.path, slide, message: `Layout failed: ${slide.layoutError}`, help: "Fix the composition settings or content structure named in the message; geometry-based rules were skipped for this slide." });
+        for (const { diagnostic } of slide.layoutDiagnostics) {
+          const path = pointerOfDotted(diagnostic.path);
+          if (!path.startsWith("/slides/")) {
+            const key = `${diagnostic.code}|${path}|${diagnostic.message}`;
+            if (deckLevel.has(key)) continue;
+            deckLevel.add(key);
+          }
+          if (diagnostic.code === "text-overflow")
+            context.report(overflowRule, { path, slide, message: diagnostic.message, help: "Shorten the text, give it more space (fewer blocks, a different composition) or split the slide (paginate); raising the readable minimum makes it worse." });
+          else if (diagnostic.code === "small-cell") continue;
+          else context.report(unresolvedRule, { path, slide: path.startsWith("/slides/") ? slide : void 0, message: diagnostic.message, help: "Supply what the message asks for, or remove the setting that cannot be honoured." });
+        }
+        for (const tv of slide.texts)
+          for (const run of runsOf(tv))
+            if (typeof run.style.fontSize === "number" && run.style.fontSize < context.thresholds.minFontSizePt)
+              context.report(minFontRule, {
+                path: `${run.path}/fontSize`,
+                slide,
+                message: `Text run is set to ${run.style.fontSize} pt, below the ${context.thresholds.minFontSizePt} pt minimum.`,
+                help: "Remove the size override so the text uses the fitted size, or raise it.",
+                measured: { sizePt: run.style.fontSize, minimumPt: context.thresholds.minFontSizePt },
+                fixes: [{ id: "focus-font-size", title: "Edit the size", kind: "focus", safe: true, focus: { path: `${run.path}/fontSize`, field: "fontSize" } }]
+              });
+        const composition = slide.composition;
+        if (!composition) continue;
+        const scale = Math.min(composition.width, composition.height) / 720;
+        const limitPx = context.thresholds.minFontSizePt / PX_TO_PT2;
+        const small = (path, sizes, label) => {
+          const known = sizes.filter((size) => size !== void 0);
+          const sizePx = known.length ? Math.min(...known) / scale : void 0;
+          if (sizePx === void 0 || sizePx >= limitPx - 1e-6) return;
+          context.report(minFontRule, {
+            path,
+            slide,
+            message: `${label} is drawn at ${round2(sizePx * PX_TO_PT2)} pt${scale === 1 ? "" : " (reference slide size)"}, below the ${context.thresholds.minFontSizePt} pt minimum.`,
+            help: "Shorten the text or give it more room so it can be drawn larger; check composition.minFontSize and run fontSize settings that force small type.",
+            measured: { sizePt: round2(sizePx * PX_TO_PT2, 2), minimumPt: context.thresholds.minFontSizePt }
+          });
+        };
+        for (const item of composition.items) {
+          if (item.field === "code" || item.field === "table" || item.type === "code" || item.type === "table") continue;
+          const layout = item.quoteLayout ?? item.metricLayout ?? item.timelineLayout;
+          if (layout) small(pointerOfDotted(item.path), layout.parts.map((part) => part.visible === false ? void 0 : part.fit?.fontSize), "The smallest text");
+          else small(pointerOfDotted(item.path), [item.text?.fontSize], item.field === "title" ? "Title" : "Text");
+        }
+      }
+    }
+  }
+];
+var outsideRule = rule(
+  "font-outside-scheme",
+  "layout",
+  "warning",
+  "Text uses a font family that is not in the deck's font scheme.",
+  "The font scheme is the deck's font choice. A run that names another family will not follow a font-scheme change, may be missing on the viewer's machine, and breaks the deck's typographic consistency.",
+  { approximations: "Compares the run's fontFamily (case-insensitively) with the heading, body, code and accent families of the slide's resolved font scheme and the scheme's major/minor fonts. Families that the host substitutes are still different names here." }
+);
+var fontRules = [
+  {
+    info: outsideRule,
+    run(context) {
+      for (const slide of context.slides) {
+        const allowed = new Set(
+          [slide.design.fonts.heading, slide.design.fonts.body, slide.design.fonts.code, slide.design.fonts.accent, slide.design.fontScheme.major, slide.design.fontScheme.minor].filter((family) => typeof family === "string").map((family) => family.toLowerCase())
+        );
+        const reported = /* @__PURE__ */ new Set();
+        for (const tv of slide.texts)
+          for (const run of runsOf(tv)) {
+            const family = run.style.fontFamily;
+            if (typeof family !== "string" || !family.trim() || allowed.has(family.trim().toLowerCase()) || reported.has(family.toLowerCase())) continue;
+            reported.add(family.toLowerCase());
+            context.report(outsideRule, {
+              path: `${run.path}/fontFamily`,
+              slide,
+              message: `Text uses ${JSON.stringify(family)}, which is not in the font scheme (${[.../* @__PURE__ */ new Set([slide.design.fonts.heading, slide.design.fonts.body])].join(" / ")}).`,
+              help: "Remove the fontFamily override to use the scheme font, or change the deck's font scheme so the family is part of it.",
+              fixes: [{ id: "remove-font-family", title: "Use the scheme font", kind: "patch", safe: false, patch: [{ op: "remove", path: `${run.path}/fontFamily` }] }]
+            });
+          }
+      }
+    }
+  }
+];
+var resolutionRule = rule(
+  "image-resolution",
+  "layout",
+  "warning",
+  "An image has too few pixels for the size it is shown at.",
+  "An image stretched beyond its pixel size looks blurry or blocky on a projector or a high-density screen.",
+  {
+    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 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 = [
+  {
+    info: resolutionRule,
+    run(context) {
+      const assets = context.document.assets;
+      const seen = /* @__PURE__ */ new Set();
+      const check = (path, value, box, cover, slide) => {
+        if (seen.has(path)) return;
+        seen.add(path);
+        const size = intrinsicImageSize(value, assets);
+        if (!size || size.svg || box.width <= 0 || box.height <= 0) return;
+        const scale = cover ? Math.max(box.width / size.width, box.height / size.height) : Math.min(box.width / size.width, box.height / size.height);
+        const ppi = 96 / scale;
+        if (ppi >= context.thresholds.minImagePpi) return;
+        context.report(resolutionRule, {
+          path,
+          slide,
+          message: `The ${size.width}x${size.height} px image is shown ${round2(box.width / 96)} x ${round2(box.height / 96)} in, about ${round2(ppi, 0)} pixels per inch; ${context.thresholds.minImagePpi} are needed to look sharp.`,
+          help: "Use a larger source image, or show it smaller. Re-exporting a small image at a higher size does not add detail.",
+          measured: { widthPx: size.width, heightPx: size.height, ppi: round2(ppi, 0), minimumPpi: context.thresholds.minImagePpi }
+        });
+      };
+      for (const slide of context.slides) {
+        const composition = slide.composition;
+        if (composition) {
+          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 !== "contain", background.path.startsWith("/slides/") ? slide : void 0);
+      }
+    }
+  }
+];
+var placeholderRule = rule(
+  "placeholder-text",
+  "content",
+  "warning",
+  "Placeholder text was left in the deck.",
+  '"Lorem ipsum", "Click to add title", "TBD" and bracketed prompts are scaffolding. Shipping them reads as unfinished work.',
+  { approximations: 'Case-insensitive patterns for lorem ipsum, template prompts ("Click to add...", "Your title here", "[Insert ...]", a bare "Title" or "Text"), and the markers TBD, TBC, TODO, FIXME and XXX in capitals. A deliberate use of the words is flagged too; disable the rule for that slide with ignorePaths.' }
+);
+var emptyTextRule = rule(
+  "empty-text",
+  "content",
+  "info",
+  "A text field is present but empty.",
+  "An empty title, text block or list item draws nothing, and leaves a hole in the outline and for assistive technology."
+);
+var emptySlideRule = rule(
+  "empty-slide",
+  "content",
+  "warning",
+  "A slide has no content at all.",
+  "A slide with no title, no content and no picture is almost always an accident of editing. (A deliberately blank slide can use the blank layout.)"
+);
+var unusedBeatRule = rule(
+  "unused-beat",
+  "content",
+  "info",
+  "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 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 = [
+  { pattern: /lorem ipsum|dolor sit amet|consectetur adipiscing/i, label: "lorem ipsum" },
+  { pattern: /\b(click|tap) to (add|edit|enter)\b|\b(add|enter|insert|type) (a |your |the )?(title|subtitle|text|heading|caption|content|name|description)( here)?\s*$/i, label: "a template prompt" },
+  { pattern: /\b(your|the) (title|subtitle|name|company|text|logo|content) (goes )?here\b|\b(title|subtitle|text|heading|content|description) (goes )?here\b/i, label: "a template prompt" },
+  { pattern: /\[(insert|add|your|enter|name|title|date|company|tbd|tbc|todo|placeholder)[^\]]{0,40}\]/i, label: "a bracketed prompt" },
+  { pattern: /\b(TBD|TBC|TODO|FIXME)\b|\bXXX+\b|\?\?\?/, label: "a TBD/TODO marker" },
+  { pattern: /^\s*(title|subtitle|heading|text|slide title|new slide|untitled( slide| presentation)?|presentation title|sample text|placeholder)\s*$/i, label: "a template default" }
+];
+var contentRules = [
+  {
+    info: placeholderRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          const text = plainText(tv.value);
+          const hit = PLACEHOLDERS.find(({ pattern }) => pattern.test(text));
+          if (!hit) continue;
+          context.report(placeholderRule, {
+            path: tv.path,
+            slide,
+            message: `Text looks like ${hit.label}: ${JSON.stringify(text.length > 60 ? `${text.slice(0, 57)}...` : text)}.`,
+            help: "Replace it with the real content, or delete the element.",
+            fixes: [{ id: "focus-text", title: "Edit the text", kind: "focus", safe: true, focus: { path: tv.path, field: "text" } }]
+          });
+        }
+    }
+  },
+  {
+    info: emptyTextRule,
+    run(context) {
+      for (const slide of context.slides)
+        for (const tv of slide.texts) {
+          if (["table", "table-header", "list-description"].includes(tv.role)) continue;
+          if (plainText(tv.value).trim() !== "") continue;
+          context.report(emptyTextRule, {
+            path: tv.path,
+            slide,
+            message: `The ${tv.role === "list" ? "list item" : tv.role === "body" ? "text" : tv.role} is empty.`,
+            help: "Write the text, or remove the field so the slide does not carry an empty element.",
+            fixes: [{ id: "focus-text", title: "Edit the text", kind: "focus", safe: true, focus: { path: tv.path, field: "text" } }]
+          });
+        }
+    }
+  },
+  {
+    info: unusedBeatRule,
+    run(context) {
+      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))
+        context.report(unusedBeatRule, {
+          path: "/narrative",
+          message: `Beat ${JSON.stringify(beat)} (${index + 1} of ${narrative.beats.length}) of narrative ${JSON.stringify(id)} has no slide that references it.`,
+          help: `Add a slide with "beat": ${JSON.stringify(beat)}, or list the beat on the slide that covers it. If the deck deliberately skips the beat, ignore this finding.`,
+          measured: { beat, position: index + 1, beats: narrative.beats.length }
+        });
+    }
+  },
+  {
+    info: emptySlideRule,
+    run(context) {
+      for (const slide of context.slides) {
+        if (slide.slide.layout === "blank") continue;
+        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 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." });
+      }
+    }
+  }
+];
+var layoutContentRules = [
+  ...layoutRules,
+  ...fontRules,
+  ...resolutionRules,
+  ...contentRules
+];
+
+// src/validation-types.ts
+var validationCategories = Object.freeze([
+  "format",
+  "references",
+  "policy",
+  "accessibility",
+  "layout",
+  "content"
+]);
+
+// src/validation-rules.ts
+var DEFAULT_VALIDATION_THRESHOLDS = Object.freeze({
+  contrastNormal: 4.5,
+  contrastLarge: 3,
+  minFontSizePt: 11,
+  minImagePpi: 96,
+  minSeriesColorDifference: 10
+});
+var SCHEMA = "spec/schemas/opf.schema.json (JSON Schema 2020-12) and the semantic rules of OPF";
+var formatRules = [
+  rule(
+    "json-syntax",
+    "format",
+    "error",
+    "The text is not strict JSON.",
+    "Every OPF tool reads JSON. A misplaced comma, quote, comment or trailing comma makes the file unreadable, and the range says where.",
+    { cost: "syntax", standard: "RFC 8259 (strict JSON: no comments, no trailing commas)", approximations: "Only text input is checked. A string is always read as JSON; a text that looks like YAML or Markdown gets a hint to use fromYaml or fromMarkdown first." }
+  ),
+  rule(
+    "duplicate-key",
+    "format",
+    "error",
+    "A JSON object repeats a key.",
+    "JSON.parse keeps only the last value of a repeated key, so the earlier one disappears without a trace. The check compares escaped and literal spellings of the same key.",
+    { cost: "syntax", standard: "RFC 8259 section 4 (names within an object should be unique)" }
+  ),
+  rule(
+    "schema",
+    "format",
+    "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." }
+  ),
+  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 }),
+  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("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 }),
+  rule("chart-mapping-unknown-column", "format", "error", "A chart mapping names a column the data does not have.", "The series cannot be built from a column that is not there.", { standard: SCHEMA }),
+  rule("number-format-invalid", "format", "error", "A number format cannot be read.", "A format code that no engine can parse is drawn as the plain number or fails to export.", { standard: "Excel number format codes, as far as OPF supports them" }),
+  rule("variable-invalid-value", "format", "error", "A variable value does not match its declared type.", "A number variable given text, or a date given a non-date, cannot be filled into the deck.", { standard: SCHEMA }),
+  rule("variable-unknown-builtin", "format", "error", "A token names a built-in variable that does not exist.", "The `deck.`, `speaker.` and `organization.` names (and `speakers`) are reserved for built-in variables; a name under them that is not a built-in can never be filled, so the token would show literally.", { standard: SCHEMA }),
+  rule("chart-highlight-unknown-name", "format", "error", "A chart highlight names a series or category the chart does not have.", "`chart.highlight` emphasises marks by name; a name that matches no series or category in the chart data highlights nothing, so the chart is not drawn as authored.", { standard: SCHEMA }),
+  rule("variable-format", "format", "error", "A variable cannot be formatted.", "A number or date format that does not apply to the value leaves the token unreadable.", { standard: SCHEMA }),
+  rule(
+    "variable-unfilled",
+    "format",
+    "error",
+    "A required template variable has no value.",
+    "A variable a deck declares as required, with no value, is template scaffolding: `{{name}}` tokens show up literally and colour variables fall back to a default. A normal deck must be filled, so this is an error and the deck is not valid; a template (`template: true`) is incomplete on purpose, so it is a warning.",
+    {
+      approximations: "Required variables are those the variable machinery reports as unfilled for the document (declared, no value, not `required: false`, not given by the `values` option). For a document that declares no content variables, `{{id}}` / `{{id|format}}` tokens (`{{` escapes) left in any string outside `variables`, `extensions`, `catalogs` and `assets` are reported as warnings. `var:` colour references with no declaration are reported as `opf/variable-reference-unknown`. Fill a template with `opf fill` or `resolveVariables` to clear the findings."
+    }
+  ),
+  rule("run-color-unrecognized", "format", "warning", "A text run colour is none of the documented forms.", "Run colours are open strings so imported decks stay valid, but a value that is not a hex colour, a colour-scheme name or a `var:` reference falls back to the theme colour.", { standard: SCHEMA }),
+  rule("numbering-start-ignored", "format", "warning", "A list entry sets `start` where nothing is numbered.", "A start value only restarts an auto-number; without `numbering` on the payload it has no effect.", { standard: SCHEMA })
+];
+var referenceRules = [
+  rule(
+    "asset-reference",
+    "references",
+    "error",
+    "An `asset:` reference names an asset that is not in the registry.",
+    "An image, logo or video that points at a missing asset cannot be drawn or exported. The check reads the document's own registry only; no file or URL is fetched.",
+    { standard: SCHEMA }
+  ),
+  rule("asset-cycle", "references", "error", "Asset references form a cycle.", "An asset whose source points back at itself never resolves to a file.", { standard: SCHEMA }),
+  rule(
+    "catalog-record",
+    "references",
+    "error",
+    "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(
+    "unresolved-reference",
+    "references",
+    "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." }
+  ),
+  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 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 }),
+  rule("variable-unused", "references", "warning", "A variable is declared but never used.", "A declaration nothing refers to has no effect.", { standard: SCHEMA }),
+  rule("variable-reference-unknown", "references", "warning", "A `var:` colour names a variable that is not declared.", "An undeclared colour variable falls back to a default colour.", { standard: SCHEMA })
+];
+var policyRules = [
+  rule(
+    "contract",
+    "policy",
+    "error",
+    "A field is outside the values a host policy allows.",
+    "A host that needs brand layouts, fonts or other fixed choices states them as contracts. The default severity is error; a contract can set its own. Document metadata never installs policy.",
+    { approximations: "Only the `contracts` option supplies policy, and it checks existing fields: a contract does not require an omitted field or insert a default." }
+  )
+];
+var dataRules = [
+  rule("chart-option-adapted", "layout", "warning", "A chart option cannot be shown by the chart type.", "An axis title, legend or data label option the chart type does not support is adapted by every engine, so the chart is not drawn exactly as authored.", { standard: SCHEMA }),
+  rule(
+    "chart-value-not-numeric",
+    "content",
+    "warning",
+    "A chart value is text, not a number.",
+    'A chart plots numbers. A text cell such as "12%" is plotted as a gap. When every text value of a column is written in one display style the finding carries the fix that stores the numbers and gives the column the matching format.',
+    { standard: SCHEMA }
+  ),
+  rule("chart-mapping-adapted", "content", "warning", "A chart mapping entry is ignored.", "A mapping that names a column the chart type cannot use is left out of the chart.", { standard: SCHEMA }),
+  rule("chart-highlight-adapted", "content", "warning", "A chart highlight is adapted by the chart type.", "A highlight the chart type cannot show as authored (a category highlight on a chart without categories, for example) is adapted by every engine, so the emphasis is not exactly what was written.", { standard: SCHEMA }),
+  rule("code-highlight-out-of-range", "content", "warning", "A code highlight marks a line the code does not have.", "Marked lines count from 1 by line break in code.source; an entry past the last line marks nothing.", { standard: SCHEMA }),
+  rule("code-highlight-range-reversed", "content", "warning", "A code highlight range ends before it starts.", "A range written end before start marks nothing; write the smaller line number first.", { standard: SCHEMA }),
+  rule("variable-builtin-missing", "content", "warning", "A built-in variable has no value in this document.", "A `{{deck.*}}`, `{{speaker.*}}` or `{{organization.*}}` token whose field the document does not set resolves to nothing, so the text shows a gap.", { standard: SCHEMA }),
+  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 ruleImplementations = implementations;
+var infos = [
+  ...formatRules,
+  ...referenceRules,
+  ...policyRules,
+  ...dataRules,
+  ...implementations.flatMap((entry) => [entry.info, ...entry.also ?? []])
+];
+var validationRules = Object.freeze(
+  infos.map((info, index) => ({ info, index })).sort((a, b) => validationCategories.indexOf(a.info.category) - validationCategories.indexOf(b.info.category) || a.index - b.index).map(({ info }) => Object.freeze({ ...info }))
+);
+var byName = /* @__PURE__ */ new Map();
+for (const info of validationRules) {
+  if (byName.has(info.id) || byName.has(info.name)) throw new Error(`Duplicate validation rule ${info.id}.`);
+  byName.set(info.id, info);
+  byName.set(info.name, info);
+}
+function findValidationRule(name) {
+  return byName.get(name);
+}
+function ruleInfo(id) {
+  const found = byName.get(id);
+  if (!found) throw new Error(`Validation rule ${JSON.stringify(id)} is not registered.`);
+  return found;
+}
+
+// src/check-document.ts
+var own = (value, key) => Object.hasOwn(value, key);
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var primitive = (value) => value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+var pointer3 = (parts2) => parts2.length ? "/" + parts2.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/") : "";
+function parts(path) {
+  if (path === "") return [];
+  if (!path.startsWith("/") || /~(?![01])/.test(path))
+    throw new TypeError(`Invalid contract JSON Pointer: ${path}`);
+  return path.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function at(value, path) {
+  return parts(path).reduce(
+    (current, key) => object(current) || Array.isArray(current) ? own(current, key) ? current[key] : void 0 : void 0,
+    value
+  );
+}
+function checkDocumentOptions(options) {
+  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 ?? []) {
+    if (!object(contract) || Object.keys(contract).some(
+      (key) => ![
+        "path",
+        "allowedValues",
+        "severity",
+        "message",
+        "documentation"
+      ].includes(key)
+    ) || typeof contract.path !== "string" || !Array.isArray(contract.allowedValues) || !contract.allowedValues.every(primitive) || contract.severity !== void 0 && (typeof contract.severity !== "string" || !["error", "warning", "info"].includes(contract.severity)) || contract.message !== void 0 && typeof contract.message !== "string" || contract.documentation !== void 0 && typeof contract.documentation !== "string")
+      throw new TypeError(
+        "Invalid contract: provide a path and primitive allowedValues, with optional severity, message and documentation."
+      );
+    parts(contract.path);
+  }
+}
+function finding(ruleId, data) {
+  const info = ruleInfo(ruleId);
+  const { severity, scope, ...rest } = data;
+  return { ruleId, severity: severity ?? info.severity, category: info.category, scope: scope ?? "document", ...rest };
+}
+var issueRuleId = (issue2) => typeof issue2.params.code === "string" && issue2.keyword === "opf" ? `opf/${issue2.params.code}` : "opf/schema";
+function issueFinding(issue2, ruleId = issueRuleId(issue2), schemaName = "presentation", prefix = "", scope = "document", severity) {
+  const path = prefix + (issue2.path === "/" ? "" : issue2.path) + (issue2.keyword === "additionalProperties" && typeof issue2.params.additionalProperty === "string" ? pointer3([issue2.params.additionalProperty]) : ""), entry = schemaEntries.find((entry2) => entry2.name === schemaName);
+  if (!entry) throw new TypeError(`Unknown schema ${schemaName}`);
+  const precise = validationDefinition(issue2);
+  const definition = precise?.uri ?? (issue2.keyword === "opf" ? "packages/javascript/src/schema-check.ts" : issue2.schemaPath.startsWith("#") ? entry.schema.$id + issue2.schemaPath : issue2.schemaPath);
+  const lookup = [
+    "opf",
+    "schema",
+    precise?.schemaName ?? schemaName,
+    precise?.pointer ?? (issue2.keyword !== "opf" && issue2.schemaPath.startsWith("#") ? issue2.schemaPath.slice(1) : "")
+  ];
+  let help = "Inspect this schema constraint and preserve unrelated content. Errors inside oneOf/anyOf branches may describe alternatives; retain the intended form.";
+  if (issue2.keyword === "required")
+    help = `Add the required ${JSON.stringify(issue2.params.missingProperty)} field in this object, using the intended schema form.`;
+  else if (issue2.keyword === "additionalProperties")
+    help = `Review ${JSON.stringify(issue2.params.additionalProperty)} against this object's schema. Preserve custom metadata in document.extensions where appropriate; do not delete authored content to clear this error.`;
+  else if (issue2.keyword === "enum")
+    help = "Choose one of this schema branch\u2019s allowed values; inspect the other alternatives if the field uses another form.";
+  else if (issue2.keyword === "opf")
+    help = "Resolve the reported structural conflict while preserving every content field. Preview the result after editing.";
+  const allowed = Array.isArray(issue2.params.allowedValues) ? issue2.params.allowedValues.filter(primitive) : [];
+  return finding(ruleId, {
+    ...severity ? { severity } : {},
+    path,
+    scope,
+    message: issue2.message,
+    help,
+    definition,
+    lookup,
+    validation: issue2,
+    ...allowed.length ? {
+      suggestions: allowed.map((value) => ({
+        value,
+        label: String(value),
+        origin: "schema",
+        definition
+      }))
+    } : {}
+  });
+}
+function resolve(cursor, seen = /* @__PURE__ */ new Set()) {
+  const ref = cursor.schema.$ref;
+  if (typeof ref !== "string") return cursor;
+  const id = String(cursor.root.$id ?? "") + ref;
+  if (seen.has(id)) return { ...cursor, schema: {} };
+  seen.add(id);
+  const [base, fragment = ""] = ref.split("#"), root = base ? schemaEntries.find((entry) => entry.schema.$id === base)?.schema : cursor.root;
+  if (!root) return { ...cursor, schema: {} };
+  const target = at(root, fragment);
+  if (!object(target)) return { ...cursor, schema: {} };
+  const resolved = resolve(
+    { schema: target, root, path: fragment },
+    seen
+  );
+  const { $ref, ...rest } = cursor.schema;
+  return { ...resolved, schema: { ...resolved.schema, ...rest } };
+}
+function score(schema, value) {
+  const type = schema.type;
+  if (typeof type === "string" && (type === "array" ? !Array.isArray(value) : type === "object" ? !object(value) : type === "null" ? value !== null : type === "integer" ? !Number.isInteger(value) : typeof value !== type))
+    return -1e4;
+  if (own(schema, "const")) return schema.const === value ? 100 : -1e4;
+  let result = 1;
+  if (object(value) && object(schema.properties)) {
+    for (const [key, child] of Object.entries(schema.properties))
+      if (own(value, key) && object(child))
+        result += own(child, "const") ? child.const === value[key] ? 100 : -1e3 : 1;
+  }
+  if (Array.isArray(schema.required)) {
+    for (const key of schema.required)
+      if (typeof key === "string" && (!object(value) || !own(value, key)))
+        result -= 2;
+  }
+  return result;
+}
+function active(cursor, value) {
+  const resolved = resolve(cursor), alternatives = resolved.schema.oneOf ?? resolved.schema.anyOf;
+  if (!Array.isArray(alternatives)) return resolved;
+  const keyword = resolved.schema.oneOf ? "oneOf" : "anyOf";
+  const candidates = alternatives.filter(object).map(
+    (schema, index) => active(
+      {
+        schema,
+        root: resolved.root,
+        path: `${resolved.path}/${keyword}/${index}`
+      },
+      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 childCursor(cursors, key) {
+  for (const keyword of [
+    "properties",
+    "patternProperties",
+    "additionalProperties"
+  ]) {
+    for (const cursor of cursors) {
+      const declarations = cursor.schema[keyword];
+      if (!object(declarations)) continue;
+      const name = keyword === "properties" ? key : keyword === "patternProperties" ? Object.keys(declarations).find(
+        (pattern) => new RegExp(pattern).test(key)
+      ) : void 0;
+      const schema = keyword === "additionalProperties" ? declarations : name === void 0 ? void 0 : declarations[name];
+      if (object(schema))
+        return {
+          schema,
+          root: cursor.root,
+          path: `${cursor.path}/${keyword}${name === void 0 ? "" : pointer3([name])}`
+        };
+    }
+  }
+  return void 0;
+}
+function fields(document) {
+  const result = [], stack = [
+    {
+      value: document,
+      path: [],
+      cursor: {
+        schema: schemas.presentation,
+        root: schemas.presentation,
+        path: ""
+      },
+      ancestors: []
+    }
+  ];
+  while (stack.length) {
+    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);
+    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:")
+      )
+    );
+    result.push({
+      path: pointer3(entry.path),
+      value: entry.value,
+      cursor: resolved,
+      assetReference
+    });
+    const ancestors = [...entry.ancestors, entry.value];
+    const cursors = [selected, ...selected.baseSchemas ?? [], resolved];
+    const arrayCursor = cursors.find((cursor) => object(cursor.schema.items));
+    if (Array.isArray(entry.value) && arrayCursor)
+      entry.value.forEach((value, index) => {
+        stack.push({
+          value,
+          path: [...entry.path, index],
+          cursor: {
+            schema: arrayCursor.schema.items,
+            root: arrayCursor.root,
+            path: `${arrayCursor.path}/items`
+          },
+          ancestors
+        });
+      });
+    else if (object(entry.value))
+      for (const [key, value] of Object.entries(entry.value)) {
+        if (entry.path.length === 0 && key === "catalogs") continue;
+        const cursor = childCursor(cursors, key);
+        if (!cursor) continue;
+        stack.push({
+          value,
+          path: [...entry.path, key],
+          cursor,
+          ancestors
+        });
+      }
+  }
+  return result;
+}
+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]
+          })
+        );
+      }
+  }
+  return invalid;
+}
+function distance(a, b) {
+  a = a.slice(0, 128);
+  b = b.slice(0, 128);
+  let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 0; i < a.length; i++) {
+    const next = [i + 1];
+    for (let j = 0; j < b.length; j++)
+      next.push(
+        Math.min(
+          (next[j] ?? Infinity) + 1,
+          (row[j + 1] ?? Infinity) + 1,
+          (row[j] ?? Infinity) + (a[i] === b[j] ? 0 : 1)
+        )
+      );
+    row = next;
+  }
+  return row[b.length] ?? Math.max(a.length, b.length);
+}
+function chartNumberFixPaths(document) {
+  const byCell = /* @__PURE__ */ new Map();
+  if (!isRecord(document) || !Array.isArray(document.slides)) return byCell;
+  const payload = (node, path) => {
+    if (isRecord(node.chart))
+      for (const [cell, fix] of chartNumberFixesByCell(node.chart, document, { path: pathFor(path, "chart") })) byCell.set(cell, fix);
+  };
+  document.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    payload(slide, `/slides/${index}`);
+    visitContentPayloads(slide, `/slides/${index}`, payload);
+  });
+  return byCell;
+}
+var HELP = {
+  "chart-value-not-numeric": 'Write chart values as numbers (or strict decimal strings such as "12.5" or "1e6"); put currency, percent and units in the column format ({ "name": "Revenue", "format": "$#,##0" }). The value is plotted as a gap.',
+  "chart-mapping-adapted": "The mapping entry is ignored. Remove it, or name a different column.",
+  "chart-highlight-adapted": "The highlight is adapted by every engine. Name a series or category the chart type can emphasise, or remove the entry.",
+  "slide-theme-dimensions": "A PPTX has one slide size. Set design.dimensions on the deck, or give every slide the same theme dimensions.",
+  "code-highlight-out-of-range": "Marked lines count from 1 by line break in code.source. The entry marks nothing past the last line; change it to a line the code has, or remove it.",
+  "code-highlight-range-reversed": "Write the range with the smaller line number first, or remove it. A reversed range marks nothing.",
+  "chart-option-adapted": "Remove the option, or choose a chart type that can show it; every engine draws the adapted result.",
+  "variable-unknown": "Declare the variable in the top-level variables map, or write '\\{{' for literal braces.",
+  "variable-unknown-value": "Remove the supplied value, or declare the variable it belongs to.",
+  "variable-unused": "Reference the variable as {{id}} or var:id where it belongs, or remove its declaration.",
+  "variable-reference-unknown": "Declare the variable in the top-level variables map, or use another colour.",
+  "run-color-unrecognized": "Use a #RRGGBB hex colour, a colour-scheme name or a var: reference to a declared colour variable.",
+  "numbering-start-ignored": "Add a 'numbering' field to the payload, or remove 'start'."
+};
+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));
+  }
+  let numberFixes;
+  for (const issue2 of engine.warnings) {
+    const code = issue2.params.code;
+    if (typeof code !== "string") continue;
+    const ruleId = `opf/${code}`;
+    if (!enabled(ruleId)) continue;
+    if (code === "chart-value-not-numeric") {
+      numberFixes ??= chartNumberFixPaths(document);
+      const fix = numberFixes.get(issue2.path);
+      if (fix) {
+        findings.push({
+          ...issueFinding(issue2, ruleId, "presentation", "", "document", "warning"),
+          help: `Every text value of column ${JSON.stringify(fix.name)} is written in one display style. Store the numbers and give the column the format ${JSON.stringify(fix.format)}, which shows the same text: apply fixes[0] (core suggestChartNumberFix). Until then the value is plotted as a gap.`,
+          fixes: [{ id: "store-chart-numbers", title: `Store ${JSON.stringify(fix.name)} as numbers with the format ${JSON.stringify(fix.format)}`, kind: "patch", safe: false, patch: fix.patches }]
+        });
+        continue;
+      }
+    }
+    const found = issueFinding(issue2, ruleId, "presentation", "", "document", "warning");
+    const help = HELP[code];
+    if (help) found.help = help;
+    findings.push(found);
+  }
+  return findings;
+}
+var VARIABLE_TOKEN = /\\\{\{|\{\{\s*([a-z][a-z0-9-]*)\s*(?:\|[^{}]*)?\}\}/g;
+function variableFindings(document, engine, schemaValid) {
+  const findings = [];
+  if (engine.template === true) {
+    for (const id of engine.unfilledVariables ?? [])
+      findings.push(
+        finding("opf/variable-unfilled", {
+          path: pointer3(["variables", id]),
+          message: `Template variable ${JSON.stringify(id)} has no value.`,
+          help: "This document is a template: fill it with its values (opf fill, or resolveVariables) before using it as a deck.",
+          severity: "warning"
+        })
+      );
+    return findings;
+  }
+  for (const issue2 of engine.unfilled)
+    findings.push(
+      finding("opf/variable-unfilled", {
+        path: issue2.path,
+        message: issue2.message,
+        help: 'Give the variable a value, fill the deck before use (opf fill, or resolveVariables), or mark the document as a template ("template": true).'
+      })
+    );
+  if (engine.template !== void 0 || !schemaValid) return findings;
+  const walk = (value, path, depth) => {
+    if (depth > 64) return;
+    if (typeof value === "string") {
+      if (value.startsWith("data:") || !value.includes("{{")) return;
+      for (const match of value.matchAll(VARIABLE_TOKEN))
+        if (match[1])
+          findings.push(
+            finding("opf/variable-unfilled", {
+              path: pointer3(path),
+              message: `Template variable ${JSON.stringify(match[0])} is still in the text.`,
+              help: "Declare the variable and fill it, or replace the token with the real value.",
+              severity: "warning"
+            })
+          );
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((entry, index) => {
+        walk(entry, [...path, String(index)], depth + 1);
+      });
+      return;
+    }
+    if (value && typeof value === "object")
+      for (const [key, entry] of Object.entries(value)) {
+        if (path.length === 0 && ["variables", "extensions", "catalogs", "assets"].includes(key)) continue;
+        walk(entry, [...path, key], depth + 1);
+      }
+  };
+  walk(document, [], 0);
+  return findings;
+}
+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 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) {
+      const id = field.value.slice(6);
+      if (!own(assetValues, id))
+        findings.push(
+          finding("opf/asset-reference", {
+            path: field.path,
+            message: `Asset ${JSON.stringify(id)} is missing from the document registry.`,
+            help: "Supply the intended asset in document.assets or choose the correct existing asset ID. External files and URLs are not fetched or verified.",
+            definition: schemas.presentation.$id + "#/$defs/Assets",
+            lookup: ["opf", "schema", "presentation", "/$defs/Assets"],
+            suggestions: Object.keys(assetValues).sort(
+              (a, b) => distance(id, a) - distance(id, b) || (a < b ? -1 : a > b ? 1 : 0)
+            ).slice(0, 5).map((id2) => ({
+              value: `asset:${id2}`,
+              label: id2,
+              origin: "document",
+              definition: `document#${pointer3(["assets", id2])}`
+            }))
+          })
+        );
+    }
+  }
+  const reportedCycles = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(assetValues)) {
+    const chain = [], seenIds = /* @__PURE__ */ new Set();
+    let current = id;
+    while (current !== void 0 && own(assetValues, current)) {
+      if (seenIds.has(current)) {
+        const cycle = chain.slice(chain.indexOf(current));
+        if (!cycle.some((id2) => reportedCycles.has(id2))) {
+          for (const id2 of cycle) reportedCycles.add(id2);
+          findings.push(
+            finding("opf/asset-cycle", {
+              path: pointer3(["assets", current]),
+              message: `Asset references form a cycle: ${[...cycle, current].map((id2) => JSON.stringify(id2)).join(" \u2192 ")}.`,
+              help: "Replace one link with the intended concrete source. Preserve the original asset metadata; no files or URLs were fetched."
+            })
+          );
+        }
+        break;
+      }
+      seenIds.add(current);
+      chain.push(current);
+      const value = assetValues[current], source = object(value) ? value.src : value;
+      current = typeof source === "string" && source.startsWith("asset:") ? source.slice(6) : void 0;
+    }
+  }
+  findings.push(...narrativeFindings(document, catalogs));
+  for (const issue2 of unusedReferenceWarnings(document))
+    findings.push(
+      finding("opf/unused-reference", {
+        path: issue2.path,
+        message: issue2.message,
+        help: "Cite the reference from a text, bullet or list item run ({ text, cite: id }) so it is listed in that slide's footnote area, or remove the entry. Nothing is drawn for an uncited reference.",
+        definition: schemas.presentation.$id + "#/$defs/Reference",
+        lookup: ["opf", "schema", "presentation", "/$defs/Reference"],
+        validation: issue2
+      })
+    );
+  for (const id of unusedDatasets(document))
+    findings.push(
+      finding("opf/unused-dataset", {
+        path: `/datasets/${id.replaceAll("~", "~0").replaceAll("/", "~1")}`,
+        message: `Dataset ${JSON.stringify(id)} is never referenced; reference it from a chart ("data": { "dataset": ${JSON.stringify(id)} }) or a table ({ "dataset": ${JSON.stringify(id)} }), or remove it.`,
+        help: "Reference the dataset from chart.data or a table so it is drawn, or remove the entry. Nothing is drawn for an unreferenced dataset.",
+        definition: schemas.presentation.$id + "#/$defs/Dataset",
+        lookup: ["opf", "schema", "presentation", "/$defs/Dataset"]
+      })
+    );
+  return findings;
+}
+function narrativeFindings(document, options) {
+  const findings = [];
+  if (!object(document)) return findings;
+  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, 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 (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)
+        })
+      );
+    const outside = durationOutsideNarrative(document, narrative);
+    if (outside)
+      findings.push(
+        finding("opf/duration-outside-narrative", {
+          path: "/duration",
+          message: `The target duration of ${outside.duration} minutes is outside the ${describeDurationRange(outside.range)} narrative ${JSON.stringify(id)} suits.`,
+          help: "Change the target duration, choose a narrative that suits it, or widen the range of an inline narrative record. The range describes the narrative, so nothing is drawn or exported differently.",
+          definition: schemas.presentation.$id + "#/properties/duration",
+          lookup: ["opf", "catalog", "narratives"]
+        })
+      );
+  }
+  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: 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) {
+  const findings = [];
+  for (const [index, contract] of contracts.entries()) {
+    const pattern = parts(contract.path), stack = [{ value: document, path: [], depth: 0 }];
+    while (stack.length) {
+      const entry = stack.pop();
+      if (!entry) break;
+      if (entry.depth === pattern.length) {
+        if (contract.allowedValues.some((value) => Object.is(value, entry.value)))
+          continue;
+        const path = pointer3(entry.path), definition = contract.documentation ?? `context#/contracts/${index}`, values = {
+          path,
+          value: JSON.stringify(entry.value),
+          allowed: contract.allowedValues.map((value) => JSON.stringify(value)).join(", "),
+          file: definition
+        };
+        const message = (contract.message ?? "This value is outside the allowed values for {{path}}.").replace(
+          /\{\{(path|value|allowed|file)\}\}/g,
+          (_, key) => values[key] ?? ""
+        );
+        findings.push(
+          finding("opf/contract", {
+            severity: contract.severity ?? "error",
+            path,
+            message,
+            help: `Use one of the configured values: ${values.allowed}. This is an explicit host policy; no source was changed.`,
+            definition,
+            suggestions: contract.allowedValues.map((value) => ({
+              value,
+              label: String(value),
+              origin: "contract",
+              definition
+            }))
+          })
+        );
+      } else if (object(entry.value) || Array.isArray(entry.value)) {
+        const key = pattern[entry.depth];
+        for (const [name, value] of Object.entries(entry.value))
+          if (key === "*" || key === name)
+            stack.push({
+              value,
+              path: [...entry.path, name],
+              depth: entry.depth + 1
+            });
+      }
+    }
+  }
+  return findings;
+}
+var YAML_START = /^[A-Za-z_][\w.-]*\s*:(?:\s|$)/;
+function hint(source) {
+  const text = source.replace(/^\uFEFF/, "").trimStart();
+  if (text.startsWith("{") || text.startsWith("[") || text === "") return "";
+  if (text.startsWith("---") || !text.startsWith("#") && YAML_START.test(text))
+    return " This looks like YAML: read it with fromYaml, then validate the presentation it returns.";
+  if (text.startsWith("#")) return " This looks like Markdown: read it with fromMarkdown, then validate the presentation it returns.";
+  return "";
+}
+function parseSource(source) {
+  const errors = [], tree = parseTree(
+    source.startsWith("\uFEFF") ? " " + source.slice(1) : source,
+    errors,
+    {
+      disallowComments: true,
+      allowTrailingComma: false,
+      allowEmptyContent: false
+    }
+  );
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\r") {
+      if (source[i + 1] === "\n") i++;
+      lineStarts.push(i + 1);
+    } else if (source[i] === "\n") lineStarts.push(i + 1);
+  }
+  const location = (offset, length) => {
+    let lo = 0, hi = lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((lineStarts[mid] ?? 0) <= offset) lo = mid;
+      else hi = mid;
+    }
+    return {
+      offset,
+      length,
+      line: lo + 1,
+      column: offset - (lineStarts[lo] ?? 0) + 1
+    };
+  };
+  if (errors.length || !tree) {
+    const note = hint(source);
+    return {
+      syntax: errors.map(
+        (error, index) => finding("opf/json-syntax", {
+          path: "",
+          message: printParseErrorCode(error.error),
+          help: `Repair the JSON syntax at this source range. No content or whitespace has been rewritten.${index === 0 ? note : ""}`,
+          location: location(error.offset, error.length)
+        })
+      ),
+      duplicates: [],
+      locate: () => void 0
+    };
+  }
+  const duplicates = [], stack = [tree];
+  while (stack.length) {
+    const node = stack.pop();
+    if (!node) break;
+    if (node.type === "object") {
+      const keys = /* @__PURE__ */ new Set();
+      for (const property of node.children ?? []) {
+        const key = property.children?.[0];
+        if (!key) continue;
+        if (keys.has(key.value))
+          duplicates.push(
+            finding("opf/duplicate-key", {
+              path: pointer3(getNodePath(key)),
+              message: `Duplicate JSON property ${JSON.stringify(key.value)}.`,
+              help: "Resolve the duplicate explicitly, preserving the intended content from both occurrences. JSON.parse would otherwise hide an earlier value.",
+              location: location(key.offset, key.length)
+            })
+          );
+        keys.add(key.value);
+      }
+    }
+    stack.push(...node.children ?? []);
+  }
+  return {
+    value: JSON.parse(source.replace(/^\uFEFF/, "")),
+    syntax: [],
+    duplicates,
+    locate(path) {
+      try {
+        let node = tree;
+        const found = [];
+        const wanted = parts(path);
+        for (const part of wanted) {
+          const next = node?.type === "array" ? node.children?.[Number(part)] : node?.type === "object" ? node.children?.find(
+            (property) => property.children?.[0]?.value === part
+          )?.children?.[1] : void 0;
+          if (!next) break;
+          node = next;
+          found.push(next);
+        }
+        const target = found.length === wanted.length ? node : found[found.length - 1] ?? tree;
+        return target ? location(target.offset, target.length) : void 0;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/slide-context.ts
+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 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) };
+  let layout;
+  let layoutProvenance;
+  if (typeof slide.layout === "string") {
+    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 } : {},
+    presentation,
+    slideIndex: index,
+    slideNumber: options.slideNumber ?? index + 1,
+    slideCount: options.slideCount ?? slides.length,
+    fontFamilies: resolveFontFamilies(fontScheme),
+    darkBackground: resolveColorRoles(colorScheme, { background: decisionColor(design.background ?? theme.background, colorScheme, rec2(deck.variables)) }).dark,
+    ...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, fontSchemePath: records.fontSchemePath, ...layout ? { layout } : {}, provenance: { ...layoutProvenance ? { layout: layoutProvenance } : {}, ...records.provenance } } };
+}
+
+// src/rule-slides.ts
+var measurementFor = (options, index) => {
+  const measurement = options.fonts?.textMeasurement;
+  return typeof measurement === "function" ? measurement(index) : measurement;
+};
+var lazy = (compute) => {
+  let done = false;
+  let value;
+  return () => {
+    if (!done) {
+      value = compute();
+      done = true;
+    }
+    return value;
+  };
+};
+function relax(value) {
+  const copy = JSON.parse(JSON.stringify(value));
+  const walk = (node) => {
+    if (Array.isArray(node)) return node.forEach(walk);
+    if (node && typeof node === "object") {
+      const object2 = node;
+      if (object2.overflow === "error") object2.overflow = "warn";
+      for (const child of Object.values(object2)) walk(child);
+    }
+  };
+  walk(copy);
+  return copy;
+}
+function buildSlides(document, options) {
+  const slides = Array.isArray(document.slides) ? document.slides : [];
+  return slides.map((slide, index) => {
+    const path = pointer2("slides", index);
+    const measurement = lazy(() => measurementFor(options, index));
+    const resolved = lazy(() => {
+      const textMeasurement = measurement();
+      return resolveSlideContext(document, index, { catalogs: options.catalogs, ...textMeasurement ? { fonts: { textMeasurement } } : {}, date: "2000-01-01" });
+    });
+    const design = lazy(() => resolveDesign(document, index, resolved()));
+    const layout = lazy(() => resolved().options.layout);
+    const composed = lazy(() => {
+      const result = { layoutDiagnostics: [] };
+      const compose = (input, withLayout) => composeSlide(input, { ...resolved().options, layout: withLayout });
+      try {
+        result.composition = compose(slide, layout());
+        result.layoutDiagnostics.push(...result.composition.diagnostics.map((diagnostic) => ({ diagnostic, strict: false })));
+      } catch (error) {
+        if (error instanceof OPFCompositionError) {
+          result.layoutDiagnostics.push(...error.diagnostics.map((diagnostic) => ({ diagnostic, strict: true })));
+          try {
+            const relaxedLayout = layout();
+            result.composition = compose(relax(slide), relaxedLayout ? relax(relaxedLayout) : void 0);
+          } catch (second) {
+            result.layoutError = second instanceof Error ? second.message : String(second);
+          }
+        } else result.layoutError = error instanceof Error ? error.message : String(error);
+      }
+      return result;
+    });
+    const payloads = lazy(() => slidePayloads(slide, path));
+    const texts = lazy(() => textValues(slide, path));
+    const rtl = lazy(() => {
+      try {
+        return resolveScriptFonts(document, { slideIndex: index }).rtl === true;
+      } catch {
+        return false;
+      }
+    });
+    const context = { index, slide, path, ...typeof slide.id === "string" ? { id: slide.id } : {} };
+    return Object.defineProperties(context, {
+      design: { get: design, enumerable: true },
+      layout: { get: layout, enumerable: true },
+      composition: { get: () => composed().composition, enumerable: true },
+      layoutDiagnostics: { get: () => composed().layoutDiagnostics, enumerable: true },
+      layoutError: { get: () => composed().layoutError, enumerable: true },
+      measurement: { get: measurement, enumerable: true },
+      payloads: { get: payloads, enumerable: true },
+      texts: { get: texts, enumerable: true },
+      rtl: { get: rtl, enumerable: true }
+    });
+  });
+}
+
+// src/validator.ts
+var SEVERITIES = ["error", "warning", "info"];
+var OPTION_KEYS = ["only", "ignore", "severity", "ignorePaths", "catalogs", "contracts", "thresholds", "fonts", "chartPalette", "template", "values"];
+var DOCS = "https://github.com/OpenPresentation/opf/blob/main/docs/validate.md";
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var OPFValidationError = class extends Error {
+  /** The full report that failed. */
+  report;
+  /** The error-severity findings of the report. */
+  findings;
+  constructor(report) {
+    const errors = report.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.findings = errors;
+  }
+};
+function ruleFor(name, what) {
+  if (validationCategories.includes(name)) return name;
+  const found = findValidationRule(name);
+  if (!found) throw new TypeError(`Unknown validation rule or category ${JSON.stringify(name)} in ${what}. Categories: ${validationCategories.join(", ")}. Rules: ${validationRules.map((info) => info.id).join(", ")}.`);
+  return found;
+}
+function names(list, what) {
+  if (list === void 0) return void 0;
+  if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) throw new TypeError(`Validate ${what} must be an array of rule ids or category names.`);
+  const result = { rules: /* @__PURE__ */ new Set(), categories: /* @__PURE__ */ new Set() };
+  for (const name of list) {
+    const found = ruleFor(name, what);
+    if (typeof found === "string") result.categories.add(found);
+    else result.rules.add(found.id);
+  }
+  return result;
+}
+function resolveOptions(options) {
+  if (!isObject(options)) throw new TypeError("Validate options must be an object.");
+  for (const key of Object.keys(options)) if (!OPTION_KEYS.includes(key)) throw new TypeError(`Unknown validate option ${JSON.stringify(key)}. Options: ${OPTION_KEYS.join(", ")}.`);
+  checkDocumentOptions(options);
+  const only = names(options.only, "only");
+  const ignore = names(options.ignore, "ignore");
+  const severity = /* @__PURE__ */ new Map();
+  if (options.severity !== void 0) {
+    if (!isObject(options.severity)) throw new TypeError('Validate severity must map rule ids or category names to a severity or "off".');
+    for (const [name, value] of Object.entries(options.severity)) {
+      if (typeof value !== "string" || value !== "off" && !SEVERITIES.includes(value)) throw new TypeError(`Validate severity for ${JSON.stringify(name)} must be error, warning, info or off.`);
+      const found = ruleFor(name, "severity");
+      severity.set(typeof found === "string" ? found : found.id, value);
+    }
+  }
+  const ignorePaths = [];
+  if (options.ignorePaths !== void 0) {
+    if (!Array.isArray(options.ignorePaths)) throw new TypeError("Validate ignorePaths must be an array of {rule, path}.");
+    for (const entry of options.ignorePaths) {
+      if (!isObject(entry) || typeof entry.rule !== "string" || typeof entry.path !== "string" || entry.path !== "" && !entry.path.startsWith("/"))
+        throw new TypeError('Each validate ignorePaths entry needs a rule id, category name or "*", and a JSON Pointer path.');
+      const found = entry.rule === "*" ? "*" : ruleFor(entry.rule, "ignorePaths");
+      ignorePaths.push({
+        match: (info) => found === "*" || (typeof found === "string" ? found === info.category : found.id === info.id),
+        path: splitPointer(entry.path)
+      });
+    }
+  }
+  const thresholds = { ...DEFAULT_VALIDATION_THRESHOLDS };
+  if (options.thresholds !== void 0) {
+    if (!isObject(options.thresholds)) throw new TypeError("Validate thresholds must be an object.");
+    for (const [key, value] of Object.entries(options.thresholds)) {
+      if (!(key in DEFAULT_VALIDATION_THRESHOLDS)) throw new TypeError(`Unknown validate threshold ${JSON.stringify(key)}. Thresholds: ${Object.keys(DEFAULT_VALIDATION_THRESHOLDS).join(", ")}.`);
+      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new TypeError(`Validate threshold ${key} must be a positive number.`);
+      thresholds[key] = value;
+    }
+  }
+  if (options.fonts !== void 0) {
+    if (!isObject(options.fonts)) throw new TypeError("Validate fonts must be a fonts object with a textMeasurement.");
+    const measurement = options.fonts.textMeasurement;
+    if (measurement !== void 0 && typeof measurement !== "function" && !isObject(measurement)) throw new TypeError("Validate fonts.textMeasurement must be a text measurement, or a function of the slide index.");
+  }
+  if (options.chartPalette !== void 0 && (!Array.isArray(options.chartPalette) || !options.chartPalette.every((color) => typeof color === "string" && /^#[0-9a-fA-F]{6}$/.test(color))))
+    throw new TypeError("Validate chartPalette must be an array of #RRGGBB colours.");
+  if (options.template !== void 0 && typeof options.template !== "boolean") throw new TypeError("Validate template must be true or false.");
+  if (options.values !== void 0 && !isObject(options.values)) throw new TypeError("Validate values must be an object keyed by variable id.");
+  const level = (info) => severity.get(info.id) ?? severity.get(info.category);
+  const off = (info) => level(info) === "off" || !!ignore?.rules.has(info.id) || !!ignore?.categories.has(info.category);
+  return {
+    options,
+    off,
+    enabled: (info) => !off(info) && (!only || only.rules.has(info.id) || only.categories.has(info.category)),
+    severity: (info) => {
+      const value = level(info);
+      return value === "off" ? void 0 : value;
+    },
+    ignored: (info, path) => ignorePaths.some((entry) => entry.match(info) && entry.path.every((part, index) => path[index] === part)),
+    thresholds,
+    chartPalette: options.chartPalette ?? DEFAULT_CHART_PALETTE
+  };
+}
+var order = new Map(validationRules.map((info, index) => [info.id, index]));
+var categoryOrder = (category) => {
+  const index = validationCategories.indexOf(category);
+  return index < 0 ? validationCategories.length : index;
+};
+var auditInfos = ruleImplementations.flatMap((entry) => [entry.info, ...entry.also ?? []]);
+var isLayoutRule = (info) => info.category === "layout" && info.cost === "composition";
+function slideOf(path) {
+  const match = /^\/slides\/(\d+)(?:\/|$)/.exec(path);
+  return match ? Number(match[1]) : void 0;
+}
+function counts(findings) {
+  const result = { error: 0, warning: 0, info: 0 };
+  for (const entry of findings) result[entry.severity]++;
+  return result;
+}
+var FIXED = { backgroundPixels: "not-read", imageBytes: "embedded-only", nativeExport: "not-checked" };
+function syntaxReport(parsed, run) {
+  const findings = [];
+  for (const entry of parsed.syntax) {
+    const info = findValidationRule(entry.ruleId);
+    if (info && run.off(info)) continue;
+    const severity = info ? run.severity(info) : void 0;
+    findings.push(severity ? { ...entry, severity } : entry);
+  }
+  const checks = {
+    syntax: "checked",
+    schema: "not-run",
+    references: "not-run",
+    policy: "not-run",
+    accessibility: "not-run",
+    content: "not-run",
+    layout: "not-run",
+    ...FIXED
+  };
+  const tally = counts(findings);
+  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, ...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));
+  const explainFormat = !schemaValid && auditWanted;
+  const enabledRule = (info) => info ? run.enabled(info) || explainFormat && info.category === "format" && !run.off(info) : true;
+  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))));
+  }
+  const referencesWanted = validationRules.some((info) => info.category === "references" && run.enabled(info));
+  if (referencesWanted) {
+    findings.push(...referenceFindings(document, engine, run.options).filter((entry) => enabledRule(findValidationRule(entry.ruleId))));
+  }
+  const contracts = run.options.contracts ?? [];
+  const contractRule = findValidationRule("opf/contract");
+  const policyRan = contracts.length > 0 && !!contractRule && enabledRule(contractRule);
+  if (policyRan && contractRule) {
+    findings.push(...contractFindings(document, contracts));
+  }
+  const auditRan = /* @__PURE__ */ new Set();
+  if (schemaValid && auditWanted) {
+    const doc = document;
+    const context = {
+      document: doc,
+      slides: buildSlides(doc, run.options),
+      thresholds: run.thresholds,
+      options: run.options,
+      chartPalette: run.chartPalette,
+      report(info, input) {
+        const severity = run.severity(info) ?? input.severity ?? info.severity;
+        const entry = {
+          ruleId: info.id,
+          severity,
+          category: info.category,
+          scope: "document",
+          path: input.path,
+          message: input.message,
+          help: input.help,
+          definition: `${DOCS}#${info.id.replace("/", "")}`,
+          ...input.slide ? { slide: input.slide.index, ...input.slide.id ? { slideId: input.slide.id } : {} } : {},
+          ...input.measured ? { measured: input.measured } : {},
+          ...input.fixes?.length ? { fixes: input.fixes } : {},
+          ...input.suggestions ? { suggestions: input.suggestions } : {}
+        };
+        if (run.enabled(info)) findings.push(entry);
+        return entry;
+      }
+    };
+    for (const entry of ruleImplementations) {
+      const all = [entry.info, ...entry.also ?? []];
+      if (!all.some((info) => run.enabled(info))) continue;
+      for (const info of all) if (run.enabled(info)) auditRan.add(info.id);
+      entry.run(context);
+    }
+  }
+  const finished = [];
+  for (const entry of findings) {
+    const info = findValidationRule(entry.ruleId);
+    const override = info ? run.severity(info) : void 0;
+    const next = override && override !== entry.severity ? { ...entry, severity: override } : entry;
+    if (info && run.ignored(info, splitPointer(next.path))) continue;
+    const index = slideOf(next.path);
+    if (next.slide === void 0 && index !== void 0 && next.scope !== "context") {
+      const id = isObject(slides[index]) ? slides[index].id : void 0;
+      next.slide = index;
+      if (typeof id === "string") next.slideId = id;
+    }
+    if (parsed && next.location === void 0 && next.scope !== "context") {
+      const location = parsed.locate(next.path);
+      if (location) next.location = location;
+    }
+    finished.push(next);
+  }
+  finished.sort(
+    (a, b) => (a.slide ?? -1) - (b.slide ?? -1) || categoryOrder(a.category) - categoryOrder(b.category) || (order.get(a.ruleId) ?? Number.MAX_SAFE_INTEGER) - (order.get(b.ruleId) ?? Number.MAX_SAFE_INTEGER)
+  );
+  const tally = counts(finished);
+  const ranCategory = (category) => auditInfos.some((info) => info.category === category && auditRan.has(info.id));
+  const layoutRan = auditInfos.some((info) => isLayoutRule(info) && auditRan.has(info.id));
+  const checks = {
+    syntax: parsed ? "checked" : "not-applicable",
+    schema: "checked",
+    references: referencesWanted ? "checked" : "not-run",
+    policy: policyRan ? "checked" : "not-run",
+    accessibility: ranCategory("accessibility") ? "checked" : "not-run",
+    content: ranCategory("content") ? "checked" : "not-run",
+    layout: layoutRan || ranCategory("layout") ? run.options.fonts?.textMeasurement !== void 0 ? "measured" : "estimated" : "not-run",
+    ...FIXED
+  };
+  return {
+    valid: tally.error === 0,
+    schemaValid,
+    findings: finished,
+    counts: tally,
+    checks,
+    ...engine.template !== void 0 ? { template: engine.template, unfilledVariables: engine.unfilledVariables } : {}
+  };
+}
+function validate(input, options = {}) {
+  const run = resolveOptions(options);
+  if (typeof input === "string") {
+    const parsed = parseSource(input);
+    return parsed.syntax.length ? syntaxReport(parsed, run) : validateDocument(parsed.value, run, parsed);
+  }
+  return validateDocument(input, run);
+}
+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);
+}
+function validateCatalogRecord(kind, value) {
+  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));
+  const tally = counts(findings);
+  const checks = {
+    syntax: "not-applicable",
+    schema: "checked",
+    references: "not-run",
+    policy: "not-run",
+    accessibility: "not-run",
+    content: "not-run",
+    layout: "not-run",
+    ...FIXED
+  };
+  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);
+}
+
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules };