@openpresentation/opf 0.26.10 → 0.27.0

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

@@ -1,7 +1,7 @@
-import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, normalizeColorVariant, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, defaultSlideBackground, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-XRMV2GMB.js';
-import { schemas, schemaEntries } from './chunk-F4HFDP6I.js';
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
+import { original } from './chunk-JBARNYFR.js';
+import { schemas, schemaEntries } from './chunk-4ZM5G3XX.js';
+import { promotedRegionKeys, VARIABLE_KINDS, resolveChartData, chartPaletteForFill, chartSeriesPalette, chartLeadFromScheme, normalizeHexColor, resolveChartColors, colorContrast, imageBackground, tableGrid, timelineTextColor, LOGO_SHAPES, visitContentPayloads, readingRows, visualReadingOrder, intrinsicImageSize, resolveReference, textWidthMeasurer, resolveColorRef, resolveDesignRecords, resolveFontFamilies, checkCatalogsOption, provenanceOf, unresolvedReference, OPFUnresolvedReferenceError, resolveColorRoles, resolveCanvasDimensions, resolveSlideVariables, normalizeColorVariant, isRecord, hasContentVariables, isTemplate, instantiateForValidation, layoutTemplateIssues, resolveScriptFonts, defaultSlideBackground, catalogReferenceSites, parseReference, catalogGroupDeclared, pointerPath, unusedDatasets, MAX_COMPOSITION_DEPTH, datasetDiagnostics, pathFor, catalogRecords, collectCitations, numberingFindings, walkCitationRuns, resolveTableData, resolveChartOptions, chartOptionTarget, codeHighlightLines, chartNumberFixesByCell, catalogKinds, catalogGroupSource, registeredCatalog, OPFCompositionError, composeSlide } from './chunk-LRTQXGJO.js';
+import { schemaEngine } from '#schema-engine';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
 
 // src/catalog-schemas.ts
@@ -88,38 +88,9 @@ function unusedReferenceWarnings(value) {
 }
 
 // src/union-errors.ts
-var compiled = /* @__PURE__ */ new WeakMap();
-var origin = /* @__PURE__ */ new WeakMap();
 var isUnion = (error) => (error.keyword === "oneOf" || error.keyword === "anyOf") && Array.isArray(error.schema);
 var key = (error) => `${error.instancePath}\0${error.keyword}\0${error.message}\0${JSON.stringify(error.params)}`;
 var depth = (pointer4) => pointer4 ? pointer4.split("/").length - 1 : 0;
