@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/dist/chunk-5FN54NDH.js

@@ -1,2257 +0,0 @@
-import {
-  DEFAULT_BOUNDARY_ASSOC,
-  createDetachedAnchor,
-  createNodeAnchor,
-  createRangeAnchor
-} from "./chunk-EBI3BX6U.js";
-
-// 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 sortRecordKeys(record) {
-  return Object.entries(record).sort(
-    ([left], [right]) => left.localeCompare(right)
-  );
-}
-function assertValid(issues, message) {
-  if (issues.length > 0) {
-    throw new ModelValidationError(message, issues);
-  }
-}
-function toStableJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => toStableJsonValue(item));
-  }
-  if (!isPlainObject(value)) {
-    throw new TypeError("Cannot serialize non-JSON value.");
-  }
-  const sortedEntries = sortRecordKeys(value).filter(
-    ([, entryValue]) => entryValue !== void 0
-  );
-  const result = {};
-  for (const [key, entryValue] of sortedEntries) {
-    result[key] = toStableJsonValue(entryValue);
-  }
-  return result;
-}
-function stableStringify(value) {
-  return JSON.stringify(toStableJsonValue(value));
-}
-
-// 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 createCanonicalDocumentSignature(document) {
-  return stableStringify(document);
-}
-function projectCanonicalDocument(document) {
-  assertCanonicalDocument(document);
-  return JSON.parse(stableStringify(document));
-}
-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
-  };
-}
-
-export {
-  createCanonicalDocumentSignature,
-  projectCanonicalDocument,
-  validatePersistedEditorSnapshot,
-  createEmptyReviewStore,
-  createDefaultCanonicalDocument,
-  createSelectionSnapshot,
-  createEmptyCompatibilityReport,
-  createEditorState,
-  deriveDocumentStats,
-  deriveRenderSnapshot,
-  createPersistedEditorSnapshot2 as createPersistedEditorSnapshot,
-  createCanonicalDocumentId,
-  normalizeCommentThreadRecord
-};
-//# sourceMappingURL=chunk-5FN54NDH.js.map