@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/core/state/editor-state.cjs

@@ -0,0 +1,2278 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/state/editor-state.ts
+var editor_state_exports = {};
+__export(editor_state_exports, {
+  createCanonicalDocumentId: () => createCanonicalDocumentId,
+  createDefaultCanonicalDocument: () => createDefaultCanonicalDocument,
+  createEditorState: () => createEditorState,
+  createEmptyCompatibilityReport: () => createEmptyCompatibilityReport,
+  createEmptyReviewStore: () => createEmptyReviewStore,
+  createPersistedEditorSnapshot: () => createPersistedEditorSnapshot2,
+  createSelectionSnapshot: () => createSelectionSnapshot,
+  deriveDocumentStats: () => deriveDocumentStats,
+  deriveRenderSnapshot: () => deriveRenderSnapshot,
+  normalizeCommentThreadRecord: () => normalizeCommentThreadRecord
+});
+module.exports = __toCommonJS(editor_state_exports);
+
+// src/core/selection/mapping.ts
+var DEFAULT_BOUNDARY_ASSOC = {
+  start: 1,
+  end: -1
+};
+function createRangeAnchor(from, to = from, assoc = DEFAULT_BOUNDARY_ASSOC) {
+  return {
+    kind: "range",
+    range: normalizeRange({ from, to }),
+    assoc
+  };
+}
+function createNodeAnchor(at, assoc = 1) {
+  return {
+    kind: "node",
+    at,
+    assoc
+  };
+}
+function createDetachedAnchor(lastKnownRange, reason) {
+  return {
+    kind: "detached",
+    lastKnownRange: normalizeRange(lastKnownRange),
+    reason
+  };
+}
+function normalizeRange(range) {
+  return range.from <= range.to ? { from: range.from, to: range.to } : { from: range.to, to: range.from };
+}
+
+// src/model/cds-1.0.0.ts
+var CDS_SCHEMA_VERSION = "cds/1.0.0";
+var LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION = "persisted-editor-snapshot/1";
+var PERSISTED_EDITOR_SNAPSHOT_VERSION = "persisted-editor-snapshot/2";
+var COMPATIBILITY_REPORT_VERSION = "compatibility-report/1";
+var ModelValidationError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "ModelValidationError";
+    this.issues = issues;
+  }
+};
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var ISO_8601_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isUuid(value) {
+  return typeof value === "string" && UUID_PATTERN.test(value);
+}
+function isIso8601UtcTimestamp(value) {
+  return typeof value === "string" && ISO_8601_UTC_PATTERN.test(value) && !Number.isNaN(Date.parse(value));
+}
+function asPlainObject(value, path, issues) {
+  if (!isPlainObject(value)) {
+    issues.push({ path, message: "Expected a plain object." });
+    return null;
+  }
+  return value;
+}
+function expectString(value, path, issues) {
+  if (!isNonEmptyString(value)) {
+    issues.push({ path, message: "Expected a non-empty string." });
+    return null;
+  }
+  return value;
+}
+function expectStringAllowEmpty(value, path, issues) {
+  if (typeof value !== "string") {
+    issues.push({ path, message: "Expected a string." });
+    return null;
+  }
+  return value;
+}
+function expectExactString(value, expected, path, issues) {
+  if (value !== expected) {
+    issues.push({
+      path,
+      message: `Expected ${JSON.stringify(expected)}.`
+    });
+    return null;
+  }
+  return expected;
+}
+function expectIso8601UtcTimestamp(value, path, issues) {
+  if (!isIso8601UtcTimestamp(value)) {
+    issues.push({
+      path,
+      message: "Expected an ISO 8601 UTC timestamp string."
+    });
+    return null;
+  }
+  return value;
+}
+function expectUuid(value, path, issues) {
+  if (!isUuid(value)) {
+    issues.push({
+      path,
+      message: "Expected an RFC 4122 UUID string."
+    });
+    return null;
+  }
+  return value;
+}
+function assertValid(issues, message) {
+  if (issues.length > 0) {
+    throw new ModelValidationError(message, issues);
+  }
+}
+
+// src/model/canonical-document.ts
+var CANONICAL_DOCUMENT_TOP_LEVEL_KEYS = [
+  "schemaVersion",
+  "docId",
+  "createdAt",
+  "updatedAt",
+  "metadata",
+  "styles",
+  "numbering",
+  "media",
+  "content",
+  "review",
+  "preservation",
+  "diagnostics"
+];
+var CANONICAL_DOCUMENT_OPTIONAL_KEYS = ["subParts", "fieldRegistry"];
+var ID_PATTERNS = {
+  styleId: /^[A-Za-z_][A-Za-z0-9._-]{0,127}$/,
+  abstractNumberingId: /^abstract-num:[A-Za-z0-9._-]{1,120}$/,
+  numberingInstanceId: /^num:[A-Za-z0-9._-]{1,120}$/,
+  mediaId: /^media:[A-Za-z0-9._/-]{1,120}$/,
+  commentId: /^(?:comment:[A-Za-z0-9._-]{1,120}|comment-[A-Za-z0-9._-]{1,120}|[0-9]{1,18})$/,
+  revisionId: /^(?:revision:[A-Za-z0-9._-]{1,120}|change-[A-Za-z0-9._-]{1,120})$/,
+  fragmentId: /^fragment:[A-Za-z0-9._-]{1,120}$/,
+  warningId: /^warning:[A-Za-z0-9._:-]{1,120}$/,
+  diagnosticId: /^diagnostic:[A-Za-z0-9._-]{1,120}$/,
+  packagePartName: /^\/[A-Za-z0-9_.\-\/]+\.[A-Za-z0-9]+$/,
+  relationshipId: /^rId[A-Za-z0-9._-]{1,120}$/
+};
+function assertCanonicalDocument(value) {
+  const issues = validateCanonicalDocument(value);
+  assertValid(issues, "Invalid canonical document.");
+}
+function validateCanonicalDocument(value) {
+  const issues = [];
+  const record = asPlainObject(value, "$", issues);
+  if (!record) {
+    return issues;
+  }
+  validateExactObjectKeys(record, CANONICAL_DOCUMENT_TOP_LEVEL_KEYS, "$", issues, CANONICAL_DOCUMENT_OPTIONAL_KEYS);
+  expectExactString(record.schemaVersion, CDS_SCHEMA_VERSION, "$.schemaVersion", issues);
+  expectUuid(record.docId, "$.docId", issues);
+  expectIso8601UtcTimestamp(record.createdAt, "$.createdAt", issues);
+  expectIso8601UtcTimestamp(record.updatedAt, "$.updatedAt", issues);
+  validateMetadata(record.metadata, "$.metadata", issues);
+  validateStylesCatalog(record.styles, "$.styles", issues);
+  validateNumberingCatalog(record.numbering, "$.numbering", issues);
+  validateMediaCatalog(record.media, "$.media", issues);
+  validateDocumentNode(record.content, "$.content", issues);
+  validateReviewStore(record.review, "$.review", issues);
+  validatePreservationStore(record.preservation, "$.preservation", issues);
+  validateDiagnosticStore(record.diagnostics, "$.diagnostics", issues);
+  if (record.subParts !== void 0) {
+    validateSubPartsCatalog(record.subParts, "$.subParts", issues);
+  }
+  validateDocumentReferences(record, issues);
+  return issues;
+}
+function validateMetadata(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const customProperties = asPlainObject(record.customProperties, `${path}.customProperties`, issues);
+  if (!customProperties) {
+    return;
+  }
+  for (const [propertyKey, propertyValue] of Object.entries(customProperties)) {
+    if (typeof propertyValue !== "string") {
+      issues.push({
+        path: `${path}.customProperties.${propertyKey}`,
+        message: "customProperties values must be strings."
+      });
+    }
+  }
+}
+function validateStylesCatalog(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  validateStyleMap(record.paragraphs, `${path}.paragraphs`, issues);
+  validateStyleMap(record.characters, `${path}.characters`, issues);
+  validateStyleMap(record.tables, `${path}.tables`, issues);
+  if (record.latentStyles !== void 0) {
+    validateLatentStyleMap(record.latentStyles, `${path}.latentStyles`, issues);
+  }
+}
+function validateStyleMap(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  for (const [styleId, definition] of Object.entries(record)) {
+    expectDomainString(styleId, "styleId", `${path}.${styleId}`, issues);
+    const definitionRecord = asPlainObject(definition, `${path}.${styleId}`, issues);
+    if (!definitionRecord) {
+      continue;
+    }
+    if (definitionRecord.styleId !== styleId) {
+      issues.push({
+        path: `${path}.${styleId}.styleId`,
+        message: "styleId must match the map key."
+      });
+    }
+  }
+}
+function validateLatentStyleMap(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  for (const [styleName, definition] of Object.entries(record)) {
+    const definitionRecord = asPlainObject(definition, `${path}.${styleName}`, issues);
+    if (!definitionRecord) {
+      continue;
+    }
+    if (definitionRecord.name !== styleName) {
+      issues.push({
+        path: `${path}.${styleName}.name`,
+        message: "name must match the map key."
+      });
+    }
+    if (definitionRecord.uiPriority !== void 0 && typeof definitionRecord.uiPriority !== "number") {
+      issues.push({
+        path: `${path}.${styleName}.uiPriority`,
+        message: "uiPriority must be a number."
+      });
+    }
+  }
+}
+function validateNumberingCatalog(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const abstractDefinitions = asPlainObject(
+    record.abstractDefinitions,
+    `${path}.abstractDefinitions`,
+    issues
+  );
+  if (abstractDefinitions) {
+    for (const [abstractId, definition] of Object.entries(abstractDefinitions)) {
+      expectDomainString(
+        abstractId,
+        "abstractNumberingId",
+        `${path}.abstractDefinitions.${abstractId}`,
+        issues
+      );
+      const definitionRecord = asPlainObject(
+        definition,
+        `${path}.abstractDefinitions.${abstractId}`,
+        issues
+      );
+      if (definitionRecord && definitionRecord.abstractNumberingId !== abstractId) {
+        issues.push({
+          path: `${path}.abstractDefinitions.${abstractId}.abstractNumberingId`,
+          message: "abstractNumberingId must match the map key."
+        });
+      }
+    }
+  }
+  const instances = asPlainObject(record.instances, `${path}.instances`, issues);
+  if (instances) {
+    for (const [instanceId, instance] of Object.entries(instances)) {
+      expectDomainString(
+        instanceId,
+        "numberingInstanceId",
+        `${path}.instances.${instanceId}`,
+        issues
+      );
+      const instanceRecord = asPlainObject(
+        instance,
+        `${path}.instances.${instanceId}`,
+        issues
+      );
+      if (!instanceRecord) {
+        continue;
+      }
+      if (instanceRecord.numberingInstanceId !== instanceId) {
+        issues.push({
+          path: `${path}.instances.${instanceId}.numberingInstanceId`,
+          message: "numberingInstanceId must match the map key."
+        });
+      }
+      expectDomainString(
+        instanceRecord.abstractNumberingId,
+        "abstractNumberingId",
+        `${path}.instances.${instanceId}.abstractNumberingId`,
+        issues
+      );
+    }
+  }
+}
+function validateMediaCatalog(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const items = asPlainObject(record.items, `${path}.items`, issues);
+  if (!items) {
+    return;
+  }
+  for (const [mediaId, item] of Object.entries(items)) {
+    expectDomainString(mediaId, "mediaId", `${path}.items.${mediaId}`, issues);
+    const itemRecord = asPlainObject(item, `${path}.items.${mediaId}`, issues);
+    if (!itemRecord) {
+      continue;
+    }
+    if (itemRecord.mediaId !== mediaId) {
+      issues.push({
+        path: `${path}.items.${mediaId}.mediaId`,
+        message: "mediaId must match the map key."
+      });
+    }
+    expectDomainString(
+      itemRecord.packagePartName,
+      "packagePartName",
+      `${path}.items.${mediaId}.packagePartName`,
+      issues
+    );
+    if (itemRecord.relationshipId !== void 0) {
+      expectDomainString(
+        itemRecord.relationshipId,
+        "relationshipId",
+        `${path}.items.${mediaId}.relationshipId`,
+        issues
+      );
+    }
+  }
+}
+function validateDocumentNode(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const type = expectString(record.type, `${path}.type`, issues);
+  if (!type) {
+    return;
+  }
+  switch (type) {
+    case "doc":
+    case "paragraph":
+    case "sdt":
+    case "custom_xml":
+    case "hyperlink":
+      if (!Array.isArray(record.children)) {
+        issues.push({ path: `${path}.children`, message: "children must be an array." });
+      } else {
+        record.children.forEach(
+          (child, index) => validateDocumentNode(child, `${path}.children[${index}]`, issues)
+        );
+      }
+      if (type === "paragraph" && record.styleId !== void 0) {
+        expectDomainString(record.styleId, "styleId", `${path}.styleId`, issues);
+      }
+      if (type === "paragraph" && record.numbering !== void 0) {
+        const numbering = asPlainObject(record.numbering, `${path}.numbering`, issues);
+        if (numbering) {
+          expectDomainString(
+            numbering.numberingInstanceId,
+            "numberingInstanceId",
+            `${path}.numbering.numberingInstanceId`,
+            issues
+          );
+          if (typeof numbering.level !== "number") {
+            issues.push({
+              path: `${path}.numbering.level`,
+              message: "level must be a number."
+            });
+          }
+        }
+      }
+      if (type === "hyperlink") {
+        expectString(record.href, `${path}.href`, issues);
+      }
+      return;
+    case "alt_chunk":
+      expectDomainString(record.relationshipId, "relationshipId", `${path}.relationshipId`, issues);
+      return;
+    case "image":
+      expectDomainString(record.mediaId, "mediaId", `${path}.mediaId`, issues);
+      if (record.placementXml !== void 0) {
+        expectString(record.placementXml, `${path}.placementXml`, issues);
+      }
+      if (record.display !== void 0) {
+        const display = expectString(record.display, `${path}.display`, issues);
+        if (display && display !== "inline" && display !== "floating") {
+          issues.push({
+            path: `${path}.display`,
+            message: "display must be 'inline' or 'floating'."
+          });
+        }
+      }
+      if (record.floating !== void 0) {
+        validateFloatingImageProperties(record.floating, `${path}.floating`, issues);
+      }
+      return;
+    case "opaque_inline":
+    case "opaque_block":
+      expectDomainString(record.fragmentId, "fragmentId", `${path}.fragmentId`, issues);
+      expectDomainString(record.warningId, "warningId", `${path}.warningId`, issues);
+      if (record.rawXml !== void 0) {
+        expectString(record.rawXml, `${path}.rawXml`, issues);
+      }
+      return;
+    case "table":
+      if (!Array.isArray(record.gridColumns)) {
+        issues.push({ path: `${path}.gridColumns`, message: "gridColumns must be an array." });
+      }
+      if (!Array.isArray(record.rows)) {
+        issues.push({ path: `${path}.rows`, message: "rows must be an array." });
+      } else {
+        record.rows.forEach(
+          (row, rowIndex) => validateDocumentNode(row, `${path}.rows[${rowIndex}]`, issues)
+        );
+      }
+      return;
+    case "table_row":
+      if (!Array.isArray(record.cells)) {
+        issues.push({ path: `${path}.cells`, message: "cells must be an array." });
+      } else {
+        record.cells.forEach(
+          (cell, cellIndex) => validateDocumentNode(cell, `${path}.cells[${cellIndex}]`, issues)
+        );
+      }
+      return;
+    case "table_cell":
+      if (!Array.isArray(record.children)) {
+        issues.push({ path: `${path}.children`, message: "children must be an array." });
+      } else {
+        record.children.forEach(
+          (child, childIndex) => validateDocumentNode(child, `${path}.children[${childIndex}]`, issues)
+        );
+      }
+      return;
+    case "field":
+      expectString(record.fieldType, `${path}.fieldType`, issues);
+      expectString(record.instruction, `${path}.instruction`, issues);
+      if (!Array.isArray(record.children)) {
+        issues.push({ path: `${path}.children`, message: "children must be an array." });
+      } else {
+        record.children.forEach(
+          (child, index) => validateDocumentNode(child, `${path}.children[${index}]`, issues)
+        );
+      }
+      return;
+    case "bookmark_start":
+      expectString(record.bookmarkId, `${path}.bookmarkId`, issues);
+      expectString(record.name, `${path}.name`, issues);
+      return;
+    case "bookmark_end":
+      expectString(record.bookmarkId, `${path}.bookmarkId`, issues);
+      return;
+    case "section_break":
+      return;
+    case "text":
+      if (typeof record.text !== "string") {
+        issues.push({
+          path: `${path}.text`,
+          message: "text must be a string."
+        });
+      }
+      return;
+    case "hard_break":
+    case "column_break":
+    case "tab":
+      return;
+    case "symbol":
+      expectString(record.char, `${path}.char`, issues);
+      if (record.font !== void 0) {
+        expectString(record.font, `${path}.font`, issues);
+      }
+      return;
+    case "footnote_ref":
+      expectString(record.noteId, `${path}.noteId`, issues);
+      if (record.noteKind !== "footnote" && record.noteKind !== "endnote") {
+        issues.push({
+          path: `${path}.noteKind`,
+          message: "noteKind must be 'footnote' or 'endnote'."
+        });
+      }
+      return;
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+      expectString(record.rawXml, `${path}.rawXml`, issues);
+      return;
+    default:
+      issues.push({
+        path: `${path}.type`,
+        message: `Unsupported node type ${JSON.stringify(type)}.`
+      });
+  }
+}
+function validateFloatingImageProperties(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.horizontalPosition !== void 0) {
+    validateFloatingAxisPosition(record.horizontalPosition, `${path}.horizontalPosition`, issues);
+  }
+  if (record.verticalPosition !== void 0) {
+    validateFloatingAxisPosition(record.verticalPosition, `${path}.verticalPosition`, issues);
+  }
+  if (record.wrap !== void 0) {
+    const wrap = expectString(record.wrap, `${path}.wrap`, issues);
+    if (wrap && wrap !== "none" && wrap !== "square" && wrap !== "tight" && wrap !== "through" && wrap !== "topAndBottom") {
+      issues.push({
+        path: `${path}.wrap`,
+        message: "wrap must be one of none, square, tight, through, or topAndBottom."
+      });
+    }
+  }
+}
+function validateFloatingAxisPosition(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.relativeFrom !== void 0) {
+    expectString(record.relativeFrom, `${path}.relativeFrom`, issues);
+  }
+  if (record.align !== void 0) {
+    expectString(record.align, `${path}.align`, issues);
+  }
+  if (record.offset !== void 0 && typeof record.offset !== "number") {
+    issues.push({
+      path: `${path}.offset`,
+      message: "offset must be a number."
+    });
+  }
+}
+function validateReviewStore(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const comments = asPlainObject(record.comments, `${path}.comments`, issues);
+  if (comments) {
+    for (const [commentId, thread] of Object.entries(comments)) {
+      expectDomainString(commentId, "commentId", `${path}.comments.${commentId}`, issues);
+      const threadRecord = asPlainObject(thread, `${path}.comments.${commentId}`, issues);
+      if (!threadRecord) {
+        continue;
+      }
+      if (threadRecord.commentId !== commentId) {
+        issues.push({
+          path: `${path}.comments.${commentId}.commentId`,
+          message: "commentId must match the map key."
+        });
+      }
+      validateAnchor(threadRecord.anchor, `${path}.comments.${commentId}.anchor`, issues);
+      expectIso8601UtcTimestamp(
+        threadRecord.createdAt,
+        `${path}.comments.${commentId}.createdAt`,
+        issues
+      );
+      validateCommentStatus(threadRecord.status, `${path}.comments.${commentId}.status`, issues);
+      if (threadRecord.createdBy !== void 0) {
+        expectString(
+          threadRecord.createdBy,
+          `${path}.comments.${commentId}.createdBy`,
+          issues
+        );
+      }
+      if (threadRecord.authorId !== void 0) {
+        expectString(
+          threadRecord.authorId,
+          `${path}.comments.${commentId}.authorId`,
+          issues
+        );
+      }
+      if (threadRecord.body !== void 0) {
+        expectStringAllowEmpty(
+          threadRecord.body,
+          `${path}.comments.${commentId}.body`,
+          issues
+        );
+      }
+      if (!Array.isArray(threadRecord.warningIds)) {
+        issues.push({
+          path: `${path}.comments.${commentId}.warningIds`,
+          message: "warningIds must be an array."
+        });
+      } else {
+        threadRecord.warningIds.forEach(
+          (warningId, index) => expectDomainString(
+            warningId,
+            "warningId",
+            `${path}.comments.${commentId}.warningIds[${index}]`,
+            issues
+          )
+        );
+      }
+      if (threadRecord.entries !== void 0) {
+        validateCommentEntries(
+          threadRecord.entries,
+          `${path}.comments.${commentId}.entries`,
+          issues
+        );
+      }
+      if (threadRecord.resolution !== void 0) {
+        validateCommentResolution(
+          threadRecord.resolution,
+          `${path}.comments.${commentId}.resolution`,
+          issues
+        );
+      }
+      if (threadRecord.resolvedAt !== void 0) {
+        expectIso8601UtcTimestamp(
+          threadRecord.resolvedAt,
+          `${path}.comments.${commentId}.resolvedAt`,
+          issues
+        );
+      }
+      if (threadRecord.isResolved !== void 0 && typeof threadRecord.isResolved !== "boolean") {
+        issues.push({
+          path: `${path}.comments.${commentId}.isResolved`,
+          message: "isResolved must be a boolean."
+        });
+      }
+      if (threadRecord.metadata !== void 0) {
+        validateCommentThreadMetadata(
+          threadRecord.metadata,
+          `${path}.comments.${commentId}.metadata`,
+          issues
+        );
+      }
+    }
+  }
+  const revisions = asPlainObject(record.revisions, `${path}.revisions`, issues);
+  if (revisions) {
+    for (const [revisionId, revision] of Object.entries(revisions)) {
+      expectDomainString(revisionId, "revisionId", `${path}.revisions.${revisionId}`, issues);
+      const revisionRecord = asPlainObject(
+        revision,
+        `${path}.revisions.${revisionId}`,
+        issues
+      );
+      if (!revisionRecord) {
+        continue;
+      }
+      if (revisionRecord.changeId !== revisionId) {
+        issues.push({
+          path: `${path}.revisions.${revisionId}.changeId`,
+          message: "changeId must match the map key."
+        });
+      }
+      validateAnchor(revisionRecord.anchor, `${path}.revisions.${revisionId}.anchor`, issues);
+      validateRevisionKind(revisionRecord.kind, `${path}.revisions.${revisionId}.kind`, issues);
+      validateRevisionStatus(
+        revisionRecord.status,
+        `${path}.revisions.${revisionId}.status`,
+        issues
+      );
+      expectIso8601UtcTimestamp(
+        revisionRecord.createdAt,
+        `${path}.revisions.${revisionId}.createdAt`,
+        issues
+      );
+      if (revisionRecord.authorId !== void 0) {
+        expectString(
+          revisionRecord.authorId,
+          `${path}.revisions.${revisionId}.authorId`,
+          issues
+        );
+      }
+      if (revisionRecord.warningIds !== void 0) {
+        validateWarningIds(
+          revisionRecord.warningIds,
+          `${path}.revisions.${revisionId}.warningIds`,
+          issues
+        );
+      }
+      if (revisionRecord.metadata !== void 0) {
+        validateRevisionMetadata(
+          revisionRecord.metadata,
+          `${path}.revisions.${revisionId}.metadata`,
+          issues
+        );
+      }
+    }
+  }
+}
+function validateCommentStatus(value, path, issues) {
+  if (value === "open" || value === "resolved" || value === "detached") {
+    return;
+  }
+  issues.push({
+    path,
+    message: "status must be one of open, resolved, or detached."
+  });
+}
+function validateCommentEntries(value, path, issues) {
+  if (!Array.isArray(value)) {
+    issues.push({
+      path,
+      message: "entries must be an array."
+    });
+    return;
+  }
+  value.forEach((entry, index) => {
+    const record = asPlainObject(entry, `${path}[${index}]`, issues);
+    if (!record) {
+      return;
+    }
+    expectString(record.entryId, `${path}[${index}].entryId`, issues);
+    expectString(record.authorId, `${path}[${index}].authorId`, issues);
+    expectStringAllowEmpty(record.body, `${path}[${index}].body`, issues);
+    expectIso8601UtcTimestamp(record.createdAt, `${path}[${index}].createdAt`, issues);
+    if (record.metadata !== void 0) {
+      validateCommentEntryMetadata(record.metadata, `${path}[${index}].metadata`, issues);
+    }
+  });
+}
+function validateCommentEntryMetadata(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  for (const field of [
+    "ooxmlCommentId",
+    "paraId",
+    "parentParaId",
+    "durableId",
+    "initials"
+  ]) {
+    if (record[field] !== void 0) {
+      expectString(record[field], `${path}.${field}`, issues);
+    }
+  }
+}
+function validateCommentResolution(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectIso8601UtcTimestamp(record.resolvedAt, `${path}.resolvedAt`, issues);
+  expectString(record.resolvedBy, `${path}.resolvedBy`, issues);
+}
+function validateCommentThreadMetadata(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.source !== void 0 && record.source !== "runtime" && record.source !== "import") {
+    issues.push({
+      path: `${path}.source`,
+      message: "source must be either runtime or import."
+    });
+  }
+  if (record.rootOoxmlCommentId !== void 0) {
+    expectString(record.rootOoxmlCommentId, `${path}.rootOoxmlCommentId`, issues);
+  }
+  if (record.rootParaId !== void 0) {
+    expectString(record.rootParaId, `${path}.rootParaId`, issues);
+  }
+}
+function validateRevisionKind(value, path, issues) {
+  if (value === "insertion" || value === "deletion" || value === "formatting" || value === "move" || value === "property-change") {
+    return;
+  }
+  issues.push({
+    path,
+    message: "kind must be insertion, deletion, formatting, move, or property-change."
+  });
+}
+function validateRevisionStatus(value, path, issues) {
+  if (value === "open" || value === "accepted" || value === "rejected" || value === "detached") {
+    return;
+  }
+  issues.push({
+    path,
+    message: "status must be one of open, accepted, rejected, or detached."
+  });
+}
+function validateWarningIds(value, path, issues) {
+  if (!Array.isArray(value)) {
+    issues.push({
+      path,
+      message: "warningIds must be an array."
+    });
+    return;
+  }
+  value.forEach(
+    (warningId, index) => expectDomainString(warningId, "warningId", `${path}[${index}]`, issues)
+  );
+}
+function validateRevisionMetadata(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.source !== void 0 && record.source !== "runtime" && record.source !== "import") {
+    issues.push({
+      path: `${path}.source`,
+      message: "source must be either runtime or import."
+    });
+  }
+  for (const field of [
+    "preserveOnlyReason",
+    "importedRevisionForm",
+    "originalRevisionType",
+    "ooxmlRevisionId"
+  ]) {
+    if (record[field] !== void 0) {
+      expectString(record[field], `${path}.${field}`, issues);
+    }
+  }
+  if (record.propertyChangeData !== void 0) {
+    const pcd = asPlainObject(record.propertyChangeData, `${path}.propertyChangeData`, issues);
+    if (pcd) {
+      expectString(pcd.xmlTag, `${path}.propertyChangeData.xmlTag`, issues);
+      expectString(pcd.beforeXml, `${path}.propertyChangeData.beforeXml`, issues);
+    }
+  }
+  if (record.moveData !== void 0) {
+    const md = asPlainObject(record.moveData, `${path}.moveData`, issues);
+    if (md) {
+      expectString(md.moveId, `${path}.moveData.moveId`, issues);
+      expectString(md.direction, `${path}.moveData.direction`, issues);
+    }
+  }
+}
+function validatePreservationStore(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const opaqueFragments = asPlainObject(
+    record.opaqueFragments,
+    `${path}.opaqueFragments`,
+    issues
+  );
+  if (opaqueFragments) {
+    for (const [fragmentId, fragment] of Object.entries(opaqueFragments)) {
+      expectDomainString(fragmentId, "fragmentId", `${path}.opaqueFragments.${fragmentId}`, issues);
+      const fragmentRecord = asPlainObject(
+        fragment,
+        `${path}.opaqueFragments.${fragmentId}`,
+        issues
+      );
+      if (!fragmentRecord) {
+        continue;
+      }
+      if (fragmentRecord.fragmentId !== fragmentId) {
+        issues.push({
+          path: `${path}.opaqueFragments.${fragmentId}.fragmentId`,
+          message: "fragmentId must match the map key."
+        });
+      }
+      validateRange(
+        fragmentRecord.lastKnownRange,
+        `${path}.opaqueFragments.${fragmentId}.lastKnownRange`,
+        issues
+      );
+      expectDomainString(
+        fragmentRecord.warningId,
+        "warningId",
+        `${path}.opaqueFragments.${fragmentId}.warningId`,
+        issues
+      );
+      if (fragmentRecord.packagePartName !== void 0) {
+        expectDomainString(
+          fragmentRecord.packagePartName,
+          "packagePartName",
+          `${path}.opaqueFragments.${fragmentId}.packagePartName`,
+          issues
+        );
+      }
+      if (fragmentRecord.relationshipId !== void 0) {
+        expectDomainString(
+          fragmentRecord.relationshipId,
+          "relationshipId",
+          `${path}.opaqueFragments.${fragmentId}.relationshipId`,
+          issues
+        );
+      }
+    }
+  }
+  const packageParts = asPlainObject(record.packageParts, `${path}.packageParts`, issues);
+  if (packageParts) {
+    for (const [packagePartName, packagePart] of Object.entries(packageParts)) {
+      expectDomainString(
+        packagePartName,
+        "packagePartName",
+        `${path}.packageParts.${packagePartName}`,
+        issues
+      );
+      const packagePartRecord = asPlainObject(
+        packagePart,
+        `${path}.packageParts.${packagePartName}`,
+        issues
+      );
+      if (!packagePartRecord) {
+        continue;
+      }
+      if (packagePartRecord.packagePartName !== packagePartName) {
+        issues.push({
+          path: `${path}.packageParts.${packagePartName}.packagePartName`,
+          message: "packagePartName must match the map key."
+        });
+      }
+      if (Array.isArray(packagePartRecord.relationshipIds)) {
+        packagePartRecord.relationshipIds.forEach(
+          (relationshipId, index) => expectDomainString(
+            relationshipId,
+            "relationshipId",
+            `${path}.packageParts.${packagePartName}.relationshipIds[${index}]`,
+            issues
+          )
+        );
+      }
+    }
+  }
+}
+function validateDiagnosticStore(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (Array.isArray(record.warnings)) {
+    record.warnings.forEach((warning, index) => {
+      const warningRecord = asPlainObject(warning, `${path}.warnings[${index}]`, issues);
+      if (!warningRecord) {
+        return;
+      }
+      expectDomainString(
+        warningRecord.diagnosticId,
+        "diagnosticId",
+        `${path}.warnings[${index}].diagnosticId`,
+        issues
+      );
+      expectDomainString(
+        warningRecord.warningId,
+        "warningId",
+        `${path}.warnings[${index}].warningId`,
+        issues
+      );
+    });
+  }
+  if (Array.isArray(record.errors)) {
+    record.errors.forEach((error, index) => {
+      const errorRecord = asPlainObject(error, `${path}.errors[${index}]`, issues);
+      if (!errorRecord) {
+        return;
+      }
+      expectDomainString(
+        errorRecord.diagnosticId,
+        "diagnosticId",
+        `${path}.errors[${index}].diagnosticId`,
+        issues
+      );
+    });
+  }
+}
+function validateAnchor(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const kind = expectString(record.kind, `${path}.kind`, issues);
+  if (!kind) {
+    return;
+  }
+  if (kind === "range") {
+    validateRange(record.range, `${path}.range`, issues);
+    validateBoundaryAssoc(record.assoc, `${path}.assoc`, issues);
+  } else if (kind === "node") {
+    if (typeof record.at !== "number") {
+      issues.push({
+        path: `${path}.at`,
+        message: "node anchors must contain a numeric at value."
+      });
+    }
+    if (record.assoc !== -1 && record.assoc !== 1) {
+      issues.push({
+        path: `${path}.assoc`,
+        message: "node anchor assoc must be -1 or 1."
+      });
+    }
+  } else if (kind === "detached") {
+    validateRange(record.lastKnownRange, `${path}.lastKnownRange`, issues);
+    if (record.reason !== "deleted" && record.reason !== "invalidatedByStructureChange" && record.reason !== "importAmbiguity") {
+      issues.push({
+        path: `${path}.reason`,
+        message: "detached anchor reason must be deleted, invalidatedByStructureChange, or importAmbiguity."
+      });
+    }
+  } else {
+    issues.push({
+      path: `${path}.kind`,
+      message: "anchor kind must be range, node, or detached."
+    });
+  }
+}
+function validateBoundaryAssoc(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.start !== -1 && record.start !== 1) {
+    issues.push({
+      path: `${path}.start`,
+      message: "assoc.start must be -1 or 1."
+    });
+  }
+  if (record.end !== -1 && record.end !== 1) {
+    issues.push({
+      path: `${path}.end`,
+      message: "assoc.end must be -1 or 1."
+    });
+  }
+}
+function validateDocumentReferences(record, issues) {
+  const paragraphStyleIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.styles, "$.styles", [])?.paragraphs, "$.styles.paragraphs", []) ?? {})
+  );
+  const numberingInstanceIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.numbering, "$.numbering", [])?.instances, "$.numbering.instances", []) ?? {})
+  );
+  const abstractNumberingIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.numbering, "$.numbering", [])?.abstractDefinitions, "$.numbering.abstractDefinitions", []) ?? {})
+  );
+  const mediaIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.media, "$.media", [])?.items, "$.media.items", []) ?? {})
+  );
+  const warningIds = new Set(
+    (Array.isArray(asPlainObject(record.diagnostics, "$.diagnostics", [])?.warnings) ? asPlainObject(record.diagnostics, "$.diagnostics", [])?.warnings : []).flatMap((warning) => typeof warning.warningId === "string" ? [warning.warningId] : [])
+  );
+  const fragmentIds = new Set(
+    Object.keys(asPlainObject(asPlainObject(record.preservation, "$.preservation", [])?.opaqueFragments, "$.preservation.opaqueFragments", []) ?? {})
+  );
+  const noteIds = collectNoteIds(record);
+  const numberingInstances = asPlainObject(
+    asPlainObject(record.numbering, "$.numbering", [])?.instances,
+    "$.numbering.instances",
+    []
+  );
+  if (numberingInstances) {
+    for (const [instanceId, instance] of Object.entries(numberingInstances)) {
+      const instanceRecord = asPlainObject(instance, `$.numbering.instances.${instanceId}`, []);
+      if (instanceRecord && typeof instanceRecord.abstractNumberingId === "string" && !abstractNumberingIds.has(instanceRecord.abstractNumberingId)) {
+        issues.push({
+          path: `$.numbering.instances.${instanceId}.abstractNumberingId`,
+          message: "abstractNumberingId must reference an existing abstract numbering definition."
+        });
+      }
+    }
+  }
+  validateDocumentNodeReferences(record.content, "$.content", issues, {
+    paragraphStyleIds,
+    numberingInstanceIds,
+    mediaIds,
+    warningIds,
+    fragmentIds,
+    noteIds
+  });
+  validateSubPartReferences(record.subParts, "$.subParts", issues, {
+    paragraphStyleIds,
+    numberingInstanceIds,
+    mediaIds,
+    warningIds,
+    fragmentIds,
+    noteIds
+  });
+  validateReviewReferences(record.review, "$.review", issues, warningIds);
+}
+function validateDocumentNodeReferences(value, path, issues, references) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const type = typeof record.type === "string" ? record.type : void 0;
+  if (type === "paragraph") {
+    if (typeof record.styleId === "string" && !references.paragraphStyleIds.has(record.styleId)) {
+      issues.push({
+        path: `${path}.styleId`,
+        message: "styleId must reference an existing paragraph style definition."
+      });
+    }
+    const numbering = asPlainObject(record.numbering, `${path}.numbering`, []);
+    if (numbering && typeof numbering.numberingInstanceId === "string" && !references.numberingInstanceIds.has(numbering.numberingInstanceId)) {
+      issues.push({
+        path: `${path}.numbering.numberingInstanceId`,
+        message: "numberingInstanceId must reference an existing numbering instance."
+      });
+    }
+  } else if (type === "image") {
+    if (typeof record.mediaId === "string" && !references.mediaIds.has(record.mediaId)) {
+      issues.push({
+        path: `${path}.mediaId`,
+        message: "mediaId must reference an existing media catalog item."
+      });
+    }
+  } else if (type === "opaque_inline" || type === "opaque_block") {
+    if (typeof record.fragmentId === "string" && !references.fragmentIds.has(record.fragmentId)) {
+      issues.push({
+        path: `${path}.fragmentId`,
+        message: "fragmentId must reference an existing opaque fragment."
+      });
+    }
+    if (typeof record.warningId === "string" && !references.warningIds.has(record.warningId)) {
+      issues.push({
+        path: `${path}.warningId`,
+        message: "warningId must reference an existing diagnostic warning."
+      });
+    }
+  } else if (type === "footnote_ref") {
+    if (typeof record.noteId === "string" && !references.noteIds.has(`${record.noteKind}:${record.noteId}`)) {
+      issues.push({
+        path: `${path}.noteId`,
+        message: "noteId must reference an existing footnote or endnote definition."
+      });
+    }
+  }
+  if (Array.isArray(record.children)) {
+    record.children.forEach(
+      (child, index) => validateDocumentNodeReferences(child, `${path}.children[${index}]`, issues, references)
+    );
+  }
+  if (Array.isArray(record.rows)) {
+    record.rows.forEach(
+      (row, index) => validateDocumentNodeReferences(row, `${path}.rows[${index}]`, issues, references)
+    );
+  }
+  if (Array.isArray(record.cells)) {
+    record.cells.forEach(
+      (cell, index) => validateDocumentNodeReferences(cell, `${path}.cells[${index}]`, issues, references)
+    );
+  }
+}
+function validateReviewReferences(value, path, issues, warningIds) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const comments = asPlainObject(record.comments, `${path}.comments`, []);
+  if (comments) {
+    for (const [commentId, thread] of Object.entries(comments)) {
+      const threadRecord = asPlainObject(thread, `${path}.comments.${commentId}`, []);
+      if (!threadRecord || !Array.isArray(threadRecord.warningIds)) {
+        continue;
+      }
+      threadRecord.warningIds.forEach((warningId, index) => {
+        if (typeof warningId === "string" && !warningIds.has(warningId)) {
+          issues.push({
+            path: `${path}.comments.${commentId}.warningIds[${index}]`,
+            message: "warningIds must reference existing diagnostic warnings."
+          });
+        }
+      });
+    }
+  }
+  const revisions = asPlainObject(record.revisions, `${path}.revisions`, []);
+  if (revisions) {
+    for (const [revisionId, revision] of Object.entries(revisions)) {
+      const revisionRecord = asPlainObject(revision, `${path}.revisions.${revisionId}`, []);
+      if (!revisionRecord || !Array.isArray(revisionRecord.warningIds)) {
+        continue;
+      }
+      revisionRecord.warningIds.forEach((warningId, index) => {
+        if (typeof warningId === "string" && !warningIds.has(warningId)) {
+          issues.push({
+            path: `${path}.revisions.${revisionId}.warningIds[${index}]`,
+            message: "warningIds must reference existing diagnostic warnings."
+          });
+        }
+      });
+    }
+  }
+}
+function validateSubPartReferences(value, path, issues, references) {
+  if (value === void 0) {
+    return;
+  }
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  const headers = Array.isArray(record.headers) ? record.headers : [];
+  headers.forEach((header, index) => {
+    const headerRecord = asPlainObject(header, `${path}.headers[${index}]`, []);
+    if (!headerRecord || !Array.isArray(headerRecord.blocks)) {
+      return;
+    }
+    headerRecord.blocks.forEach(
+      (block, blockIndex) => validateDocumentNodeReferences(block, `${path}.headers[${index}].blocks[${blockIndex}]`, issues, references)
+    );
+  });
+  const footers = Array.isArray(record.footers) ? record.footers : [];
+  footers.forEach((footer, index) => {
+    const footerRecord = asPlainObject(footer, `${path}.footers[${index}]`, []);
+    if (!footerRecord || !Array.isArray(footerRecord.blocks)) {
+      return;
+    }
+    footerRecord.blocks.forEach(
+      (block, blockIndex) => validateDocumentNodeReferences(block, `${path}.footers[${index}].blocks[${blockIndex}]`, issues, references)
+    );
+  });
+  if (record.footnoteCollection !== void 0) {
+    const footnoteCollection = asPlainObject(record.footnoteCollection, `${path}.footnoteCollection`, []);
+    const footnotes = asPlainObject(footnoteCollection?.footnotes, `${path}.footnoteCollection.footnotes`, []);
+    if (footnotes) {
+      for (const [noteId, note] of Object.entries(footnotes)) {
+        const noteRecord = asPlainObject(note, `${path}.footnoteCollection.footnotes.${noteId}`, []);
+        if (!noteRecord || !Array.isArray(noteRecord.blocks)) {
+          continue;
+        }
+        noteRecord.blocks.forEach(
+          (block, blockIndex) => validateDocumentNodeReferences(
+            block,
+            `${path}.footnoteCollection.footnotes.${noteId}.blocks[${blockIndex}]`,
+            issues,
+            references
+          )
+        );
+      }
+    }
+    const endnotes = asPlainObject(footnoteCollection?.endnotes, `${path}.footnoteCollection.endnotes`, []);
+    if (endnotes) {
+      for (const [noteId, note] of Object.entries(endnotes)) {
+        const noteRecord = asPlainObject(note, `${path}.footnoteCollection.endnotes.${noteId}`, []);
+        if (!noteRecord || !Array.isArray(noteRecord.blocks)) {
+          continue;
+        }
+        noteRecord.blocks.forEach(
+          (block, blockIndex) => validateDocumentNodeReferences(
+            block,
+            `${path}.footnoteCollection.endnotes.${noteId}.blocks[${blockIndex}]`,
+            issues,
+            references
+          )
+        );
+      }
+    }
+  }
+}
+function collectNoteIds(record) {
+  const noteIds = /* @__PURE__ */ new Set();
+  const subParts = asPlainObject(record.subParts, "$.subParts", []);
+  const footnoteCollection = asPlainObject(subParts?.footnoteCollection, "$.subParts.footnoteCollection", []);
+  const footnotes = asPlainObject(footnoteCollection?.footnotes, "$.subParts.footnoteCollection.footnotes", []);
+  if (footnotes) {
+    Object.keys(footnotes).forEach((noteId) => noteIds.add(`footnote:${noteId}`));
+  }
+  const endnotes = asPlainObject(footnoteCollection?.endnotes, "$.subParts.footnoteCollection.endnotes", []);
+  if (endnotes) {
+    Object.keys(endnotes).forEach((noteId) => noteIds.add(`endnote:${noteId}`));
+  }
+  return noteIds;
+}
+function validateRange(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (typeof record.from !== "number" || typeof record.to !== "number") {
+    issues.push({
+      path,
+      message: "Range must contain numeric from and to values."
+    });
+  }
+}
+function validateExactObjectKeys(record, expectedKeys, path, issues, allowedOptionalKeys) {
+  const actualKeys = new Set(Object.keys(record));
+  const expected = new Set(expectedKeys);
+  const optional = new Set(allowedOptionalKeys ?? []);
+  for (const expectedKey of expectedKeys) {
+    if (!actualKeys.has(expectedKey)) {
+      issues.push({
+        path,
+        message: `Missing required key ${JSON.stringify(expectedKey)}.`
+      });
+    }
+  }
+  for (const actualKey of actualKeys) {
+    if (!expected.has(actualKey) && !optional.has(actualKey)) {
+      issues.push({
+        path: `${path}.${actualKey}`,
+        message: "Unexpected canonical document key. Render/UI state is not part of the canonical envelope."
+      });
+    }
+  }
+}
+function validateSubPartsCatalog(value, path, issues) {
+  if (value === void 0) {
+    return;
+  }
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (record.headers !== void 0) {
+    if (!Array.isArray(record.headers)) {
+      issues.push({ path: `${path}.headers`, message: "headers must be an array." });
+    } else {
+      record.headers.forEach((header, index) => {
+        const headerRecord = asPlainObject(header, `${path}.headers[${index}]`, issues);
+        if (headerRecord) {
+          expectString(headerRecord.variant, `${path}.headers[${index}].variant`, issues);
+          expectString(headerRecord.partPath, `${path}.headers[${index}].partPath`, issues);
+          expectString(headerRecord.relationshipId, `${path}.headers[${index}].relationshipId`, issues);
+          if (!Array.isArray(headerRecord.blocks)) {
+            issues.push({ path: `${path}.headers[${index}].blocks`, message: "blocks must be an array." });
+          } else {
+            headerRecord.blocks.forEach(
+              (block, blockIndex) => validateDocumentNode(block, `${path}.headers[${index}].blocks[${blockIndex}]`, issues)
+            );
+          }
+        }
+      });
+    }
+  }
+  if (record.footers !== void 0) {
+    if (!Array.isArray(record.footers)) {
+      issues.push({ path: `${path}.footers`, message: "footers must be an array." });
+    } else {
+      record.footers.forEach((footer, index) => {
+        const footerRecord = asPlainObject(footer, `${path}.footers[${index}]`, issues);
+        if (footerRecord) {
+          expectString(footerRecord.variant, `${path}.footers[${index}].variant`, issues);
+          expectString(footerRecord.partPath, `${path}.footers[${index}].partPath`, issues);
+          expectString(footerRecord.relationshipId, `${path}.footers[${index}].relationshipId`, issues);
+          if (!Array.isArray(footerRecord.blocks)) {
+            issues.push({ path: `${path}.footers[${index}].blocks`, message: "blocks must be an array." });
+          } else {
+            footerRecord.blocks.forEach(
+              (block, blockIndex) => validateDocumentNode(block, `${path}.footers[${index}].blocks[${blockIndex}]`, issues)
+            );
+          }
+        }
+      });
+    }
+  }
+  if (record.footnoteCollection !== void 0) {
+    const footnoteCollection = asPlainObject(record.footnoteCollection, `${path}.footnoteCollection`, issues);
+    if (footnoteCollection) {
+      validateSubPartNoteMap(footnoteCollection.footnotes, "footnote", `${path}.footnoteCollection.footnotes`, issues);
+      validateSubPartNoteMap(footnoteCollection.endnotes, "endnote", `${path}.footnoteCollection.endnotes`, issues);
+    }
+  }
+}
+function validateSubPartNoteMap(value, expectedKind, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  for (const [noteId, note] of Object.entries(record)) {
+    const noteRecord = asPlainObject(note, `${path}.${noteId}`, issues);
+    if (!noteRecord) {
+      continue;
+    }
+    expectString(noteRecord.noteId, `${path}.${noteId}.noteId`, issues);
+    if (noteRecord.noteId !== noteId) {
+      issues.push({
+        path: `${path}.${noteId}.noteId`,
+        message: "noteId must match the map key."
+      });
+    }
+    if (noteRecord.kind !== expectedKind) {
+      issues.push({
+        path: `${path}.${noteId}.kind`,
+        message: `kind must be ${expectedKind}.`
+      });
+    }
+    if (!Array.isArray(noteRecord.blocks)) {
+      issues.push({ path: `${path}.${noteId}.blocks`, message: "blocks must be an array." });
+    } else {
+      noteRecord.blocks.forEach(
+        (block, blockIndex) => validateDocumentNode(block, `${path}.${noteId}.blocks[${blockIndex}]`, issues)
+      );
+    }
+  }
+}
+function expectDomainString(value, domain, path, issues) {
+  const stableId = expectString(value, path, issues);
+  if (!stableId) {
+    return null;
+  }
+  if (!ID_PATTERNS[domain].test(stableId)) {
+    issues.push({
+      path,
+      message: `Expected a valid ${domain}.`
+    });
+    return null;
+  }
+  return stableId;
+}
+
+// src/model/snapshot.ts
+var SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS = [
+  "snapshotVersion",
+  "schemaVersion",
+  "documentId",
+  "docId",
+  "createdAt",
+  "updatedAt",
+  "savedAt",
+  "editorBuild",
+  "canonicalDocument",
+  "compatibility",
+  "warningLog"
+];
+var SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS = ["sourcePackage", "protectionSnapshot"];
+var PERSISTED_EDITOR_SNAPSHOT_VERSIONS = /* @__PURE__ */ new Set([
+  LEGACY_PERSISTED_EDITOR_SNAPSHOT_VERSION,
+  PERSISTED_EDITOR_SNAPSHOT_VERSION
+]);
+var DOCX_SOURCE_PACKAGE_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var COMPATIBILITY_FEATURE_CLASSES = /* @__PURE__ */ new Set([
+  "supported-roundtrip",
+  "preserve-only",
+  "unsupported-fatal"
+]);
+var EDITOR_WARNING_CODES = /* @__PURE__ */ new Set([
+  "unsupported_ooxml_preserved",
+  "unsupported_ooxml_locked",
+  "import_normalized",
+  "export_roundtrip_risk",
+  "comment_anchor_detached",
+  "revision_anchor_detached",
+  "large_document_degraded",
+  "font_substitution",
+  "image_missing"
+]);
+var EDITOR_WARNING_SEVERITIES = /* @__PURE__ */ new Set(["info", "warning"]);
+var EDITOR_WARNING_SOURCES = /* @__PURE__ */ new Set([
+  "import",
+  "runtime",
+  "review",
+  "preservation",
+  "validation",
+  "export"
+]);
+var EDITOR_ERROR_CODES = /* @__PURE__ */ new Set([
+  "import_failed",
+  "export_failed",
+  "package_corrupt",
+  "validation_failed",
+  "datastore_failed",
+  "internal_invariant"
+]);
+var EDITOR_ERROR_SOURCES = /* @__PURE__ */ new Set([
+  "import",
+  "runtime",
+  "validation",
+  "datastore",
+  "host",
+  "export"
+]);
+function assertPersistedEditorSnapshot(snapshot) {
+  const issues = validatePersistedEditorSnapshot(snapshot);
+  assertValid(issues, "Invalid persisted editor snapshot.");
+}
+function validatePersistedEditorSnapshot(snapshot) {
+  const issues = [];
+  const record = asPlainObject(snapshot, "$", issues);
+  if (!record) {
+    return issues;
+  }
+  validateExactObjectKeys2(
+    record,
+    SNAPSHOT_REQUIRED_TOP_LEVEL_KEYS,
+    SNAPSHOT_OPTIONAL_TOP_LEVEL_KEYS,
+    "$",
+    issues
+  );
+  validateSnapshotVersion(record.snapshotVersion, "$.snapshotVersion", issues);
+  expectExactString(
+    record.schemaVersion,
+    CDS_SCHEMA_VERSION,
+    "$.schemaVersion",
+    issues
+  );
+  expectString(record.documentId, "$.documentId", issues);
+  expectString(record.docId, "$.docId", issues);
+  expectIso8601UtcTimestamp(record.createdAt, "$.createdAt", issues);
+  expectIso8601UtcTimestamp(record.updatedAt, "$.updatedAt", issues);
+  expectIso8601UtcTimestamp(record.savedAt, "$.savedAt", issues);
+  expectString(record.editorBuild, "$.editorBuild", issues);
+  const canonicalDocumentIssues = validateCanonicalDocument(record.canonicalDocument);
+  issues.push(...canonicalDocumentIssues.map(prefixIssue("$.canonicalDocument")));
+  if (asPlainObject(record.canonicalDocument, "$.canonicalDocument", [])?.docId !== record.docId) {
+    issues.push({
+      path: "$.docId",
+      message: "Snapshot docId must match canonicalDocument.docId."
+    });
+  }
+  validateCompatibilityReport(record.compatibility, "$.compatibility", issues);
+  if (!Array.isArray(record.warningLog)) {
+    issues.push({
+      path: "$.warningLog",
+      message: "warningLog must be an array."
+    });
+  } else {
+    record.warningLog.forEach((warning, index) => {
+      validateEditorWarning(warning, `$.warningLog[${index}]`, issues);
+    });
+  }
+  if (record.sourcePackage !== void 0) {
+    validatePersistedSourcePackage(record.sourcePackage, "$.sourcePackage", issues);
+  }
+  if (record.protectionSnapshot !== void 0) {
+    validateProtectionSnapshot(record.protectionSnapshot, "$.protectionSnapshot", issues);
+  }
+  return issues;
+}
+function assertCompatibilityReport(report) {
+  const issues = validateCompatibilityReport(report);
+  assertValid(issues, "Invalid compatibility report.");
+}
+function validateCompatibilityReport(report, path = "$", issues = []) {
+  const record = asPlainObject(report, path, issues);
+  if (!record) {
+    return issues;
+  }
+  expectExactString(
+    record.reportVersion,
+    COMPATIBILITY_REPORT_VERSION,
+    `${path}.reportVersion`,
+    issues
+  );
+  expectIso8601UtcTimestamp(record.generatedAt, `${path}.generatedAt`, issues);
+  if (typeof record.blockExport !== "boolean") {
+    issues.push({
+      path: `${path}.blockExport`,
+      message: "blockExport must be a boolean."
+    });
+  }
+  if (!Array.isArray(record.featureEntries)) {
+    issues.push({
+      path: `${path}.featureEntries`,
+      message: "featureEntries must be an array."
+    });
+  } else {
+    record.featureEntries.forEach((featureEntry, index) => {
+      validateCompatibilityFeatureEntry(
+        featureEntry,
+        `${path}.featureEntries[${index}]`,
+        issues
+      );
+    });
+  }
+  if (!Array.isArray(record.warnings)) {
+    issues.push({
+      path: `${path}.warnings`,
+      message: "warnings must be an array."
+    });
+  } else {
+    record.warnings.forEach((warning, index) => {
+      validateEditorWarning(warning, `${path}.warnings[${index}]`, issues);
+    });
+  }
+  if (!Array.isArray(record.errors)) {
+    issues.push({
+      path: `${path}.errors`,
+      message: "errors must be an array."
+    });
+  } else {
+    record.errors.forEach((error, index) => {
+      validateEditorError(error, `${path}.errors[${index}]`, issues);
+    });
+  }
+  return issues;
+}
+function validateCompatibilityFeatureEntry(featureEntry, path, issues) {
+  const record = asPlainObject(featureEntry, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.featureEntryId, `${path}.featureEntryId`, issues);
+  expectString(record.featureKey, `${path}.featureKey`, issues);
+  if (typeof record.featureClass !== "string" || !COMPATIBILITY_FEATURE_CLASSES.has(record.featureClass)) {
+    issues.push({
+      path: `${path}.featureClass`,
+      message: "featureClass must be supported-roundtrip, preserve-only, or unsupported-fatal."
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+}
+function validateEditorWarning(warning, path, issues) {
+  const record = asPlainObject(warning, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.warningId, `${path}.warningId`, issues);
+  if (typeof record.code !== "string" || !EDITOR_WARNING_CODES.has(record.code)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_WARNING_CODES])}.`
+    });
+  }
+  if (typeof record.severity !== "string" || !EDITOR_WARNING_SEVERITIES.has(record.severity)) {
+    issues.push({
+      path: `${path}.severity`,
+      message: "severity must be info or warning."
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+  if (typeof record.source !== "string" || !EDITOR_WARNING_SOURCES.has(record.source)) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_WARNING_SOURCES])}.`
+    });
+  }
+}
+function validateEditorError(error, path, issues) {
+  const record = asPlainObject(error, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.errorId, `${path}.errorId`, issues);
+  if (typeof record.code !== "string" || !EDITOR_ERROR_CODES.has(record.code)) {
+    issues.push({
+      path: `${path}.code`,
+      message: `code must be one of ${JSON.stringify([...EDITOR_ERROR_CODES])}.`
+    });
+  }
+  expectString(record.message, `${path}.message`, issues);
+  if (typeof record.source !== "string" || !EDITOR_ERROR_SOURCES.has(record.source)) {
+    issues.push({
+      path: `${path}.source`,
+      message: `source must be one of ${JSON.stringify([...EDITOR_ERROR_SOURCES])}.`
+    });
+  }
+  if (typeof record.isFatal !== "boolean") {
+    issues.push({
+      path: `${path}.isFatal`,
+      message: "isFatal must be a boolean."
+    });
+  }
+}
+function validateExactObjectKeys2(record, requiredKeys, optionalKeys, path, issues) {
+  const actualKeys = new Set(Object.keys(record));
+  const allowedKeys = /* @__PURE__ */ new Set([...requiredKeys, ...optionalKeys]);
+  for (const requiredKey of requiredKeys) {
+    if (!actualKeys.has(requiredKey)) {
+      issues.push({
+        path,
+        message: `Missing required key ${JSON.stringify(requiredKey)}.`
+      });
+    }
+  }
+  for (const actualKey of actualKeys) {
+    if (!allowedKeys.has(actualKey)) {
+      issues.push({
+        path: `${path}.${actualKey}`,
+        message: "Unexpected persisted snapshot key. Render/UI state is not part of the persistence contract."
+      });
+    }
+  }
+}
+function prefixIssue(basePath) {
+  return (issue) => ({
+    path: `${basePath}${issue.path === "$" ? "" : issue.path.slice(1)}`,
+    message: issue.message
+  });
+}
+function validateSnapshotVersion(value, path, issues) {
+  if (typeof value !== "string" || !PERSISTED_EDITOR_SNAPSHOT_VERSIONS.has(value)) {
+    issues.push({
+      path,
+      message: `Expected one of ${JSON.stringify([...PERSISTED_EDITOR_SNAPSHOT_VERSIONS])}.`
+    });
+    return null;
+  }
+  return value;
+}
+function validatePersistedSourcePackage(sourcePackage, path, issues) {
+  const record = asPlainObject(sourcePackage, path, issues);
+  if (!record) {
+    return;
+  }
+  validateExactObjectKeys2(
+    record,
+    ["format", "storage", "mimeType", "sha256Hex", "bytesBase64"],
+    ["sourceLabel"],
+    path,
+    issues
+  );
+  expectExactString(record.format, "docx", `${path}.format`, issues);
+  expectExactString(record.storage, "embedded-base64", `${path}.storage`, issues);
+  expectExactString(
+    record.mimeType,
+    DOCX_SOURCE_PACKAGE_MIME_TYPE,
+    `${path}.mimeType`,
+    issues
+  );
+  expectString(record.sha256Hex, `${path}.sha256Hex`, issues);
+  expectString(record.bytesBase64, `${path}.bytesBase64`, issues);
+  if (typeof record.sha256Hex === "string" && !/^[0-9a-f]{64}$/u.test(record.sha256Hex)) {
+    issues.push({
+      path: `${path}.sha256Hex`,
+      message: "Expected a lowercase SHA-256 hex digest."
+    });
+  }
+  if (record.sourceLabel !== void 0) {
+    expectString(record.sourceLabel, `${path}.sourceLabel`, issues);
+  }
+}
+function createPersistedEditorSnapshot(params) {
+  assertCanonicalDocument(params.canonicalDocument);
+  assertCompatibilityReport(params.compatibility);
+  return {
+    snapshotVersion: PERSISTED_EDITOR_SNAPSHOT_VERSION,
+    schemaVersion: CDS_SCHEMA_VERSION,
+    documentId: params.documentId,
+    docId: params.canonicalDocument.docId,
+    createdAt: params.canonicalDocument.createdAt,
+    updatedAt: params.canonicalDocument.updatedAt,
+    savedAt: params.savedAt,
+    editorBuild: params.editorBuild,
+    canonicalDocument: params.canonicalDocument,
+    compatibility: params.compatibility,
+    warningLog: params.warningLog ?? params.compatibility.warnings,
+    protectionSnapshot: params.protectionSnapshot,
+    sourcePackage: params.sourcePackage
+  };
+}
+function validateProtectionSnapshot(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  if (typeof record.hasDocumentProtection !== "boolean") {
+    issues.push({ path: `${path}.hasDocumentProtection`, message: "hasDocumentProtection must be a boolean." });
+  }
+  if (record.editType !== void 0) {
+    expectString(record.editType, `${path}.editType`, issues);
+  }
+  if (typeof record.enforcementActive !== "boolean") {
+    issues.push({ path: `${path}.enforcementActive`, message: "enforcementActive must be a boolean." });
+  }
+  if (!Array.isArray(record.ranges)) {
+    issues.push({ path: `${path}.ranges`, message: "ranges must be an array." });
+  } else {
+    record.ranges.forEach((range, index) => validateProtectionRange(range, `${path}.ranges[${index}]`, issues));
+  }
+  if (!Number.isInteger(record.enforcedRangeCount)) {
+    issues.push({ path: `${path}.enforcedRangeCount`, message: "enforcedRangeCount must be an integer." });
+  }
+  if (!Number.isInteger(record.preservedRangeCount)) {
+    issues.push({ path: `${path}.preservedRangeCount`, message: "preservedRangeCount must be an integer." });
+  }
+}
+function validateProtectionRange(value, path, issues) {
+  const record = asPlainObject(value, path, issues);
+  if (!record) {
+    return;
+  }
+  expectString(record.rangeId, `${path}.rangeId`, issues);
+  if (record.start !== void 0 && !Number.isInteger(record.start)) {
+    issues.push({ path: `${path}.start`, message: "start must be an integer." });
+  }
+  if (record.end !== void 0 && !Number.isInteger(record.end)) {
+    issues.push({ path: `${path}.end`, message: "end must be an integer." });
+  }
+  if (record.editorGroup !== void 0) {
+    expectString(record.editorGroup, `${path}.editorGroup`, issues);
+  }
+  if (record.editor !== void 0) {
+    expectString(record.editor, `${path}.editor`, issues);
+  }
+  if (typeof record.enforced !== "boolean") {
+    issues.push({ path: `${path}.enforced`, message: "enforced must be a boolean." });
+  }
+  expectString(record.enforcementReason, `${path}.enforcementReason`, issues);
+}
+
+// src/core/state/editor-state.ts
+function createEmptyReviewStore() {
+  return {
+    comments: {},
+    revisions: {}
+  };
+}
+function createDefaultCanonicalDocument(documentId, timestamp) {
+  return {
+    schemaVersion: "cds/1.0.0",
+    docId: createCanonicalDocumentId(documentId),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    metadata: {
+      customProperties: {}
+    },
+    styles: {
+      paragraphs: {},
+      characters: {},
+      tables: {}
+    },
+    numbering: {
+      abstractDefinitions: {},
+      instances: {}
+    },
+    media: {
+      items: {}
+    },
+    content: {
+      type: "doc",
+      children: [{ type: "paragraph", children: [] }]
+    },
+    review: createEmptyReviewStore(),
+    preservation: {
+      opaqueFragments: {},
+      packageParts: {}
+    },
+    diagnostics: {
+      warnings: [],
+      errors: []
+    }
+  };
+}
+function createSelectionSnapshot(anchor = 0, head = anchor) {
+  return {
+    anchor,
+    head,
+    isCollapsed: anchor === head,
+    activeRange: createRangeAnchor(anchor, head, DEFAULT_BOUNDARY_ASSOC)
+  };
+}
+function createEmptyCompatibilityReport(generatedAt) {
+  return {
+    reportVersion: "compatibility-report/1",
+    generatedAt,
+    blockExport: false,
+    featureEntries: [],
+    warnings: [],
+    errors: []
+  };
+}
+function createEditorState(options) {
+  const timestamp = (/* @__PURE__ */ new Date(0)).toISOString();
+  const normalizedSnapshot = options.persistedSnapshot ? normalizePersistedSnapshotForRuntime(options.persistedSnapshot, options.documentId, timestamp) : void 0;
+  if (options.canonicalDocument) {
+    assertCanonicalDocument(options.canonicalDocument);
+  }
+  const normalizedDocument = normalizedSnapshot ? structuredClone(normalizedSnapshot.canonicalDocument) : options.canonicalDocument ? structuredClone(options.canonicalDocument) : createDefaultCanonicalDocument(options.documentId, timestamp);
+  const warnings = normalizedSnapshot ? normalizeWarningLog(normalizedSnapshot.warningLog) : options.warnings ?? [];
+  const compatibility = normalizedSnapshot ? normalizeCompatibilityReport(normalizedSnapshot.compatibility) : options.compatibility ?? createEmptyCompatibilityReport(normalizedDocument.updatedAt);
+  return {
+    phase: options.fatalError ? "error" : "ready",
+    documentId: options.documentId,
+    sessionId: options.sessionId,
+    sourceLabel: options.sourceLabel,
+    sourcePackage: normalizedSnapshot?.sourcePackage,
+    revision: 0,
+    revisionToken: `${options.sessionId}:0`,
+    isDirty: false,
+    readOnly: options.readOnly ?? false,
+    document: normalizedDocument,
+    selection: createSelectionSnapshot(),
+    warnings,
+    compatibility,
+    fatalError: options.fatalError,
+    runtime: {
+      hasFocus: false
+    }
+  };
+}
+function normalizePersistedSnapshotForRuntime(snapshot, documentId, timestamp) {
+  const issues = validatePersistedEditorSnapshot(snapshot);
+  if (issues.length === 0) {
+    return snapshot;
+  }
+  if (!isRecord(snapshot) || !isRecord(snapshot.canonicalDocument)) {
+    assertPersistedEditorSnapshot(snapshot);
+  }
+  const normalizedDocument = normalizeCanonicalDocumentEnvelope(
+    snapshot.canonicalDocument,
+    documentId,
+    timestamp
+  );
+  try {
+    assertCanonicalDocument(normalizedDocument);
+  } catch {
+    assertPersistedEditorSnapshot(snapshot);
+  }
+  const repairWarning = createSnapshotRepairWarning(issues.length);
+  const compatibility = coerceCompatibilityReport(
+    snapshot.compatibility,
+    normalizedDocument.updatedAt,
+    repairWarning
+  );
+  return {
+    snapshotVersion: snapshot.snapshotVersion === "persisted-editor-snapshot/1" || snapshot.snapshotVersion === "persisted-editor-snapshot/2" ? snapshot.snapshotVersion : "persisted-editor-snapshot/2",
+    schemaVersion: "cds/1.0.0",
+    documentId: typeof snapshot.documentId === "string" && snapshot.documentId.length > 0 ? snapshot.documentId : documentId,
+    docId: normalizedDocument.docId,
+    createdAt: normalizedDocument.createdAt,
+    updatedAt: normalizedDocument.updatedAt,
+    savedAt: typeof snapshot.savedAt === "string" && snapshot.savedAt.length > 0 ? snapshot.savedAt : normalizedDocument.updatedAt,
+    editorBuild: typeof snapshot.editorBuild === "string" && snapshot.editorBuild.length > 0 ? snapshot.editorBuild : "dev",
+    canonicalDocument: normalizedDocument,
+    compatibility,
+    warningLog: dedupeWarnings([
+      ...coerceWarnings(snapshot.warningLog),
+      repairWarning
+    ]),
+    sourcePackage: snapshot.sourcePackage
+  };
+}
+function normalizeCanonicalDocumentEnvelope(value, documentId, timestamp) {
+  const base = createDefaultCanonicalDocument(documentId, timestamp);
+  const record = isRecord(value) ? value : {};
+  const metadata = isRecord(record.metadata) ? record.metadata : {};
+  return {
+    ...base,
+    ...record,
+    schemaVersion: "cds/1.0.0",
+    docId: isUuid(record.docId) ? record.docId : createCanonicalDocumentId(documentId),
+    createdAt: typeof record.createdAt === "string" && record.createdAt.length > 0 ? record.createdAt : base.createdAt,
+    updatedAt: typeof record.updatedAt === "string" && record.updatedAt.length > 0 ? record.updatedAt : base.updatedAt,
+    metadata: {
+      ...base.metadata,
+      ...metadata,
+      customProperties: isRecord(metadata.customProperties) ? Object.fromEntries(
+        Object.entries(metadata.customProperties).filter(([, entry]) => typeof entry === "string")
+      ) : {}
+    },
+    styles: record.styles === void 0 ? base.styles : record.styles,
+    numbering: record.numbering === void 0 ? base.numbering : record.numbering,
+    media: record.media === void 0 ? base.media : record.media,
+    content: isRecord(record.content) ? record.content : base.content,
+    review: record.review === void 0 ? base.review : record.review,
+    preservation: record.preservation === void 0 ? base.preservation : record.preservation,
+    diagnostics: record.diagnostics === void 0 ? base.diagnostics : record.diagnostics,
+    ...isRecord(record.subParts) ? { subParts: record.subParts } : {}
+  };
+}
+function coerceCompatibilityReport(value, generatedAt, repairWarning) {
+  const record = isRecord(value) ? value : {};
+  const warnings = dedupeWarnings([
+    ...coerceWarnings(record.warnings),
+    repairWarning
+  ]);
+  return {
+    reportVersion: "compatibility-report/1",
+    generatedAt: typeof record.generatedAt === "string" && record.generatedAt.length > 0 ? record.generatedAt : generatedAt,
+    blockExport: typeof record.blockExport === "boolean" ? record.blockExport : false,
+    featureEntries: Array.isArray(record.featureEntries) ? record.featureEntries.flatMap((entry) => {
+      if (!isRecord(entry)) {
+        return [];
+      }
+      if (typeof entry.featureEntryId !== "string" || typeof entry.featureKey !== "string" || typeof entry.featureClass !== "string" || typeof entry.message !== "string") {
+        return [];
+      }
+      return [{
+        featureEntryId: entry.featureEntryId,
+        featureKey: entry.featureKey,
+        featureClass: entry.featureClass,
+        message: entry.message,
+        ...entry.affectedAnchor && isRecord(entry.affectedAnchor) ? { affectedAnchor: entry.affectedAnchor } : {},
+        ...isRecord(entry.details) ? { details: entry.details } : {}
+      }];
+    }) : [],
+    warnings,
+    errors: Array.isArray(record.errors) ? record.errors.flatMap((entry) => {
+      if (!isRecord(entry)) {
+        return [];
+      }
+      if (typeof entry.errorId !== "string" || typeof entry.code !== "string" || typeof entry.message !== "string" || typeof entry.source !== "string" || typeof entry.isFatal !== "boolean") {
+        return [];
+      }
+      return [{
+        errorId: entry.errorId,
+        code: entry.code,
+        message: entry.message,
+        source: entry.source,
+        isFatal: entry.isFatal,
+        ...isRecord(entry.details) ? { details: entry.details } : {}
+      }];
+    }) : []
+  };
+}
+function coerceWarnings(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((warning) => {
+    if (!isRecord(warning)) {
+      return [];
+    }
+    if (typeof warning.warningId !== "string" || typeof warning.code !== "string" || typeof warning.severity !== "string" || typeof warning.message !== "string" || typeof warning.source !== "string") {
+      return [];
+    }
+    return [{
+      warningId: warning.warningId,
+      code: warning.code,
+      severity: warning.severity,
+      message: warning.message,
+      source: warning.source,
+      ...warning.affectedAnchor && isRecord(warning.affectedAnchor) ? { affectedAnchor: warning.affectedAnchor } : {},
+      ...typeof warning.featureEntryId === "string" ? { featureEntryId: warning.featureEntryId } : {},
+      ...isRecord(warning.details) ? { details: warning.details } : {}
+    }];
+  });
+}
+function createSnapshotRepairWarning(issueCount) {
+  return {
+    warningId: `warning:snapshot-repair:${issueCount}`,
+    code: "import_normalized",
+    severity: "warning",
+    message: `Loaded a persisted snapshot after repairing ${issueCount} validation issue${issueCount === 1 ? "" : "s"}.`,
+    source: "validation"
+  };
+}
+function dedupeWarnings(warnings) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const warning of warnings) {
+    if (!warning.warningId || seen.has(warning.warningId)) {
+      continue;
+    }
+    seen.add(warning.warningId);
+    result.push(warning);
+  }
+  return result;
+}
+function deriveDocumentStats(state) {
+  const serializedContent = extractText(state.document.content);
+  return {
+    paragraphCount: estimateParagraphCount(state.document.content),
+    wordCount: serializedContent.trim().length === 0 ? 0 : serializedContent.trim().split(/\s+/u).length,
+    characterCount: Array.from(serializedContent).length,
+    commentCount: Object.keys(state.document.review.comments).length,
+    revisionCount: Object.keys(state.document.review.revisions).length
+  };
+}
+function deriveRenderSnapshot(state, history) {
+  const comments = Object.values(state.document.review.comments).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt)
+  );
+  const revisions = Object.values(state.document.review.revisions);
+  return {
+    documentId: state.documentId,
+    sessionId: state.sessionId,
+    sourceLabel: state.sourceLabel,
+    revisionToken: state.revisionToken,
+    isReady: state.phase === "ready",
+    isDirty: state.isDirty,
+    readOnly: state.readOnly,
+    selection: state.selection,
+    documentStats: deriveDocumentStats(state),
+    comments: {
+      activeCommentId: state.runtime.activeCommentId,
+      openThreadCount: comments.filter((comment) => comment.status === "open").length,
+      resolvedThreadCount: comments.filter((comment) => comment.status === "resolved").length,
+      threads: comments
+    },
+    trackedChanges: {
+      totalCount: revisions.length,
+      pendingCount: revisions.filter((revision) => revision.status === "open").length,
+      acceptedCount: revisions.filter((revision) => revision.status === "accepted").length,
+      rejectedCount: revisions.filter((revision) => revision.status === "rejected").length
+    },
+    compatibility: {
+      report: state.compatibility,
+      blockExport: state.compatibility.blockExport,
+      totalEntries: state.compatibility.featureEntries.length
+    },
+    warnings: state.warnings,
+    fatalError: state.fatalError,
+    commandState: {
+      canUndo: history.canUndo,
+      canRedo: history.canRedo,
+      canAddComment: !state.readOnly,
+      canAcceptAllChanges: revisions.some((revision) => revision.status === "open"),
+      canRejectAllChanges: revisions.some((revision) => revision.status === "open")
+    }
+  };
+}
+function createPersistedEditorSnapshot2(state, options) {
+  const snapshot = createPersistedEditorSnapshot({
+    documentId: state.documentId,
+    savedAt: options.savedAt,
+    editorBuild: options.editorBuild,
+    canonicalDocument: state.document,
+    compatibility: options.compatibility ?? state.compatibility,
+    warningLog: state.warnings,
+    protectionSnapshot: options.protectionSnapshot,
+    sourcePackage: state.sourcePackage
+  });
+  return snapshot;
+}
+function estimateParagraphCount(content) {
+  if (Array.isArray(content)) {
+    return content.length;
+  }
+  if (content && typeof content === "object" && Array.isArray(content.blocks)) {
+    return content.blocks.length;
+  }
+  return extractText(content).length > 0 ? 1 : 0;
+}
+function normalizeWarningLog(warnings) {
+  return warnings.map((warning) => ({
+    ...warning,
+    affectedAnchor: warning.affectedAnchor ? normalizeAnchorProjection(warning.affectedAnchor) : void 0
+  }));
+}
+function normalizeCompatibilityReport(report) {
+  return {
+    ...report,
+    featureEntries: report.featureEntries.map((entry) => ({
+      ...entry,
+      affectedAnchor: entry.affectedAnchor ? normalizeAnchorProjection(entry.affectedAnchor) : void 0
+    })),
+    warnings: normalizeWarningLog(report.warnings)
+  };
+}
+function normalizeAnchorProjection(anchor) {
+  switch (anchor.kind) {
+    case "range": {
+      const rangeAnchor = anchor;
+      return rangeAnchor.range ? createRangeAnchor(rangeAnchor.range.from, rangeAnchor.range.to, rangeAnchor.assoc) : createRangeAnchor(rangeAnchor.from ?? 0, rangeAnchor.to ?? 0, rangeAnchor.assoc);
+    }
+    case "node":
+      return createNodeAnchor(anchor.at, anchor.assoc);
+    case "detached":
+      return createDetachedAnchor(anchor.lastKnownRange, anchor.reason);
+  }
+}
+function extractText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => extractText(item)).join(" ");
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  return Object.values(value).map((item) => extractText(item)).filter(Boolean).join(" ");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function createCanonicalDocumentId(documentId) {
+  const hashWord = (seed) => {
+    let hash = 2166136261;
+    for (const char of seed) {
+      hash ^= char.charCodeAt(0);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  };
+  const raw = hashWord(`${documentId}:0`) + hashWord(`${documentId}:1`) + hashWord(`${documentId}:2`) + hashWord(`${documentId}:3`);
+  return [
+    raw.slice(0, 8),
+    raw.slice(8, 12),
+    `4${raw.slice(13, 16)}`,
+    `8${raw.slice(17, 20)}`,
+    raw.slice(20, 32)
+  ].join("-");
+}
+function normalizeCommentThreadRecord(value) {
+  const record = isRecord(value) ? value : {};
+  const authorId = typeof record.createdBy === "string" && record.createdBy.length > 0 ? record.createdBy : typeof record.authorId === "string" && record.authorId.length > 0 ? record.authorId : "unknown";
+  const createdAt = typeof record.createdAt === "string" && record.createdAt.length > 0 ? record.createdAt : (/* @__PURE__ */ new Date(0)).toISOString();
+  const entries = Array.isArray(record.entries) ? record.entries.filter((entry) => isRecord(entry)).map((entry, index) => ({
+    entryId: typeof entry.entryId === "string" && entry.entryId.length > 0 ? entry.entryId : `${String(record.commentId ?? "comment")}-entry-${index + 1}`,
+    authorId: typeof entry.authorId === "string" && entry.authorId.length > 0 ? entry.authorId : authorId,
+    body: typeof entry.body === "string" ? entry.body : "",
+    createdAt: typeof entry.createdAt === "string" && entry.createdAt.length > 0 ? entry.createdAt : createdAt,
+    metadata: isRecord(entry.metadata) ? {
+      ooxmlCommentId: typeof entry.metadata.ooxmlCommentId === "string" ? entry.metadata.ooxmlCommentId : void 0,
+      paraId: typeof entry.metadata.paraId === "string" ? entry.metadata.paraId : void 0,
+      parentParaId: typeof entry.metadata.parentParaId === "string" ? entry.metadata.parentParaId : void 0,
+      durableId: typeof entry.metadata.durableId === "string" ? entry.metadata.durableId : void 0,
+      initials: typeof entry.metadata.initials === "string" ? entry.metadata.initials : void 0
+    } : void 0
+  })) : [
+    {
+      entryId: `${String(record.commentId ?? "comment")}-entry-1`,
+      authorId,
+      body: typeof record.body === "string" ? record.body : "",
+      createdAt
+    }
+  ];
+  const resolution = isRecord(record.resolution) ? {
+    resolvedAt: typeof record.resolution.resolvedAt === "string" ? record.resolution.resolvedAt : typeof record.resolvedAt === "string" ? record.resolvedAt : createdAt,
+    resolvedBy: typeof record.resolution.resolvedBy === "string" && record.resolution.resolvedBy.length > 0 ? record.resolution.resolvedBy : authorId
+  } : typeof record.resolvedAt === "string" ? {
+    resolvedAt: record.resolvedAt,
+    resolvedBy: authorId
+  } : void 0;
+  const normalizedStatus = typeof record.status === "string" ? record.status : record.anchor && isRecord(record.anchor) && record.anchor.kind === "detached" ? "detached" : resolution || record.isResolved ? "resolved" : "open";
+  return {
+    commentId: typeof record.commentId === "string" && record.commentId.length > 0 ? record.commentId : "comment-generated",
+    anchor: isRecord(record.anchor) && typeof record.anchor.kind === "string" ? record.anchor : createDetachedAnchor({ from: 0, to: 0 }, "importAmbiguity"),
+    createdAt,
+    createdBy: authorId,
+    authorId,
+    body: entries.map((entry) => entry.body).join("\n"),
+    entries,
+    status: normalizedStatus === "resolved" || normalizedStatus === "detached" ? normalizedStatus : "open",
+    resolution,
+    resolvedAt: resolution?.resolvedAt,
+    warningIds: Array.isArray(record.warningIds) ? record.warningIds.filter((warningId) => typeof warningId === "string") : [],
+    isResolved: normalizedStatus === "resolved",
+    metadata: isRecord(record.metadata) ? {
+      source: record.metadata.source === "import" || record.metadata.source === "runtime" ? record.metadata.source : void 0,
+      rootOoxmlCommentId: typeof record.metadata.rootOoxmlCommentId === "string" ? record.metadata.rootOoxmlCommentId : void 0,
+      rootParaId: typeof record.metadata.rootParaId === "string" ? record.metadata.rootParaId : void 0
+    } : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCanonicalDocumentId,
+  createDefaultCanonicalDocument,
+  createEditorState,
+  createEmptyCompatibilityReport,
+  createEmptyReviewStore,
+  createPersistedEditorSnapshot,
+  createSelectionSnapshot,
+  deriveDocumentStats,
+  deriveRenderSnapshot,
+  normalizeCommentThreadRecord
+});
+//# sourceMappingURL=editor-state.cjs.map