-var original = (node) => {
-  let current = node;
-  while (current && typeof current === "object" && origin.has(current)) current = origin.get(current);
-  return current;
-};
-function qualify(node, rootId) {
-  if (Array.isArray(node)) {
-    const copy = node.map((item) => qualify(item, rootId));
-    origin.set(copy, node);
-    return copy;
-  }
-  if (node && typeof node === "object") {
-    const copy = {};
-    for (const [name, value] of Object.entries(node)) copy[name] = name === "$ref" && typeof value === "string" && value.startsWith("#") ? rootId + value : qualify(value, rootId);
-    origin.set(copy, node);
-    return copy;
-  }
-  return node;
-}
-function branchValidator(ajv2, rootId, branch) {
-  let validate2 = compiled.get(branch);
-  if (!validate2) {
-    validate2 = ajv2.compile(qualify(branch, rootId));
-    compiled.set(branch, validate2);
-  }
-  return validate2;
-}
 function branchLabel(branch, index) {
   if (typeof branch.$ref === "string") return branch.$ref.slice(branch.$ref.lastIndexOf("/") + 1);
   if (typeof branch.type === "string") return branch.type;
@@ -135,12 +106,12 @@ function describe(errors, base) {
   const rest = shallow.instancePath.split("/").slice(base + 1).join("/");
   return depth(shallow.instancePath) === base || !rest ? shallow.message ?? "does not match" : `${shallow.message} at /${rest}`;
 }
-function bestMatchErrors(ajv2, rootId, errors) {
+function bestMatchErrors(engine, rootId, errors) {
   const unions = errors.filter(isUnion);
   if (!unions.length) return errors;
   const analyses = [];
   for (const union of unions) {
-    const analysis = analyze(ajv2, rootId, union);
+    const analysis = analyze(engine, rootId, union);
     if (analysis) analyses.push(analysis);
   }
   if (!analyses.length) return errors;
@@ -156,19 +127,20 @@ function bestMatchErrors(ajv2, rootId, errors) {
   }
   return result;
 }
-function analyze(ajv2, rootId, union) {
+function analyze(engine, rootId, union) {
   const branches = union.schema;
   const base = depth(union.instancePath);
   const results = [];
   for (const [index, branch] of branches.entries()) {
     if (!branch || typeof branch !== "object") return void 0;
-    const validate2 = branchValidator(ajv2, rootId, branch);
+    const validate2 = engine.branch(branch, rootId);
+    if (!validate2) return void 0;
     if (validate2(union.data) === true) return void 0;
     const raw = (validate2.errors ?? []).map((error) => ({ ...error, instancePath: union.instancePath + error.instancePath }));
     results.push({ label: branchLabel(branch, index), errors: raw });
   }
   const span = /* @__PURE__ */ new Set([key(union), ...results.flatMap((result) => result.errors.map(key))]);
-  const reduced = results.map((result) => ({ label: result.label, errors: bestMatchErrors(ajv2, rootId, result.errors) }));
+  const reduced = results.map((result) => ({ label: result.label, errors: bestMatchErrors(engine, rootId, result.errors) }));
   const mismatch = (error) => {
     const level = depth(error.instancePath) - base;
     return level === 0 && (error.keyword === "type" || isUnion(error)) || level === 1 && error.keyword === "const";
@@ -248,7 +220,6 @@ function validationDefinition(issue2) {
 
 // src/schema-check.ts
 var schemaNameByCatalogKind = catalogSchemaNames;
-var ajv;
 var promotedRegionKeySet = new Set(promotedRegionKeys);
 var rootPayloadFields = [
   "type",
@@ -326,23 +297,6 @@ var rowSpans = {
   "middle+bottom": [1, 2],
   "top+middle+bottom": [0, 1, 2]
 };
-function getAjv() {
-  if (ajv) {
-    return ajv;
-  }
-  const instance = new Ajv2020({
-    allErrors: true,
-    verbose: true,
-    strict: false,
-    allowUnionTypes: true
-  });
-  addFormats(instance);
-  for (const schema of Object.values(schemas)) {
-    instance.addSchema(schema);
-  }
-  ajv = instance;
-  return instance;
-}
 function isSchemaName(value) {
   return typeof value === "string" && hasOwn(schemas, value);
 }
@@ -350,17 +304,12 @@ function isCatalogKind(value) {
   return typeof value === "string" && hasOwn(schemaNameByCatalogKind, value);
 }
 function resolveValidator(schemaOrKind) {
-  const instance = getAjv();
   if (isSchemaName(schemaOrKind)) {
-    const schema = schemas[schemaOrKind];
-    const validator = instance.getSchema(schema.$id) ?? instance.compile(schema);
-    return { validate: validator, schemaName: schemaOrKind };
+    return { validate: schemaEngine().root(schemaOrKind), schemaName: schemaOrKind };
   }
   if (isCatalogKind(schemaOrKind)) {
     const schemaName = schemaNameByCatalogKind[schemaOrKind];
-    const schema = schemas[schemaName];
-    const validator = instance.getSchema(schema.$id) ?? instance.compile(schema);
-    return { validate: validator, schemaName, catalogKind: schemaOrKind };
+    return { validate: schemaEngine().root(schemaName), schemaName, catalogKind: schemaOrKind };
   }
   throw new TypeError(`Unknown schema or catalog kind ${JSON.stringify(schemaOrKind)}.`);
 }
@@ -983,7 +932,6 @@ function typedVariableErrors(errors, value) {
   if (!errors.some((error) => error.instancePath.startsWith("/variables/"))) return errors;
   const variables = value.variables;
   const kept = errors.filter((error) => !error.instancePath.startsWith("/variables/"));
-  const schemaId = schemas.presentation.$id;
   for (const [id, entry2] of Object.entries(variables)) {
     if (typeof entry2 === "string") {
       if (!hexColorPattern.test(entry2)) kept.push(variableIssue(id, "", "type", "must be a hex color string or a variable object", {}));
@@ -999,7 +947,7 @@ function typedVariableErrors(errors, value) {
       continue;
     }
     const definition = `${kind.charAt(0).toUpperCase()}${kind.slice(1)}Variable`;
-    const check = getAjv().getSchema(`${schemaId}#/$defs/${definition}`);
+    const check = schemaEngine().definition("presentation", definition);
     if (!check || check(entry2) === true) continue;
     for (const error of check.errors ?? []) {
       kept.push({ ...error, instancePath: `/variables/${id.replaceAll("~", "~0").replaceAll("/", "~1")}${error.instancePath}`, schemaPath: `#/$defs/${definition}${error.schemaPath.replace(/^#/, "")}` });
@@ -1020,7 +968,6 @@ function pointerValue(root, pointer4) {
 var datasetTableMessage = (field) => `'${field}' is not allowed on a dataset-backed table: it takes its headers, rows and column formats from the dataset`;
 function dataUnionErrors(errors, value) {
   let kept = errors;
-  const schemaId = schemas.presentation.$id;
   for (const union of errors) {
     if (union.keyword !== "oneOf") continue;
     const chartData = /\/chart\/data$/.test(union.instancePath) && /\/properties\/data\/oneOf$/.test(union.schemaPath);
@@ -1029,7 +976,7 @@ function dataUnionErrors(errors, value) {
     const target = pointerValue(value, union.instancePath);
     if (!isRecord(target)) continue;
     const branch = chartData ? hasOwn(target, "dataset") ? "DatasetRef" : hasOwn(target, "rows") ? "ChartData" : void 0 : hasOwn(target, "value") ? "StyledTableCell" : hasOwn(target, "name") ? "DataColumn" : void 0;
-    const check = branch ? getAjv().getSchema(`${schemaId}#/$defs/${branch}`) : void 0;
+    const check = branch ? schemaEngine().definition("presentation", branch) : void 0;
     if (!check || check(target) === true) continue;
     const branchErrors = (check.errors ?? []).map((error) => ({ ...error, instancePath: `${union.instancePath}${error.instancePath}`, schemaPath: `#/$defs/${branch}${error.schemaPath.replace(/^#/, "")}` }));
     const prefix = `${union.instancePath}/`;
@@ -1076,7 +1023,7 @@ function validateAgainstSchema(value, schemaOrKind = "presentation", options2 =
   const valid = resolved.validate(subject) === true;
   const ajvErrors = valid ? [] : typedVariableErrors(resolved.validate.errors ?? [], subject);
   const specific = resolved.schemaName === "presentation" ? dataUnionErrors(ajvErrors, subject) : ajvErrors;
-  const mapped = bestMatchErrors(getAjv(), schemas[resolved.schemaName].$id, specific).map(toIssue);
+  const mapped = bestMatchErrors(schemaEngine(), schemas[resolved.schemaName].$id, specific).map(toIssue);
   const errors = mapped;
   if (resolved.schemaName === "layout" && valid) for (const issue2 of layoutTemplateIssues(subject)) errors.push(semanticIssue(issue2.path, issue2.message, { code: issue2.code }));
   const warnings = [];
@@ -2457,7 +2404,8 @@ var chartRules = [
           const count = slices ? data.rows.length : data.columns.length - 1;
           if (count < 2) continue;
           const surface = slide.design.colors.surface;
-          const palette = chartPaletteForFill(surface, context.chartPalette ?? chartSeriesPalette(slide.design.colorScheme, chart.colors, chartColorContext(slide.design)));
+          const paletteContext = chartColorContext(slide.design);
+          const palette = chartPaletteForFill(surface, context.chartPalette ?? chartSeriesPalette(slide.design.colorScheme, chart.colors, paletteContext), { legibleLead: context.chartPalette === void 0 && chartLeadFromScheme(chart.colors, slide.design.colorScheme, paletteContext) });
           if (!palette.length) continue;
           const used = Array.from({ length: Math.min(count, 24) }, (_, i) => palette[i % palette.length]);
           const pairs = [];
@@ -3526,6 +3474,157 @@ function contractFindings(document, contracts) {
   return findings;
 }
 
+// src/document-hash.ts
+function canonicalJson(value) {
+  const stack = [];
+  const write = (item) => {
+    if (item === null || typeof item === "boolean" || typeof item === "string") return JSON.stringify(item);
+    if (typeof item === "number") return JSON.stringify(item);
+    if (typeof item === "bigint") throw new TypeError("A BigInt is not JSON.");
+    if (typeof item !== "object") return void 0;
+    if (stack.includes(item)) throw new TypeError("A cyclic value has no canonical JSON.");
+    stack.push(item);
+    let text2;
+    if (Array.isArray(item)) {
+      text2 = `[${item.map((entry2) => write(entry2) ?? "null").join(",")}]`;
+    } else {
+      const record = item;
+      const members = [];
+      for (const key2 of Object.keys(record).sort()) {
+        const member = write(record[key2]);
+        if (member !== void 0) members.push(`${JSON.stringify(key2)}:${member}`);
+      }
+      text2 = `{${members.join(",")}}`;
+    }
+    stack.pop();
+    return text2;
+  };
+  return write(value) ?? "null";
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(bytes) {
+  const length = bytes.length;
+  const padded = new Uint8Array(length + 9 + 63 >> 6 << 6);
+  padded.set(bytes);
+  padded[length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(length / 536870912), false);
+  view.setUint32(padded.length - 4, length << 3 >>> 0, false);
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 64; i += 1) {
+      const a2 = w[i - 15], b2 = w[i - 2];
+      const s0 = (a2 >>> 7 | a2 << 25) ^ (a2 >>> 18 | a2 << 14) ^ a2 >>> 3;
+      const s1 = (b2 >>> 17 | b2 << 15) ^ (b2 >>> 19 | b2 << 13) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+    }
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const choose = e & f ^ ~e & g;
+      const t1 = hh + s1 + choose + K[i] + w[i] | 0;
+      const s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const majority = a & b ^ a & c ^ b & c;
+      const t2 = s0 + majority | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  let hex = "";
+  for (const word of h) hex += word.toString(16).padStart(8, "0");
+  return hex;
+}
+function documentHash(document) {
+  return `sha256:${sha256Hex(new TextEncoder().encode(canonicalJson(document)))}`;
+}
+var HASH_PATTERN = /^(?:sha256:)?([0-9a-fA-F]{64})$/;
+function normalizeDocumentHash(value) {
+  if (typeof value !== "string") return void 0;
+  const match2 = HASH_PATTERN.exec(value);
+  return match2 ? `sha256:${match2[1].toLowerCase()}` : void 0;
+}
+
 // src/patch.ts
 var OPFPatchError = class extends Error {
   code;
@@ -3552,6 +3651,18 @@ var OPFPatchValidationError = class extends OPFPatchError {
     this.validation = validation;
   }
 };
+var OPFPatchHashError = class extends OPFPatchError {
+  /** The hash the caller expected, in the form `documentHash` returns. */
+  expected;
+  /** The hash of the document the patch was given. */
+  actual;
+  constructor(expected, actual) {
+    super("patch-hash-mismatch", "The document changed since it was read: its hash is not the expected hash. Nothing was applied.");
+    this.name = "OPFPatchHashError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
 var own2 = (value, key2) => Object.prototype.hasOwnProperty.call(value, key2);
 var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var clone = (value) => structuredClone(value);
@@ -3597,13 +3708,83 @@ function splitPointer2(pointer4) {
   if (!tokens.length) throw new OPFPatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer4 });
   return { parent: formatPointer(tokens.slice(0, -1)), token: tokens[tokens.length - 1] };
 }
+var isIdToken = (token) => token.length > 1 && token.startsWith("@");
+var idToken = (id) => `@${id}`;
+var INDEX_TOKEN = /^(0|[1-9][0-9]*)$/;
+function indexOfId(array, id) {
+  let found = -1;
+  for (let i = 0; i < array.length; i += 1) {
+    const item = array[i];
+    if (isObject(item) && own2(item, "id") && item.id === id) {
+      if (found !== -1) return -2;
+      found = i;
+    }
+  }
+  return found;
+}
+function uniqueIdAt(array, at2) {
+  const item = array[at2];
+  if (!isObject(item) || !own2(item, "id") || typeof item.id !== "string" || item.id === "") return void 0;
+  return indexOfId(array, item.id) === at2 ? item.id : void 0;
+}
+function resolveTokens(document, tokens, pointer4) {
+  const out = [];
+  let cursor = document, walking = true;
+  for (const token of tokens) {
+    let resolved = token;
+    if (walking && Array.isArray(cursor) && isIdToken(token)) {
+      const at2 = indexOfId(cursor, token.slice(1));
+      if (at2 === -1) throw new OPFPatchError("patch-id-not-found", `No element of ${formatPointer(out) || "/"} has the id '${token.slice(1)}'.`, { path: pointer4 });
+      if (at2 === -2) throw new OPFPatchError("patch-id-ambiguous", `More than one element of ${formatPointer(out) || "/"} has the id '${token.slice(1)}'.`, { path: pointer4 });
+      resolved = String(at2);
+    }
+    out.push(resolved);
+    if (walking) {
+      const next = readPointer(cursor, [resolved]);
+      if (next.found) cursor = next.value;
+      else walking = false;
+    }
+  }
+  return out;
+}
+function resolveIdPointer(document, pointer4) {
+  const tokens = parsePointer(pointer4);
+  return tokens.some(isIdToken) ? formatPointer(resolveTokens(document, tokens, pointer4)) : pointer4;
+}
+function idTokens(document, tokens, convertLast) {
+  const out = [];
+  let cursor = document, walking = true;
+  tokens.forEach((token, i) => {
+    let named = token;
+    if (walking && Array.isArray(cursor) && INDEX_TOKEN.test(token) && (convertLast || i < tokens.length - 1)) {
+      const id = uniqueIdAt(cursor, Number(token));
+      if (id !== void 0) named = idToken(id);
+    }
+    out.push(named);
+    if (walking) {
+      const next = readPointer(cursor, [token]);
+      if (next.found) cursor = next.value;
+      else walking = false;
+    }
+  });
+  return out;
+}
+function toIdPointer(document, pointer4, options2 = {}) {
+  return formatPointer(idTokens(document, resolveTokens(document, parsePointer(pointer4), pointer4), !options2.keepLast));
+}
 function readPointer(document, pointer4) {
   const tokens = typeof pointer4 === "string" ? parsePointer(pointer4) : pointer4;
   let value = document;
   for (const token of tokens) {
     if (Array.isArray(value)) {
-      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { found: false };
-      const at2 = Number(token);
+      let at2;
+      if (isIdToken(token)) {
+        at2 = indexOfId(value, token.slice(1));
+        if (at2 < 0) return { found: false };
+      } else {
+        if (!INDEX_TOKEN.test(token)) return { found: false };
+        at2 = Number(token);
+      }
       if (!Number.isSafeInteger(at2) || at2 >= value.length) return { found: false };
       value = value[at2];
     } else if (value && typeof value === "object" && own2(value, token)) value = value[token];
@@ -3622,7 +3803,7 @@ function getAtPointer(document, pointer4) {
 var hasPointer = (document, pointer4) => readPointer(document, pointer4).found;
 function arrayIndex(token, length, allowEnd, path) {
   if (allowEnd && token === "-") return length;
-  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
+  if (!INDEX_TOKEN.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
   const at2 = Number(token);
   if (!Number.isSafeInteger(at2) || at2 > length || !allowEnd && at2 >= length) throw new OPFPatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
   return at2;
@@ -3667,38 +3848,42 @@ function parentOf(document, tokens, path) {
 }
 var NONE = /* @__PURE__ */ Symbol("none");
 function addAt(document, path, value) {
-  const tokens = parsePointer(path);
-  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const tokens = resolveTokens(document, parsePointer(path), path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) }, pointer: "" };
   const { parent, key: key2 } = parentOf(document, tokens, path);
   if (Array.isArray(parent)) {
     const at2 = arrayIndex(key2, parent.length, true, path);
     parent.splice(at2, 0, clone(value));
-    return { document, inverse: { op: "remove", path: formatPointer([...tokens.slice(0, -1), at2]) } };
+    const pointer5 = formatPointer([...tokens.slice(0, -1), at2]);
+    return { document, inverse: { op: "remove", path: pointer5 }, pointer: pointer5 };
   }
   const record = parent;
   const previous = own2(record, key2) ? record[key2] : NONE;
   Object.defineProperty(record, key2, { value: clone(value), enumerable: true, configurable: true, writable: true });
-  return { document, inverse: previous === NONE ? { op: "remove", path } : { op: "replace", path, value: clone(previous) } };
+  const pointer4 = formatPointer(tokens);
+  return { document, inverse: previous === NONE ? { op: "remove", path: pointer4 } : { op: "replace", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function replaceAt(document, path, value) {
-  const tokens = parsePointer(path);
-  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const tokens = resolveTokens(document, parsePointer(path), path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) }, pointer: "" };
   const { parent, key: key2 } = parentOf(document, tokens, path);
   let previous;
+  let pointer4 = formatPointer(tokens);
   if (Array.isArray(parent)) {
     const at2 = arrayIndex(key2, parent.length, false, path);
     previous = parent[at2];
     parent[at2] = clone(value);
+    pointer4 = formatPointer([...tokens.slice(0, -1), at2]);
   } else {
     const record = parent;
     if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
     previous = record[key2];
     Object.defineProperty(record, key2, { value: clone(value), enumerable: true, configurable: true, writable: true });
   }
-  return { document, inverse: { op: "replace", path, value: clone(previous) } };
+  return { document, inverse: { op: "replace", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function removeAt(document, path) {
-  const tokens = parsePointer(path);
+  const tokens = resolveTokens(document, parsePointer(path), path);
   if (!tokens.length) throw new OPFPatchError("patch-root-remove", "The document root cannot be removed.", { path });
   const { parent, key: key2 } = parentOf(document, tokens, path);
   let previous;
@@ -3706,60 +3891,71 @@ function removeAt(document, path) {
     const at2 = arrayIndex(key2, parent.length, false, path);
     previous = parent[at2];
     parent.splice(at2, 1);
-    return { document, inverse: { op: "add", path: formatPointer([...tokens.slice(0, -1), at2]), value: clone(previous) } };
+    const pointer5 = formatPointer([...tokens.slice(0, -1), at2]);
+    return { document, inverse: { op: "add", path: pointer5, value: clone(previous) }, pointer: pointer5 };
   }
   const record = parent;
   if (!own2(record, key2)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
   previous = record[key2];
   delete record[key2];
-  return { document, inverse: { op: "add", path, value: clone(previous) } };
+  const pointer4 = formatPointer(tokens);
+  return { document, inverse: { op: "add", path: pointer4, value: clone(previous) }, pointer: pointer4 };
 }
 function applyOne(document, operation) {
   switch (operation.op) {
     case "add": {
       const r = addAt(document, operation.path, operation.value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "add", path: r.pointer, value: operation.value } };
     }
     case "replace": {
       const r = replaceAt(document, operation.path, operation.value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "replace", path: r.pointer, value: operation.value } };
     }
     case "remove": {
       const r = removeAt(document, operation.path);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "remove", path: r.pointer } };
     }
     case "test": {
       const found = readPointer(document, operation.path);
       if (!found.found || !jsonEqual(found.value, operation.value)) throw new OPFPatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
-      return { document, inverse: [] };
+      return { document, inverse: [], resolved: { op: "test", path: resolveIdPointer(document, operation.path), value: operation.value } };
     }
     case "copy": {
-      const value = clone(getAtPointer(document, operation.from));
+      const from = resolveIdPointer(document, operation.from);
+      const value = clone(getAtPointer(document, from));
       const r = addAt(document, operation.path, value);
-      return { document: r.document, inverse: [r.inverse] };
+      return { document: r.document, inverse: [r.inverse], resolved: { op: "copy", from, path: r.pointer } };
     }
     case "move": {
-      const from = parsePointer(operation.from), to = parsePointer(operation.path);
+      const from = resolveTokens(document, parsePointer(operation.from), operation.from);
+      let to;
+      try {
+        to = resolveTokens(document, parsePointer(operation.path), operation.path);
+      } catch {
+        to = parsePointer(operation.path);
+      }
       const value = clone(getAtPointer(document, from));
-      if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [] };
+      if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [], resolved: { op: "move", from: formatPointer(from), path: formatPointer(to) } };
       if (to.length > from.length && from.every((token, i) => to[i] === token)) {
         throw new OPFPatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
       }
-      const removed = removeAt(document, operation.from);
+      const removed = removeAt(document, formatPointer(from));
       const added = addAt(removed.document, operation.path, value);
-      return { document: added.document, inverse: [added.inverse, removed.inverse] };
+      return { document: added.document, inverse: [added.inverse, removed.inverse], resolved: { op: "move", from: removed.pointer, path: added.pointer } };
     }
   }
 }
-function applyPatchWithInverse(document, patch2, options2 = {}) {
+function walkPatch(document, patch2, hooks = {}) {
   const operations = normalizePatch(patch2);
   let working = clone(document);
   const inverse = [];
   for (const [index, operation] of operations.entries()) {
     try {
-      const step = applyOne(working, operation);
-      working = step.document;
-      inverse.unshift(...step.inverse);
+      hooks.before?.(index, operation, working);
+      const applied = applyOne(working, operation);
+      working = applied.document;
+      inverse.unshift(...applied.inverse);
+      hooks.after?.({ index, operation, resolved: applied.resolved, inverse: applied.inverse }, working);
     } catch (error) {
       if (error instanceof OPFPatchError && error.index === void 0) {
         const wrapped = new OPFPatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
@@ -3768,6 +3964,17 @@ function applyPatchWithInverse(document, patch2, options2 = {}) {
       throw error;
     }
   }
+  return { document: working, operations, inverse };
+}
+function assertExpectedHash(document, expectHash) {
+  const expected = normalizeDocumentHash(expectHash);
+  if (expected === void 0) throw new OPFPatchError("invalid-expect-hash", "expectHash must be a document hash: the value documentHash(document) returns.");
+  const actual = documentHash(document);
+  if (actual !== expected) throw new OPFPatchHashError(expected, actual);
+}
+function applyPatchWithInverse(document, patch2, options2 = {}) {
+  if (options2.expectHash !== void 0) assertExpectedHash(document, options2.expectHash);
+  const { document: working, operations, inverse } = walkPatch(document, patch2);
   const result = { presentation: working, inverse, patch: operations };
   if (options2.validate) {
     const validator = typeof options2.validate === "function" ? options2.validate : (value) => validate(value, { only: options2.strict ? ["format", "references"] : ["format"] });
@@ -3783,6 +3990,50 @@ function applyPatch(document, patch2, options2 = {}) {
 function invertPatch(document, patch2) {
   return applyPatchWithInverse(document, patch2).inverse;
 }
+function resolveIdPatch(document, patch2) {
+  const resolved = [];
+  walkPatch(document, patch2, { after: (step) => {
+    resolved.push(step.resolved);
+  } });
+  return resolved;
+}
+function toIdPatch(document, patch2) {
+  const out = [];
+  const pending = /* @__PURE__ */ new Map();
+  walkPatch(document, patch2, {
+    before: (index, operation, working) => {
+      const named = (pointer4) => toIdPointer(working, pointer4);
+      switch (operation.op) {
+        case "replace":
+        case "remove":
+        case "test":
+          pending.set(index, { ...operation, path: named(operation.path) });
+          break;
+        case "copy":
+          pending.set(index, { ...operation, from: named(operation.from), path: toIdPointer(working, operation.path, { keepLast: true }) });
+          break;
+        case "add":
+          pending.set(index, { ...operation, path: toIdPointer(working, operation.path, { keepLast: true }) });
+          break;
+        case "move":
+          pending.set(index, { ...operation, from: named(operation.from) });
+          break;
+      }
+    },
+    after: (step, working) => {
+      const early = pending.get(step.index);
+      pending.delete(step.index);
+      if (step.operation.op !== "move") {
+        out.push(early);
+        return;
+      }
+      const appended = parsePointer(step.operation.path).at(-1) === "-";
+      const destination = toIdPointer(working, step.resolved.path, { keepLast: true });
+      out.push({ ...early, path: appended ? formatPointer([...parsePointer(destination).slice(0, -1), "-"]) : destination });
+    }
+  });
+  return out;
+}
 
 // src/schema-catalog-kinds.ts
 var schemaCatalogKinds = {
@@ -7457,4 +7708,4 @@ function assertValidCatalogRecord(kind, value) {
   if (!report2.valid) throw new OPFValidationError(report2);
 }
 
-export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, CATALOG_SCHEMA, COMMON_KEYS, DEFAULT_VALIDATION_THRESHOLDS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, OPFPatchError, OPFPatchValidationError, OPFValidationError, PATTERN_PHRASES, SLIDE_OPTION_KEYS, SOURCE_EXPLAIN, SPAN_FLAGS, SPAN_VALUES, UNRANKED_PRIORITY, activeSchema, analyzeJsonSyntax, applyPatch, applyPatchWithInverse, applyTextEdits, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogKindAt, catalogSchemaNames, createLocator, createSchemaValue, describeField, describeFinding, distance2 as distance, escapePointerToken, findValidationRule, formatPointer, getAtPointer, hasPointer, invertPatch, isPromotedRegionKey, jsonEqual, listSchemaFields, nearest, normalizePatch, parsePointer, parseSource, pointerFromPath, readPointer, rememberByText, resolveSchema, resolveSlideContext, resolveSlideScriptMeasurement, ruleDocumentation, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, segmentsOf, splitOpfPath, splitPointer2 as splitPointer, starterValue, unescapePointerToken, us, validate, validateCatalogRecord, validationCategories, validationRules };
+export { BLOCK_AS_VALUES, BLOCK_OPTION_KEYS, CATALOG_SCHEMA, COMMON_KEYS, DEFAULT_VALIDATION_THRESHOLDS, FENCE_ATTRIBUTES, FENCE_KINDS, LINE_KEYWORDS, METRIC_KEYS, OPFPatchError, OPFPatchHashError, OPFPatchValidationError, OPFValidationError, PATTERN_PHRASES, SLIDE_OPTION_KEYS, SOURCE_EXPLAIN, SPAN_FLAGS, SPAN_VALUES, UNRANKED_PRIORITY, activeSchema, analyzeJsonSyntax, applyPatch, applyPatchWithInverse, applyTextEdits, assertValid, assertValidCatalogRecord, catalogDisplayKinds, catalogKindAt, catalogSchemaNames, createLocator, createSchemaValue, describeField, describeFinding, distance2 as distance, documentHash, escapePointerToken, findValidationRule, formatPointer, getAtPointer, hasPointer, idToken, invertPatch, isIdToken, isPromotedRegionKey, jsonEqual, listSchemaFields, nearest, normalizePatch, parsePointer, parseSource, pointerFromPath, readPointer, rememberByText, resolveIdPatch, resolveIdPointer, resolveSchema, resolveSlideContext, resolveSlideScriptMeasurement, ruleDocumentation, schemaAtPath, schemaCatalogKinds, schemaLabel, schemaType, schemaVariants, segmentsOf, splitOpfPath, splitPointer2 as splitPointer, starterValue, toIdPatch, toIdPointer, unescapePointerToken, us, validate, validateCatalogRecord, validationCategories, validationRules, walkPatch };