@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/dist/chunk-KD2QRQPY.js

@@ -1,4342 +0,0 @@
-import {
-  deleteSelectionOrBackward,
-  deleteSelectionOrForward,
-  insertHardBreak,
-  insertTab,
-  insertText,
-  splitParagraph
-} from "./chunk-UZXBISGO.js";
-import {
-  applyTextTransaction
-} from "./chunk-QDAQ4CJU.js";
-import {
-  searchSurfaceBlocks
-} from "./chunk-CN3XMECL.js";
-import {
-  buildPageLayoutSnapshot,
-  buildResolvedSections,
-  canCreateDocxCommentAnchor,
-  createDocumentNavigationSnapshot,
-  createEditorViewStateSnapshot,
-  createViewState,
-  detachReviewAnchor,
-  findPageForOffset,
-  getAnchorRange,
-  incrementInvalidationCounter,
-  mapReviewAnchor,
-  mappingTouchesAnchorContent,
-  rangeStaysWithinSingleParagraph,
-  recordPerfSample,
-  resolveActiveSection,
-  setDocumentMode,
-  setFocused,
-  setViewMode,
-  setWorkspaceMode,
-  setZoomLevel
-} from "./chunk-GBVOWFIK.js";
-import {
-  parseTextStory
-} from "./chunk-KLMXQVYK.js";
-import {
-  createEditorSurfaceSnapshot,
-  getStoryBlocks,
-  normalizeHeaderFooterTarget,
-  replaceStoryBlocks,
-  storyTargetKey
-} from "./chunk-EILUG3VB.js";
-import {
-  buildCompatibilityReport,
-  createDiagnostics,
-  createRevisionSidebarProjection,
-  diagnosticsBlockExport,
-  editorSessionStateFromPersistedSnapshot,
-  getRevisionActionability,
-  persistedSnapshotFromEditorSessionState,
-  remapRevisionStore,
-  setRevisionStatus
-} from "./chunk-2FJS5GZM.js";
-import {
-  createCommentSidebarProjection,
-  createCommentStoreFromRuntimeComments
-} from "./chunk-2S7W4KFO.js";
-import {
-  describeOpaqueFragment,
-  findOpaqueFragmentsIntersectingRange
-} from "./chunk-SWKWQZXM.js";
-import {
-  createEditorState,
-  createPersistedEditorSnapshot,
-  createSelectionSnapshot,
-  deriveDocumentStats,
-  normalizeCommentThreadRecord
-} from "./chunk-5FN54NDH.js";
-import {
-  DEFAULT_BOUNDARY_ASSOC,
-  MAIN_STORY_TARGET,
-  areAnchorsEqual,
-  createDetachedAnchor,
-  createEmptyMapping,
-  createNodeAnchor,
-  createRangeAnchor,
-  mapAnchor,
-  mapRange,
-  storyTargetsEqual
-} from "./chunk-EBI3BX6U.js";
-import {
-  buildBookmarkNameMap
-} from "./chunk-RMH72RZI.js";
-import {
-  buildFieldRegistry,
-  isSupportedFieldFamily,
-  parseTocLevelRange,
-  resolveRefFieldText
-} from "./chunk-TLCEAQDQ.js";
-
-// src/core/commands/review-commands.ts
-function isSingleRevisionReviewCommand(command) {
-  return "revisionId" in command;
-}
-function getReviewCommandIntent(command) {
-  switch (command.type) {
-    case "review.accept-revision":
-    case "review.accept-all-revisions":
-      return "accept";
-    case "review.reject-revision":
-    case "review.reject-all-revisions":
-      return "reject";
-  }
-}
-function createAcceptRevisionCommand(revisionId, origin) {
-  return {
-    type: "review.accept-revision",
-    revisionId,
-    ...origin ? { origin } : {}
-  };
-}
-function createRejectRevisionCommand(revisionId, origin) {
-  return {
-    type: "review.reject-revision",
-    revisionId,
-    ...origin ? { origin } : {}
-  };
-}
-
-// src/review/store/comment-remapping.ts
-function remapCommentThreads(options) {
-  const comments = Object.fromEntries(
-    Object.entries(options.comments).map(([commentId, comment]) => [
-      commentId,
-      remapCommentThread(comment, options.mapping, options.nextContent)
-    ])
-  );
-  const detachedCommentIds = Object.values(comments).filter((comment) => comment.anchor.kind === "detached").map((comment) => comment.commentId);
-  return {
-    comments,
-    warnings: mergeDetachedAnchorWarnings(comments, options.existingWarnings ?? []),
-    detachedCommentIds
-  };
-}
-function remapCommentThread(comment, mapping, nextContent) {
-  if (comment.anchor.kind === "detached") {
-    return comment;
-  }
-  const mappedAnchor = mapReviewAnchor(comment.anchor, mapping);
-  const anchor = normalizeCommentAnchor(comment.anchor, mappedAnchor, mapping, nextContent);
-  return {
-    ...comment,
-    anchor
-  };
-}
-function normalizeCommentAnchor(previousAnchor, mappedAnchor, mapping, nextContent) {
-  if (mappedAnchor.kind === "detached") {
-    return mappedAnchor;
-  }
-  const previousRange = getAnchorRange(previousAnchor);
-  const mappedRange = getAnchorRange(mappedAnchor);
-  if (previousAnchor.kind === "range" && previousRange.from < previousRange.to && mappedAnchor.kind === "range" && mappedRange.from === mappedRange.to && mappingTouchesAnchorContent(previousAnchor, mapping)) {
-    return detachReviewAnchor(previousRange, detachReason(mapping));
-  }
-  if (mappedAnchor.kind === "range" && !rangeStaysWithinSingleParagraph(nextContent, mappedAnchor.range)) {
-    return detachReviewAnchor(previousRange, "invalidatedByStructureChange");
-  }
-  return mappedAnchor;
-}
-function detachReason(mapping) {
-  return mapping.metadata?.invalidatesStructures ? "invalidatedByStructureChange" : "deleted";
-}
-function mergeDetachedAnchorWarnings(comments, existingWarnings) {
-  const retainedWarnings = existingWarnings.filter(
-    (warning) => warning.code !== "comment_anchor_detached" || !warning.details || typeof warning.details.commentId !== "string" || comments[warning.details.commentId]?.anchor.kind === "detached"
-  );
-  const knownDetachedIds = new Set(
-    retainedWarnings.filter((warning) => warning.code === "comment_anchor_detached").map(
-      (warning) => typeof warning.details?.commentId === "string" ? warning.details.commentId : void 0
-    ).filter((value) => Boolean(value))
-  );
-  const detachedWarnings = Object.values(comments).filter(
-    (comment) => comment.anchor.kind === "detached" && !knownDetachedIds.has(comment.commentId)
-  ).map((comment) => createDetachedCommentWarning(comment));
-  return [...retainedWarnings, ...detachedWarnings];
-}
-function createDetachedCommentWarning(comment) {
-  const anchor = comment.anchor.kind === "detached" ? comment.anchor : void 0;
-  return {
-    warningId: `warning:comment-anchor-detached:${comment.commentId}`,
-    code: "comment_anchor_detached",
-    severity: "warning",
-    message: `Comment ${comment.commentId} detached after edit remapping.`,
-    source: "review",
-    affectedAnchor: anchor,
-    details: {
-      commentId: comment.commentId,
-      reason: anchor?.reason
-    }
-  };
-}
-
-// src/review/store/revision-actions.ts
-function applyRevisionAction(options) {
-  const revision = options.store.revisions[options.revisionId];
-  if (!revision) {
-    return skippedResult(options, "missing", "Revision record was not found.");
-  }
-  if (revision.status !== "active") {
-    return skippedResult(
-      options,
-      "already-resolved",
-      `Revision is already ${revision.status}.`
-    );
-  }
-  if (revision.anchor.kind === "detached") {
-    return skippedResult(
-      options,
-      "detached-anchor",
-      "Detached revisions remain visible but cannot be accepted or rejected."
-    );
-  }
-  if (getRevisionActionability(revision) !== "actionable") {
-    return skippedResult(
-      options,
-      "preserve-only",
-      revision.metadata.preserveOnlyReason ?? "This revision kind remains preserve-only in the current runtime."
-    );
-  }
-  if (revision.anchor.kind !== "range") {
-    return skippedResult(
-      options,
-      "structural-range",
-      "Non-range revisions remain preserve-only in the current runtime."
-    );
-  }
-  const story = parseTextStory(options.document.content);
-  const range = normalizeRange(
-    revision.anchor.range.from,
-    revision.anchor.range.to
-  );
-  if (range.to > story.size) {
-    return skippedResult(
-      options,
-      "invalid-range",
-      `Revision range ${range.from}-${range.to} exceeds story size ${story.size}.`
-    );
-  }
-  const paragraphMarkRange = resolveParagraphMarkDeletionRange(story, revision, options.intent);
-  if (paragraphMarkRange) {
-    const resultingStatus2 = toResultingStatus(options.intent);
-    const textResult2 = applyTextTransaction(
-      options.document,
-      createSelectionSnapshot(paragraphMarkRange.from, paragraphMarkRange.to),
-      {
-        type: "replace",
-        range: paragraphMarkRange,
-        insertion: []
-      },
-      {
-        timestamp: options.timestamp
-      }
-    );
-    const nextStore2 = remapRevisionStore(
-      setRevisionStatus(options.store, revision.revisionId, resultingStatus2),
-      textResult2.mapping
-    );
-    return {
-      document: textResult2.document,
-      store: nextStore2,
-      mapping: textResult2.mapping,
-      outcome: {
-        kind: "applied",
-        revisionId: revision.revisionId,
-        intent: options.intent,
-        resultingStatus: resultingStatus2,
-        contentChanged: true
-      },
-      detachedRevisionIds: findNewDetachedRevisionIds(options.store, nextStore2)
-    };
-  }
-  if (requiresParagraphBoundaryDeletion(revision, options.intent)) {
-    return skippedResult(
-      options,
-      "structural-range",
-      "Paragraph-boundary revisions need a stable paragraph break and remain blocked for this shape."
-    );
-  }
-  const slice = story.units.slice(range.from, range.to);
-  if (slice.some(
-    (unit) => unit.kind === "paragraph_break" || unit.kind === "opaque_block"
-  )) {
-    return skippedResult(
-      options,
-      "structural-range",
-      "Paragraph-boundary and structural revisions remain preserve-only."
-    );
-  }
-  if (slice.some(
-    (unit) => unit.kind === "image" || unit.kind === "opaque_inline"
-  )) {
-    return skippedResult(
-      options,
-      "protected-range",
-      "Revisions touching protected inline content remain preserve-only."
-    );
-  }
-  const resultingStatus = toResultingStatus(options.intent);
-  const contentChanged = requiresContentDeletion(revision, options.intent);
-  if (!contentChanged) {
-    return {
-      document: options.document,
-      store: setRevisionStatus(options.store, revision.revisionId, resultingStatus),
-      mapping: createEmptyMapping(),
-      outcome: {
-        kind: "applied",
-        revisionId: revision.revisionId,
-        intent: options.intent,
-        resultingStatus,
-        contentChanged: false
-      },
-      detachedRevisionIds: []
-    };
-  }
-  const textResult = applyTextTransaction(
-    options.document,
-    createSelectionSnapshot(range.from, range.to),
-    {
-      type: "replace",
-      range,
-      insertion: []
-    },
-    {
-      timestamp: options.timestamp
-    }
-  );
-  const nextStore = remapRevisionStore(
-    setRevisionStatus(options.store, revision.revisionId, resultingStatus),
-    textResult.mapping
-  );
-  return {
-    document: textResult.document,
-    store: nextStore,
-    mapping: textResult.mapping,
-    outcome: {
-      kind: "applied",
-      revisionId: revision.revisionId,
-      intent: options.intent,
-      resultingStatus,
-      contentChanged: true
-    },
-    detachedRevisionIds: findNewDetachedRevisionIds(options.store, nextStore)
-  };
-}
-function skippedResult(options, reason, detail) {
-  return {
-    document: options.document,
-    store: options.store,
-    mapping: createEmptyMapping(),
-    outcome: {
-      kind: "skipped",
-      revisionId: options.revisionId,
-      intent: options.intent,
-      reason,
-      detail
-    },
-    detachedRevisionIds: []
-  };
-}
-function toResultingStatus(intent) {
-  return intent === "accept" ? "accepted" : "rejected";
-}
-function requiresContentDeletion(revision, intent) {
-  return revision.kind === "insertion" && intent === "reject" || revision.kind === "deletion" && intent === "accept";
-}
-function requiresParagraphBoundaryDeletion(revision, intent) {
-  return revision.metadata.originalRevisionType === "paragraph-del" && intent === "accept" || revision.metadata.originalRevisionType === "paragraph-ins" && intent === "reject";
-}
-function resolveParagraphMarkDeletionRange(story, revision, intent) {
-  const originalRevisionType = revision.metadata.originalRevisionType;
-  if (revision.anchor.kind !== "range" || originalRevisionType !== "paragraph-del" && originalRevisionType !== "paragraph-ins") {
-    return void 0;
-  }
-  const shouldDeleteBoundary = originalRevisionType === "paragraph-del" && intent === "accept" || originalRevisionType === "paragraph-ins" && intent === "reject";
-  if (!shouldDeleteBoundary) {
-    return void 0;
-  }
-  const paragraphs = mapParagraphRanges(story);
-  const anchorPosition = normalizeRange(
-    revision.anchor.range.from,
-    revision.anchor.range.to
-  ).from;
-  const paragraph = paragraphs.find(
-    (candidate) => candidate.end === anchorPosition || anchorPosition >= candidate.start && anchorPosition <= candidate.end
-  );
-  if (!paragraph) {
-    return void 0;
-  }
-  if (originalRevisionType === "paragraph-del") {
-    const boundaryIndex2 = paragraph.end;
-    if (story.units[boundaryIndex2]?.kind !== "paragraph_break") {
-      return void 0;
-    }
-    return {
-      from: boundaryIndex2,
-      to: boundaryIndex2 + 1
-    };
-  }
-  const boundaryIndex = paragraph.start - 1;
-  if (boundaryIndex < 0 || story.units[boundaryIndex]?.kind !== "paragraph_break") {
-    return void 0;
-  }
-  return {
-    from: boundaryIndex,
-    to: boundaryIndex + 1
-  };
-}
-function mapParagraphRanges(story) {
-  const paragraphs = [];
-  let start = 0;
-  let hasPendingParagraph = true;
-  for (let index = 0; index < story.units.length; index += 1) {
-    const unit = story.units[index];
-    if (unit.kind === "paragraph_break") {
-      paragraphs.push({ start, end: index });
-      start = index + 1;
-      hasPendingParagraph = true;
-      continue;
-    }
-    if (unit.kind === "opaque_block") {
-      if (hasPendingParagraph) {
-        paragraphs.push({ start, end: index });
-      }
-      start = index + 1;
-      hasPendingParagraph = Boolean(unit.nextParagraph);
-    }
-  }
-  if (hasPendingParagraph) {
-    paragraphs.push({ start, end: story.units.length });
-  }
-  return paragraphs;
-}
-function normalizeRange(from, to) {
-  return {
-    from: Math.min(from, to),
-    to: Math.max(from, to)
-  };
-}
-function findNewDetachedRevisionIds(previousStore, nextStore) {
-  const detachedRevisionIds = [];
-  for (const [revisionId, revision] of Object.entries(nextStore.revisions)) {
-    if (revision.status === "detached" && previousStore.revisions[revisionId]?.status !== "detached") {
-      detachedRevisionIds.push(revisionId);
-    }
-  }
-  return detachedRevisionIds;
-}
-
-// src/runtime/revision-runtime.ts
-function applyRevisionRuntimeCommand(options) {
-  const revisionIds = isSingleRevisionReviewCommand(options.command) ? [options.command.revisionId] : listBatchRevisionIds(options.state.store);
-  const outcomes = [];
-  const mappings = [];
-  const appliedRevisionIds = [];
-  const detachedRevisionIds = /* @__PURE__ */ new Set();
-  let state = options.state;
-  for (const revisionId of revisionIds) {
-    const result = applyRevisionAction({
-      document: state.document,
-      store: state.store,
-      revisionId,
-      intent: getReviewCommandIntent(options.command),
-      timestamp: options.timestamp
-    });
-    state = {
-      document: result.document,
-      store: result.store
-    };
-    outcomes.push(result.outcome);
-    mappings.push({
-      revisionId,
-      mapping: result.mapping,
-      steps: result.mapping.steps.length
-    });
-    if (result.outcome.kind === "applied") {
-      appliedRevisionIds.push(revisionId);
-    }
-    for (const detachedRevisionId of result.detachedRevisionIds) {
-      detachedRevisionIds.add(detachedRevisionId);
-    }
-  }
-  return {
-    ...state,
-    outcomes,
-    mappings,
-    effects: {
-      appliedRevisionIds,
-      skippedRevisions: outcomes.filter(
-        (outcome) => outcome.kind === "skipped"
-      ),
-      detachedRevisionIds: [...detachedRevisionIds]
-    }
-  };
-}
-function listBatchRevisionIds(store) {
-  return Object.values(store.revisions).filter((revision) => revision.status === "active").sort((left, right) => {
-    const createdAtDelta = left.createdAt.localeCompare(right.createdAt);
-    if (createdAtDelta !== 0) {
-      return createdAtDelta;
-    }
-    return left.revisionId.localeCompare(right.revisionId);
-  }).map((revision) => revision.revisionId);
-}
-
-// src/core/commands/index.ts
-function executeEditorCommand(state, command, context) {
-  switch (command.type) {
-    case "selection.set":
-      return createTransaction(
-        {
-          ...state,
-          selection: normalizeSelection(command.selection)
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false
-        }
-      );
-    case "document.replace": {
-      const mapping = command.mapping ?? createEmptyMapping();
-      const selection = command.selection ?? remapSelection(state.selection, mapping);
-      const reviewState = remapReviewStateAfterContentChange(
-        state,
-        command.document,
-        mapping
-      );
-      return createTransaction(
-        {
-          ...state,
-          document: reviewState.document,
-          selection,
-          warnings: reviewState.warnings,
-          runtime: {
-            ...state.runtime,
-            activeCommentId: reviewState.activeCommentId
-          },
-          compatibility: {
-            ...state.compatibility,
-            generatedAt: context.timestamp,
-            warnings: reviewState.warnings,
-            featureEntries: state.compatibility.featureEntries.map(
-              (entry) => entry.affectedAnchor ? {
-                ...entry,
-                affectedAnchor: mapAnchor(entry.affectedAnchor, mapping)
-              } : entry
-            )
-          }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          mapping,
-          effects: reviewState.effects
-        }
-      );
-    }
-    case "text.insert": {
-      const suggestingResult = context.documentMode === "suggesting" ? applySuggestingInsert(state, command.text, context) : void 0;
-      if (suggestingResult) return suggestingResult;
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => insertText(document, selection, command.text, context)
-      );
-    }
-    case "text.delete-backward": {
-      const suggestingResult = context.documentMode === "suggesting" ? applySuggestingDelete(state, "backward", context) : void 0;
-      if (suggestingResult) return suggestingResult;
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => deleteSelectionOrBackward(document, selection, context)
-      );
-    }
-    case "text.delete-forward": {
-      const suggestingResult = context.documentMode === "suggesting" ? applySuggestingDelete(state, "forward", context) : void 0;
-      if (suggestingResult) return suggestingResult;
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => deleteSelectionOrForward(document, selection, context)
-      );
-    }
-    case "text.insert-tab": {
-      const suggestingResult = context.documentMode === "suggesting" ? applySuggestingInsertUnit(state, "tab", context) : void 0;
-      if (suggestingResult) return suggestingResult;
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => insertTab(document, selection, context)
-      );
-    }
-    case "text.insert-hard-break": {
-      const suggestingResult = context.documentMode === "suggesting" ? applySuggestingInsertUnit(state, "hard_break", context) : void 0;
-      if (suggestingResult) return suggestingResult;
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => insertHardBreak(document, selection, context)
-      );
-    }
-    case "paragraph.split":
-      if (context.documentMode === "suggesting") {
-        return createTransaction(state, {
-          historyBoundary: "skip",
-          markDirty: false,
-          effects: {
-            commandBlocked: {
-              code: "suggesting_unsupported",
-              message: "Paragraph splits are not supported in suggesting mode."
-            }
-          }
-        });
-      }
-      return applyTextCommand(
-        state,
-        context.timestamp,
-        (document, selection) => splitParagraph(document, selection, context)
-      );
-    case "runtime.set-read-only":
-      return createTransaction(
-        {
-          ...state,
-          readOnly: command.readOnly
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false
-        }
-      );
-    case "runtime.focus":
-      return createTransaction(
-        {
-          ...state,
-          runtime: {
-            ...state.runtime,
-            hasFocus: command.focused
-          }
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false
-        }
-      );
-    case "warning.add": {
-      if (state.warnings.some((warning) => warning.warningId === command.warning.warningId)) {
-        return createTransaction(state, {
-          historyBoundary: "skip",
-          markDirty: false
-        });
-      }
-      const warnings = [...state.warnings, command.warning];
-      return createTransaction(
-        {
-          ...state,
-          warnings,
-          compatibility: {
-            ...state.compatibility,
-            generatedAt: context.timestamp,
-            warnings
-          }
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false,
-          effects: {
-            warningsAdded: [command.warning]
-          }
-        }
-      );
-    }
-    case "warning.clear": {
-      const existing = state.warnings.find((warning) => warning.warningId === command.warningId);
-      if (!existing) {
-        return createTransaction(state, {
-          historyBoundary: "skip",
-          markDirty: false
-        });
-      }
-      const warnings = state.warnings.filter((warning) => warning.warningId !== command.warningId);
-      return createTransaction(
-        {
-          ...state,
-          warnings,
-          compatibility: {
-            ...state.compatibility,
-            generatedAt: context.timestamp,
-            warnings
-          }
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false,
-          effects: {
-            warningsCleared: [
-              {
-                warningId: existing.warningId,
-                code: existing.code
-              }
-            ]
-          }
-        }
-      );
-    }
-    case "comment.add": {
-      const comments = {
-        ...state.document.review.comments,
-        [command.comment.commentId]: normalizeCommentThreadRecord(command.comment)
-      };
-      return createTransaction(
-        {
-          ...state,
-          document: {
-            ...state.document,
-            updatedAt: context.timestamp,
-            review: {
-              ...state.document.review,
-              comments
-            }
-          },
-          runtime: {
-            ...state.runtime,
-            activeCommentId: command.comment.commentId
-          }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          effects: {
-            commentAdded: {
-              commentId: command.comment.commentId,
-              anchor: command.comment.anchor
-            }
-          }
-        }
-      );
-    }
-    case "comment.open":
-      return createTransaction(
-        {
-          ...state,
-          runtime: {
-            ...state.runtime,
-            activeCommentId: command.commentId
-          }
-        },
-        {
-          historyBoundary: "skip",
-          markDirty: false
-        }
-      );
-    case "comment.resolve": {
-      const existing = state.document.review.comments[command.commentId];
-      if (!existing) {
-        return createTransaction(state, {
-          historyBoundary: "skip",
-          markDirty: false
-        });
-      }
-      const comments = {
-        ...state.document.review.comments,
-        [command.commentId]: {
-          ...existing,
-          status: existing.anchor.kind === "detached" ? "detached" : "resolved",
-          resolution: {
-            resolvedAt: context.timestamp,
-            resolvedBy: command.resolvedBy ?? existing.createdBy ?? existing.authorId ?? existing.entries?.[0]?.authorId ?? "unknown"
-          },
-          isResolved: true,
-          resolvedAt: context.timestamp
-        }
-      };
-      return createTransaction(
-        {
-          ...state,
-          document: {
-            ...state.document,
-            updatedAt: context.timestamp,
-            review: {
-              ...state.document.review,
-              comments
-            }
-          }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          effects: {
-            commentResolved: {
-              commentId: command.commentId
-            }
-          }
-        }
-      );
-    }
-    case "comment.reopen": {
-      const existingThread = state.document.review.comments[command.commentId];
-      if (!existingThread || existingThread.status === "detached") {
-        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-      }
-      const reopenedComments = {
-        ...state.document.review.comments,
-        [command.commentId]: {
-          ...existingThread,
-          status: "open",
-          isResolved: false,
-          resolvedAt: void 0,
-          resolution: void 0
-        }
-      };
-      return createTransaction(
-        {
-          ...state,
-          document: {
-            ...state.document,
-            updatedAt: context.timestamp,
-            review: { ...state.document.review, comments: reopenedComments }
-          },
-          runtime: { ...state.runtime, activeCommentId: command.commentId }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          effects: { commentReopened: { commentId: command.commentId } }
-        }
-      );
-    }
-    case "comment.add-reply": {
-      const threadForReply = state.document.review.comments[command.commentId];
-      if (!threadForReply) {
-        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-      }
-      if (threadForReply.status === "resolved" || threadForReply.status === "detached") {
-        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-      }
-      const entryId = `${command.commentId}-entry-${(threadForReply.entries?.length ?? 0) + 1}`;
-      const newEntry = {
-        entryId,
-        authorId: command.authorId ?? threadForReply.createdBy ?? "unknown",
-        body: command.body,
-        createdAt: context.timestamp
-      };
-      const updatedThread = {
-        ...threadForReply,
-        entries: [...threadForReply.entries ?? [], newEntry]
-      };
-      const replyComments = {
-        ...state.document.review.comments,
-        [command.commentId]: updatedThread
-      };
-      return createTransaction(
-        {
-          ...state,
-          document: {
-            ...state.document,
-            updatedAt: context.timestamp,
-            review: { ...state.document.review, comments: replyComments }
-          }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          effects: { commentReplyAdded: { commentId: command.commentId } }
-        }
-      );
-    }
-    case "comment.edit-body": {
-      const threadToEdit = state.document.review.comments[command.commentId];
-      if (!threadToEdit || !threadToEdit.entries?.length) {
-        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-      }
-      const editedEntries = [...threadToEdit.entries];
-      editedEntries[0] = { ...editedEntries[0], body: command.body };
-      const editedThread = {
-        ...threadToEdit,
-        body: command.body,
-        entries: editedEntries
-      };
-      const editedComments = {
-        ...state.document.review.comments,
-        [command.commentId]: editedThread
-      };
-      return createTransaction(
-        {
-          ...state,
-          document: {
-            ...state.document,
-            updatedAt: context.timestamp,
-            review: { ...state.document.review, comments: editedComments }
-          }
-        },
-        {
-          historyBoundary: "push",
-          markDirty: true,
-          effects: { commentBodyEdited: { commentId: command.commentId } }
-        }
-      );
-    }
-    case "change.accept":
-      return applyReviewCommand(
-        state,
-        createAcceptRevisionCommand(command.changeId, command.origin),
-        context.timestamp
-      );
-    case "change.reject":
-      return applyReviewCommand(
-        state,
-        createRejectRevisionCommand(command.changeId, command.origin),
-        context.timestamp
-      );
-    case "change.accept-all":
-      return applyReviewCommand(
-        state,
-        {
-          type: "review.accept-all-revisions",
-          ...command.origin ? { origin: command.origin } : {}
-        },
-        context.timestamp
-      );
-    case "change.reject-all":
-      return applyReviewCommand(
-        state,
-        {
-          type: "review.reject-all-revisions",
-          ...command.origin ? { origin: command.origin } : {}
-        },
-        context.timestamp
-      );
-  }
-}
-function remapSelection(selection, mapping) {
-  const activeRange = mapAnchor(selection.activeRange, mapping);
-  if (activeRange.kind === "range") {
-    return {
-      anchor: activeRange.range.from,
-      head: activeRange.range.to,
-      isCollapsed: activeRange.range.from === activeRange.range.to,
-      activeRange
-    };
-  }
-  if (activeRange.kind === "node") {
-    return {
-      anchor: activeRange.at,
-      head: activeRange.at,
-      isCollapsed: true,
-      activeRange
-    };
-  }
-  return {
-    anchor: selection.anchor,
-    head: selection.head,
-    isCollapsed: selection.anchor === selection.head,
-    activeRange
-  };
-}
-function selectionChanged(left, right) {
-  return left.anchor !== right.anchor || left.head !== right.head || left.isCollapsed !== right.isCollapsed || !areAnchorsEqual(left.activeRange, right.activeRange);
-}
-function createTransaction(nextState, options) {
-  return {
-    nextState,
-    mapping: options.mapping ?? createEmptyMapping(),
-    historyBoundary: options.historyBoundary,
-    markDirty: options.markDirty,
-    effects: {
-      warningsAdded: options.effects?.warningsAdded ?? [],
-      warningsCleared: options.effects?.warningsCleared ?? [],
-      commentAdded: options.effects?.commentAdded,
-      commentResolved: options.effects?.commentResolved,
-      changeAccepted: options.effects?.changeAccepted,
-      changeRejected: options.effects?.changeRejected,
-      revisionAuthored: options.effects?.revisionAuthored,
-      commandBlocked: options.effects?.commandBlocked
-    }
-  };
-}
-function normalizeSelection(selection) {
-  const activeRange = normalizeSelectionAnchor(
-    selection.activeRange,
-    selection.anchor,
-    selection.head
-  );
-  if (activeRange.kind === "range") {
-    return {
-      anchor: activeRange.range.from,
-      head: activeRange.range.to,
-      isCollapsed: activeRange.range.from === activeRange.range.to,
-      activeRange
-    };
-  }
-  if (activeRange.kind === "node") {
-    return {
-      anchor: activeRange.at,
-      head: activeRange.at,
-      isCollapsed: true,
-      activeRange
-    };
-  }
-  return {
-    anchor: activeRange.lastKnownRange.from,
-    head: activeRange.lastKnownRange.to,
-    isCollapsed: activeRange.lastKnownRange.from === activeRange.lastKnownRange.to,
-    activeRange
-  };
-}
-function normalizeSelectionAnchor(value, anchor, head) {
-  if (!value || typeof value !== "object") {
-    return createRangeAnchor(anchor, head, DEFAULT_BOUNDARY_ASSOC);
-  }
-  const record = value;
-  switch (record.kind) {
-    case "range": {
-      const assoc = normalizeBoundaryAssoc(record.assoc);
-      const internalRange = record.range;
-      if (internalRange && typeof internalRange === "object" && typeof internalRange.from === "number" && typeof internalRange.to === "number") {
-        return createRangeAnchor(
-          internalRange.from,
-          internalRange.to,
-          assoc
-        );
-      }
-      if (typeof record.from === "number" && typeof record.to === "number") {
-        return createRangeAnchor(record.from, record.to, assoc);
-      }
-      return createRangeAnchor(anchor, head, assoc);
-    }
-    case "node":
-      return createNodeAnchor(
-        typeof record.at === "number" ? record.at : anchor,
-        normalizeAssoc(record.assoc)
-      );
-    case "detached": {
-      const lastKnownRange = record.lastKnownRange;
-      if (lastKnownRange && typeof lastKnownRange === "object" && typeof lastKnownRange.from === "number" && typeof lastKnownRange.to === "number") {
-        return createDetachedAnchor(
-          {
-            from: lastKnownRange.from,
-            to: lastKnownRange.to
-          },
-          normalizeDetachedReason(record.reason)
-        );
-      }
-      return createDetachedAnchor({ from: anchor, to: head }, normalizeDetachedReason(record.reason));
-    }
-    default:
-      return createRangeAnchor(anchor, head, DEFAULT_BOUNDARY_ASSOC);
-  }
-}
-function normalizeBoundaryAssoc(value) {
-  if (value && typeof value === "object") {
-    const record = value;
-    return {
-      start: normalizeAssoc(record.start),
-      end: normalizeAssoc(record.end)
-    };
-  }
-  return DEFAULT_BOUNDARY_ASSOC;
-}
-function normalizeAssoc(value) {
-  return value === -1 ? -1 : 1;
-}
-function normalizeDetachedReason(value) {
-  if (value === "deleted" || value === "invalidatedByStructureChange" || value === "importAmbiguity") {
-    return value;
-  }
-  return "importAmbiguity";
-}
-function applyTextCommand(state, timestamp, apply) {
-  if (state.readOnly) {
-    return createTransaction(state, {
-      historyBoundary: "skip",
-      markDirty: false
-    });
-  }
-  const result = apply(state.document, state.selection);
-  const reviewState = remapReviewStateAfterContentChange(
-    state,
-    result.document,
-    result.mapping
-  );
-  return createTransaction(
-    {
-      ...state,
-      document: reviewState.document,
-      selection: result.selection,
-      warnings: reviewState.warnings,
-      runtime: {
-        ...state.runtime,
-        activeCommentId: reviewState.activeCommentId
-      }
-    },
-    {
-      historyBoundary: "push",
-      markDirty: true,
-      mapping: result.mapping,
-      effects: reviewState.effects
-    }
-  );
-}
-function applyReviewCommand(state, command, timestamp) {
-  if (state.readOnly) {
-    return createTransaction(state, {
-      historyBoundary: "skip",
-      markDirty: false
-    });
-  }
-  const result = applyRevisionRuntimeCommand({
-    state: {
-      document: state.document,
-      store: createRevisionStoreFromState(state)
-    },
-    command,
-    timestamp
-  });
-  const hasAppliedOutcome = result.outcomes.some((outcome) => outcome.kind === "applied");
-  if (!hasAppliedOutcome) {
-    return createTransaction(state, {
-      historyBoundary: "skip",
-      markDirty: false
-    });
-  }
-  let selection = state.selection;
-  let comments = result.document.review.comments;
-  let warnings = state.warnings;
-  let activeCommentId = state.runtime.activeCommentId;
-  const mappingSteps = [];
-  for (const entry of result.mappings) {
-    if (entry.steps === 0) {
-      continue;
-    }
-    selection = remapSelection(selection, entry.mapping);
-    mappingSteps.push(...entry.mapping.steps);
-    const remappedComments = remapCommentThreads({
-      comments,
-      mapping: entry.mapping,
-      nextContent: result.document.content,
-      existingWarnings: mapWarningsThroughMapping(warnings, entry.mapping)
-    });
-    comments = remappedComments.comments;
-    warnings = remappedComments.warnings;
-    activeCommentId = activeCommentId && comments[activeCommentId] ? activeCommentId : void 0;
-  }
-  warnings = mergeDetachedRevisionWarnings(result.store, warnings);
-  const nextDocument = {
-    ...result.document,
-    review: {
-      ...result.document.review,
-      comments,
-      revisions: toEditorRevisionRecords(result.store)
-    }
-  };
-  const appliedRevisionIds = result.effects.appliedRevisionIds;
-  return createTransaction(
-    {
-      ...state,
-      document: nextDocument,
-      selection,
-      warnings,
-      runtime: {
-        ...state.runtime,
-        activeCommentId
-      }
-    },
-    {
-      historyBoundary: "push",
-      markDirty: true,
-      mapping: combineMappingSteps(mappingSteps),
-      effects: {
-        ...buildWarningEffects(state.warnings, warnings),
-        changeAccepted: command.type === "review.accept-revision" && appliedRevisionIds[0] ? {
-          changeId: appliedRevisionIds[0]
-        } : void 0,
-        changeRejected: command.type === "review.reject-revision" && appliedRevisionIds[0] ? {
-          changeId: appliedRevisionIds[0]
-        } : void 0
-      }
-    }
-  );
-}
-function remapReviewStateAfterContentChange(state, nextDocument, mapping) {
-  const mappedWarnings = mapWarningsThroughMapping(state.warnings, mapping);
-  const remappedComments = remapCommentThreads({
-    comments: nextDocument.review.comments,
-    mapping,
-    nextContent: nextDocument.content,
-    existingWarnings: mappedWarnings
-  });
-  const revisions = Object.fromEntries(
-    Object.entries(nextDocument.review.revisions).map(([changeId, revision]) => [
-      changeId,
-      {
-        ...revision,
-        anchor: mapAnchor(revision.anchor, mapping)
-      }
-    ])
-  );
-  const activeCommentId = state.runtime.activeCommentId && remappedComments.comments[state.runtime.activeCommentId] ? state.runtime.activeCommentId : void 0;
-  const warnings = remappedComments.warnings;
-  return {
-    document: {
-      ...nextDocument,
-      review: {
-        ...nextDocument.review,
-        comments: remappedComments.comments,
-        revisions
-      }
-    },
-    warnings,
-    activeCommentId,
-    effects: buildWarningEffects(state.warnings, warnings)
-  };
-}
-function createRevisionStoreFromState(state) {
-  return {
-    version: "revision-store/1",
-    revisions: Object.fromEntries(
-      Object.values(state.document.review.revisions).map((revision) => [
-        revision.changeId,
-        {
-          revisionId: revision.changeId,
-          kind: revision.kind,
-          anchor: revision.anchor,
-          authorId: revision.authorId ?? "unknown",
-          createdAt: revision.createdAt,
-          status: revision.status === "open" ? "active" : revision.status,
-          warningIds: [...revision.warningIds ?? []],
-          metadata: {
-            source: revision.metadata?.source ?? "runtime",
-            storyTarget: revision.metadata?.storyTarget,
-            preserveOnlyReason: revision.metadata?.preserveOnlyReason,
-            importedRevisionForm: revision.metadata?.importedRevisionForm,
-            originalRevisionType: revision.metadata?.originalRevisionType,
-            ooxmlRevisionId: revision.metadata?.ooxmlRevisionId
-          }
-        }
-      ])
-    )
-  };
-}
-function toEditorRevisionRecords(store) {
-  return Object.fromEntries(
-    Object.values(store.revisions).map((revision) => [
-      revision.revisionId,
-      {
-        changeId: revision.revisionId,
-        kind: revision.kind,
-        anchor: revision.anchor,
-        authorId: revision.authorId,
-        createdAt: revision.createdAt,
-        warningIds: [...revision.warningIds],
-        metadata: {
-          source: revision.metadata.source,
-          storyTarget: revision.metadata.storyTarget,
-          preserveOnlyReason: revision.metadata.preserveOnlyReason,
-          importedRevisionForm: revision.metadata.importedRevisionForm,
-          originalRevisionType: revision.metadata.originalRevisionType,
-          ooxmlRevisionId: revision.metadata.ooxmlRevisionId
-        },
-        status: revision.status === "active" ? "open" : revision.status
-      }
-    ])
-  );
-}
-function mapWarningsThroughMapping(warnings, mapping) {
-  return warnings.map(
-    (warning) => warning.affectedAnchor ? {
-      ...warning,
-      affectedAnchor: mapAnchor(warning.affectedAnchor, mapping)
-    } : warning
-  );
-}
-function buildWarningEffects(previousWarnings, nextWarnings) {
-  const previousById = new Set(previousWarnings.map((warning) => warning.warningId));
-  const nextById = new Set(nextWarnings.map((warning) => warning.warningId));
-  return {
-    warningsAdded: nextWarnings.filter((warning) => !previousById.has(warning.warningId)),
-    warningsCleared: previousWarnings.filter((warning) => !nextById.has(warning.warningId)).map((warning) => ({
-      warningId: warning.warningId,
-      code: warning.code
-    }))
-  };
-}
-function mergeDetachedRevisionWarnings(store, existingWarnings) {
-  const retainedWarnings = existingWarnings.filter(
-    (warning) => warning.code !== "revision_anchor_detached" || !warning.details || typeof warning.details.changeId !== "string" || store.revisions[warning.details.changeId]?.status === "detached"
-  );
-  const knownDetachedIds = new Set(
-    retainedWarnings.filter((warning) => warning.code === "revision_anchor_detached").map(
-      (warning) => typeof warning.details?.changeId === "string" ? warning.details.changeId : void 0
-    ).filter((value) => Boolean(value))
-  );
-  const detachedWarnings = Object.values(store.revisions).filter(
-    (revision) => revision.status === "detached" && !knownDetachedIds.has(revision.revisionId)
-  ).map((revision) => ({
-    warningId: `warning:revision-anchor-detached:${revision.revisionId}`,
-    code: "revision_anchor_detached",
-    severity: "warning",
-    message: `Revision ${revision.revisionId} detached after review remapping.`,
-    source: "review",
-    affectedAnchor: revision.anchor.kind === "detached" ? revision.anchor : void 0,
-    details: {
-      changeId: revision.revisionId,
-      reason: revision.anchor.kind === "detached" ? revision.anchor.reason : void 0
-    }
-  }));
-  return [...retainedWarnings, ...detachedWarnings];
-}
-function combineMappingSteps(steps) {
-  return steps.length > 0 ? {
-    steps
-  } : createEmptyMapping();
-}
-var suggestingRevisionCounter = 0;
-function createSuggestingRevisionId(existing, timestamp) {
-  suggestingRevisionCounter += 1;
-  const ts = timestamp.replace(/[^0-9]/gu, "");
-  let id = `change-${ts}-s${suggestingRevisionCounter}`;
-  while (existing[id]) {
-    suggestingRevisionCounter += 1;
-    id = `change-${ts}-s${suggestingRevisionCounter}`;
-  }
-  return id;
-}
-function createAuthoredRevision(existing, kind, from, to, authorId, timestamp) {
-  const changeId = createSuggestingRevisionId(existing, timestamp);
-  return {
-    changeId,
-    kind,
-    anchor: {
-      kind: "range",
-      range: { from, to },
-      assoc: { start: 1, end: -1 }
-    },
-    authorId,
-    createdAt: timestamp,
-    warningIds: [],
-    metadata: {
-      source: "runtime"
-    },
-    status: "open"
-  };
-}
-function createSuggestingUnsupportedTransaction(state, message) {
-  return createTransaction(state, {
-    historyBoundary: "skip",
-    markDirty: false,
-    effects: {
-      commandBlocked: {
-        code: "suggesting_unsupported",
-        message
-      }
-    }
-  });
-}
-function isSingleParagraphSuggestingRange(document, from, to) {
-  const ranges = [];
-  let cursor = 0;
-  let previousWasParagraph = false;
-  for (const block of document.content.children) {
-    if (block.type === "paragraph") {
-      if (previousWasParagraph) {
-        cursor += 1;
-      }
-      const start = cursor;
-      cursor += block.children.reduce((size, child) => {
-        if (child.type === "text") {
-          return size + child.text.length;
-        }
-        if (child.type === "hyperlink") {
-          return size + child.children.reduce((childSize, entry) => {
-            if (entry.type === "text") {
-              return childSize + entry.text.length;
-            }
-            return childSize + 1;
-          }, 0);
-        }
-        return size + 1;
-      }, 0);
-      ranges.push({ start, end: cursor });
-      previousWasParagraph = true;
-      continue;
-    }
-    cursor += 1;
-    previousWasParagraph = false;
-  }
-  return ranges.some((range) => from >= range.start && to <= range.end);
-}
-function applySuggestingInsert(state, text, context) {
-  if (state.readOnly) {
-    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-  }
-  const authorId = context.defaultAuthorId ?? "unknown";
-  const selection = state.selection;
-  const from = Math.min(selection.anchor, selection.head);
-  const to = Math.max(selection.anchor, selection.head);
-  const isCollapsed = from === to;
-  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
-    return createSuggestingUnsupportedTransaction(
-      state,
-      "Suggesting mode does not yet support multi-paragraph replacement ranges."
-    );
-  }
-  if (isCollapsed) {
-    const result2 = insertText(state.document, selection, text, { timestamp: context.timestamp });
-    const insertedFrom2 = from;
-    const insertedTo2 = from + Array.from(text).length;
-    const reviewState2 = remapReviewStateAfterContentChange(
-      state,
-      result2.document,
-      result2.mapping
-    );
-    const adjacentInsertion = findAdjacentAuthoredInsertion(
-      reviewState2.document.review.revisions,
-      insertedFrom2
-    );
-    let finalRevisionId;
-    let finalRevisions;
-    if (adjacentInsertion && adjacentInsertion.anchor.kind === "range") {
-      const extended = {
-        ...adjacentInsertion,
-        anchor: {
-          kind: "range",
-          range: { from: adjacentInsertion.anchor.range.from, to: insertedTo2 },
-          assoc: { start: 1, end: -1 }
-        }
-      };
-      finalRevisionId = extended.changeId;
-      finalRevisions = {
-        ...reviewState2.document.review.revisions,
-        [extended.changeId]: extended
-      };
-    } else {
-      const revision = createAuthoredRevision(
-        reviewState2.document.review.revisions,
-        "insertion",
-        insertedFrom2,
-        insertedTo2,
-        authorId,
-        context.timestamp
-      );
-      finalRevisionId = revision.changeId;
-      finalRevisions = {
-        ...reviewState2.document.review.revisions,
-        [revision.changeId]: revision
-      };
-    }
-    const finalDocument2 = {
-      ...reviewState2.document,
-      review: {
-        ...reviewState2.document.review,
-        revisions: finalRevisions
-      }
-    };
-    return createTransaction(
-      {
-        ...state,
-        document: finalDocument2,
-        selection: result2.selection,
-        warnings: reviewState2.warnings,
-        runtime: {
-          ...state.runtime,
-          activeCommentId: reviewState2.activeCommentId
-        }
-      },
-      {
-        historyBoundary: "push",
-        markDirty: true,
-        mapping: result2.mapping,
-        effects: {
-          ...reviewState2.effects,
-          revisionAuthored: { changeId: finalRevisionId, kind: "insertion" }
-        }
-      }
-    );
-  }
-  const insertSelection = createSelectionSnapshot(to, to);
-  const result = insertText(state.document, insertSelection, text, { timestamp: context.timestamp });
-  const insertedFrom = to;
-  const insertedTo = to + Array.from(text).length;
-  const reviewState = remapReviewStateAfterContentChange(
-    state,
-    result.document,
-    result.mapping
-  );
-  const deletionRevision = createAuthoredRevision(
-    reviewState.document.review.revisions,
-    "deletion",
-    from,
-    to,
-    authorId,
-    context.timestamp
-  );
-  const insertionRevision = createAuthoredRevision(
-    {
-      ...reviewState.document.review.revisions,
-      [deletionRevision.changeId]: deletionRevision
-    },
-    "insertion",
-    insertedFrom,
-    insertedTo,
-    authorId,
-    context.timestamp
-  );
-  const finalDocument = {
-    ...reviewState.document,
-    review: {
-      ...reviewState.document.review,
-      revisions: {
-        ...reviewState.document.review.revisions,
-        [deletionRevision.changeId]: deletionRevision,
-        [insertionRevision.changeId]: insertionRevision
-      }
-    }
-  };
-  const caretPos = insertedTo;
-  return createTransaction(
-    {
-      ...state,
-      document: finalDocument,
-      selection: createSelectionSnapshot(caretPos, caretPos),
-      warnings: reviewState.warnings,
-      runtime: {
-        ...state.runtime,
-        activeCommentId: reviewState.activeCommentId
-      }
-    },
-    {
-      historyBoundary: "push",
-      markDirty: true,
-      mapping: result.mapping,
-      effects: {
-        ...reviewState.effects,
-        revisionAuthored: { changeId: insertionRevision.changeId, kind: "insertion" }
-      }
-    }
-  );
-}
-function applySuggestingDelete(state, direction, context) {
-  if (state.readOnly) {
-    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-  }
-  const authorId = context.defaultAuthorId ?? "unknown";
-  const selection = state.selection;
-  const from = Math.min(selection.anchor, selection.head);
-  const to = Math.max(selection.anchor, selection.head);
-  const isCollapsed = from === to;
-  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
-    return createSuggestingUnsupportedTransaction(
-      state,
-      "Suggesting mode does not yet support multi-paragraph deletion ranges."
-    );
-  }
-  let deleteFrom;
-  let deleteTo;
-  if (isCollapsed) {
-    if (direction === "backward") {
-      deleteFrom = Math.max(0, from - 1);
-      deleteTo = from;
-    } else {
-      deleteFrom = from;
-      deleteTo = from + 1;
-    }
-  } else {
-    deleteFrom = from;
-    deleteTo = to;
-  }
-  if (deleteFrom === deleteTo) {
-    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-  }
-  const existingDeletion = findOverlappingAuthoredDeletion(
-    state.document.review.revisions,
-    deleteFrom,
-    deleteTo
-  );
-  if (existingDeletion) {
-    const extendedFrom = Math.min(
-      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.from : deleteFrom,
-      deleteFrom
-    );
-    const extendedTo = Math.max(
-      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.to : deleteTo,
-      deleteTo
-    );
-    const updatedRevision = {
-      ...existingDeletion,
-      anchor: {
-        kind: "range",
-        range: { from: extendedFrom, to: extendedTo },
-        assoc: { start: 1, end: -1 }
-      }
-    };
-    const nextDocument2 = {
-      ...state.document,
-      updatedAt: context.timestamp,
-      review: {
-        ...state.document.review,
-        revisions: {
-          ...state.document.review.revisions,
-          [updatedRevision.changeId]: updatedRevision
-        }
-      }
-    };
-    const caretPos2 = direction === "backward" ? deleteFrom : deleteTo;
-    return createTransaction(
-      {
-        ...state,
-        document: nextDocument2,
-        selection: createSelectionSnapshot(caretPos2, caretPos2)
-      },
-      {
-        historyBoundary: "push",
-        markDirty: true,
-        effects: {
-          revisionAuthored: { changeId: updatedRevision.changeId, kind: "deletion" }
-        }
-      }
-    );
-  }
-  const revision = createAuthoredRevision(
-    state.document.review.revisions,
-    "deletion",
-    deleteFrom,
-    deleteTo,
-    authorId,
-    context.timestamp
-  );
-  const nextDocument = {
-    ...state.document,
-    updatedAt: context.timestamp,
-    review: {
-      ...state.document.review,
-      revisions: {
-        ...state.document.review.revisions,
-        [revision.changeId]: revision
-      }
-    }
-  };
-  const caretPos = direction === "backward" ? deleteFrom : deleteTo;
-  return createTransaction(
-    {
-      ...state,
-      document: nextDocument,
-      selection: createSelectionSnapshot(caretPos, caretPos)
-    },
-    {
-      historyBoundary: "push",
-      markDirty: true,
-      effects: {
-        revisionAuthored: { changeId: revision.changeId, kind: "deletion" }
-      }
-    }
-  );
-}
-function applySuggestingInsertUnit(state, unitType, context) {
-  if (state.readOnly) {
-    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
-  }
-  const authorId = context.defaultAuthorId ?? "unknown";
-  const selection = state.selection;
-  const from = Math.min(selection.anchor, selection.head);
-  const to = Math.max(selection.anchor, selection.head);
-  if (from !== to && !isSingleParagraphSuggestingRange(state.document, from, to)) {
-    return createSuggestingUnsupportedTransaction(
-      state,
-      "Suggesting mode does not yet support multi-paragraph replacement ranges."
-    );
-  }
-  const insertPos = to;
-  const insertSelection = createSelectionSnapshot(insertPos, insertPos);
-  const applyFn = unitType === "tab" ? insertTab : insertHardBreak;
-  const result = applyFn(state.document, insertSelection, { timestamp: context.timestamp });
-  const reviewState = remapReviewStateAfterContentChange(
-    state,
-    result.document,
-    result.mapping
-  );
-  const deletionRevision = from !== to ? createAuthoredRevision(
-    reviewState.document.review.revisions,
-    "deletion",
-    from,
-    to,
-    authorId,
-    context.timestamp
-  ) : void 0;
-  const insertionRevision = createAuthoredRevision(
-    {
-      ...reviewState.document.review.revisions,
-      ...deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {}
-    },
-    "insertion",
-    insertPos,
-    insertPos + 1,
-    authorId,
-    context.timestamp
-  );
-  const finalDocument = {
-    ...reviewState.document,
-    review: {
-      ...reviewState.document.review,
-      revisions: {
-        ...reviewState.document.review.revisions,
-        ...deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {},
-        [insertionRevision.changeId]: insertionRevision
-      }
-    }
-  };
-  return createTransaction(
-    {
-      ...state,
-      document: finalDocument,
-      selection: result.selection,
-      warnings: reviewState.warnings,
-      runtime: {
-        ...state.runtime,
-        activeCommentId: reviewState.activeCommentId
-      }
-    },
-    {
-      historyBoundary: "push",
-      markDirty: true,
-      mapping: result.mapping,
-      effects: {
-        ...reviewState.effects,
-        revisionAuthored: { changeId: insertionRevision.changeId, kind: "insertion" }
-      }
-    }
-  );
-}
-function findOverlappingAuthoredDeletion(revisions, from, to) {
-  for (const revision of Object.values(revisions)) {
-    if (revision.kind === "deletion" && revision.status === "open" && revision.metadata?.source === "runtime" && revision.anchor.kind === "range") {
-      const revFrom = revision.anchor.range.from;
-      const revTo = revision.anchor.range.to;
-      if (from >= revFrom && from <= revTo || to >= revFrom && to <= revTo || from === revTo || to === revFrom) {
-        return revision;
-      }
-    }
-  }
-  return void 0;
-}
-function findAdjacentAuthoredInsertion(revisions, cursorAt) {
-  for (const revision of Object.values(revisions)) {
-    if (revision.kind === "insertion" && revision.status === "open" && revision.metadata?.source === "runtime" && revision.anchor.kind === "range" && revision.anchor.range.to === cursorAt) {
-      return revision;
-    }
-  }
-  return void 0;
-}
-
-// src/validation/compatibility-report.ts
-var COMPATIBILITY_REPORT_VERSION = "compatibility-report/1";
-function createCompatibilityReport(input) {
-  const diagnostics = createDiagnostics(input);
-  return Object.freeze({
-    reportVersion: COMPATIBILITY_REPORT_VERSION,
-    generatedAt: input.generatedAt,
-    blockExport: diagnosticsBlockExport(diagnostics, input.blockExport),
-    featureEntries: diagnostics.featureEntries,
-    warnings: diagnostics.warnings,
-    errors: diagnostics.errors
-  });
-}
-function mergeCompatibilityReports(reports, options) {
-  return createCompatibilityReport({
-    generatedAt: options.generatedAt,
-    blockExport: options.blockExport ?? reports.some((report) => report.blockExport),
-    featureEntries: flattenUnique(reports.flatMap((report) => report.featureEntries)),
-    warnings: flattenUnique(reports.flatMap((report) => report.warnings)),
-    errors: flattenUnique(reports.flatMap((report) => report.errors))
-  });
-}
-function flattenUnique(items) {
-  const deduped = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    deduped.set(JSON.stringify(item), item);
-  }
-  return Object.freeze([...deduped.values()]);
-}
-
-// src/runtime/workflow-markup.ts
-var BLOCKED_IMPORT_FEATURE_KEYS = /* @__PURE__ */ new Set(["alt-chunk", "alternate-content", "custom-xml"]);
-function collectWorkflowMarkupSnapshot(input) {
-  const highlights = [];
-  const fields = [];
-  const opaqueFragments = [];
-  const surface = input.renderSnapshot.surface;
-  if (surface) {
-    collectSurfaceMarkup(
-      surface.blocks,
-      MAIN_STORY_TARGET,
-      input.preservation,
-      highlights,
-      opaqueFragments
-    );
-    for (const story of surface.secondaryStories) {
-      collectSurfaceMarkup(
-        story.blocks,
-        story.target,
-        input.preservation,
-        highlights,
-        opaqueFragments
-      );
-    }
-    fields.push(...collectFieldMarkup(surface, input.fieldSnapshot));
-  }
-  opaqueFragments.push(...collectOpaqueFragmentMarkup(input.preservation, opaqueFragments));
-  const comments = input.renderSnapshot.comments.threads.map((thread) => ({
-    markupId: `comment:${thread.commentId}`,
-    kind: "comment",
-    commentId: thread.commentId,
-    anchor: thread.anchor,
-    label: thread.anchorLabel,
-    excerpt: thread.excerpt,
-    status: thread.status,
-    warningCount: thread.warningCount,
-    entryCount: thread.entryCount,
-    createdAt: thread.createdAt,
-    createdBy: thread.createdBy
-  }));
-  const revisions = input.renderSnapshot.trackedChanges.revisions.map(
-    (revision) => ({
-      markupId: `revision:${revision.revisionId}`,
-      kind: "revision",
-      revisionId: revision.revisionId,
-      revisionKind: revision.kind,
-      anchor: revision.anchor,
-      label: revision.label,
-      excerpt: revision.excerpt,
-      status: revision.status,
-      actionability: revision.actionability,
-      authorId: revision.authorId,
-      createdAt: revision.createdAt,
-      preserveOnlyReason: revision.preserveOnlyReason
-    })
-  );
-  const protectedRanges = input.protectionSnapshot.ranges.filter(
-    (range) => typeof range.start === "number" && typeof range.end === "number"
-  ).map(
-    (range) => ({
-      markupId: `protected-range:${range.rangeId}`,
-      kind: "protected_range",
-      rangeId: range.rangeId,
-      anchor: createRangeAnchor2(range.start, range.end),
-      storyTarget: MAIN_STORY_TARGET,
-      label: `Protected range ${range.rangeId}`,
-      excerpt: range.enforcementReason,
-      enforced: range.enforced,
-      enforcementReason: range.enforcementReason,
-      editorGroup: range.editorGroup,
-      editor: range.editor
-    })
-  );
-  const items = [
-    ...highlights,
-    ...comments,
-    ...revisions,
-    ...fields,
-    ...protectedRanges,
-    ...opaqueFragments
-  ];
-  return {
-    totalCount: items.length,
-    items,
-    highlights,
-    comments,
-    revisions,
-    fields,
-    protectedRanges,
-    opaqueFragments
-  };
-}
-function deriveWorkflowCandidateRangesFromMarkup(snapshot, options = {}) {
-  const allowedKinds = options.kinds ? new Set(options.kinds) : null;
-  const includeDetached = options.includeDetached === true;
-  return snapshot.items.filter((item) => allowedKinds ? allowedKinds.has(item.kind) : true).filter((item) => includeDetached || item.anchor.kind !== "detached").map(
-    (item) => ({
-      candidateId: item.markupId,
-      storyTarget: item.storyTarget,
-      anchor: item.anchor,
-      label: item.label,
-      source: options.source ?? "host"
-    })
-  );
-}
-function collectSurfaceMarkup(blocks, storyTarget, preservation, highlights, opaqueFragments) {
-  for (const block of blocks) {
-    if (block.kind === "paragraph") {
-      for (const segment of block.segments) {
-        collectSegmentMarkup(segment, storyTarget, preservation, highlights, opaqueFragments);
-      }
-      continue;
-    }
-    if (block.kind === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          collectSurfaceMarkup(cell.content, storyTarget, preservation, highlights, opaqueFragments);
-        }
-      }
-      continue;
-    }
-    if (block.kind === "sdt_block") {
-      collectSurfaceMarkup(block.children, storyTarget, preservation, highlights, opaqueFragments);
-      continue;
-    }
-    const fragment = preservation.opaqueFragments[block.fragmentId];
-    const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
-    const blockedReasonCode = fragment && BLOCKED_IMPORT_FEATURE_KEYS.has(descriptor?.featureKey ?? "") ? "workflow_blocked_import" : "workflow_preserve_only";
-    opaqueFragments.push({
-      markupId: `opaque:${block.fragmentId}`,
-      kind: "opaque_fragment",
-      fragmentId: block.fragmentId,
-      warningId: block.warningId,
-      anchor: createRangeAnchor2(block.from, block.to),
-      storyTarget,
-      label: block.label,
-      excerpt: block.detail,
-      detail: block.detail,
-      blockedReasonCode
-    });
-  }
-}
-function collectSegmentMarkup(segment, storyTarget, preservation, highlights, opaqueFragments) {
-  if (segment.kind === "text" && segment.markAttrs?.backgroundColor) {
-    highlights.push({
-      markupId: `highlight:${storyTargetKey2(storyTarget)}:${segment.from}:${segment.to}:${segment.markAttrs.backgroundColor}`,
-      kind: "highlight",
-      anchor: createRangeAnchor2(segment.from, segment.to),
-      storyTarget,
-      label: `Highlight ${segment.markAttrs.backgroundColor}`,
-      excerpt: segment.text,
-      color: segment.markAttrs.backgroundColor,
-      text: segment.text
-    });
-    return;
-  }
-  if (segment.kind === "opaque_inline") {
-    const fragment = preservation.opaqueFragments[segment.fragmentId];
-    const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
-    const blockedReasonCode = fragment && BLOCKED_IMPORT_FEATURE_KEYS.has(descriptor?.featureKey ?? "") ? "workflow_blocked_import" : "workflow_preserve_only";
-    opaqueFragments.push({
-      markupId: `opaque:${segment.fragmentId}`,
-      kind: "opaque_fragment",
-      fragmentId: segment.fragmentId,
-      warningId: segment.warningId,
-      anchor: createRangeAnchor2(segment.from, segment.to),
-      storyTarget,
-      label: segment.label,
-      excerpt: segment.detail,
-      detail: segment.detail,
-      blockedReasonCode
-    });
-  }
-}
-function collectFieldMarkup(surface, fieldSnapshot) {
-  if (!surface) {
-    return [];
-  }
-  const stories = [
-    { blocks: surface.blocks, storyTarget: MAIN_STORY_TARGET },
-    ...surface.secondaryStories.map((story) => ({
-      blocks: story.blocks,
-      storyTarget: story.target
-    }))
-  ];
-  return fieldSnapshot.fields.flatMap((field) => {
-    const displayText = field.displayText.trim();
-    if (!displayText) {
-      return [];
-    }
-    for (const story of stories) {
-      const matches = searchSurfaceBlocks(story.blocks, displayText, { limit: 2 });
-      if (matches.length === 1) {
-        const match = matches[0];
-        return [
-          {
-            markupId: `field:${field.index}`,
-            kind: "field",
-            anchor: createRangeAnchor2(match.from, match.to),
-            storyTarget: story.storyTarget,
-            label: displayText,
-            excerpt: field.instruction,
-            fieldIndex: field.index,
-            fieldFamily: field.fieldFamily,
-            fieldTarget: field.fieldTarget,
-            refreshStatus: field.refreshStatus,
-            displayText: field.displayText
-          }
-        ];
-      }
-    }
-    return [];
-  });
-}
-function collectOpaqueFragmentMarkup(preservation, existing) {
-  const seen = new Set(existing.map((item) => item.fragmentId));
-  return Object.values(preservation.opaqueFragments).filter(
-    (fragment) => !seen.has(fragment.fragmentId) && fragment.packagePartName === "/word/document.xml"
-  ).map((fragment) => {
-    const descriptor = describeOpaqueFragment(fragment);
-    const blockedReasonCode = BLOCKED_IMPORT_FEATURE_KEYS.has(descriptor.featureKey) ? "workflow_blocked_import" : "workflow_preserve_only";
-    return {
-      markupId: `opaque:${fragment.fragmentId}`,
-      kind: "opaque_fragment",
-      fragmentId: fragment.fragmentId,
-      warningId: fragment.warningId,
-      anchor: createRangeAnchor2(fragment.lastKnownRange.from, fragment.lastKnownRange.to),
-      storyTarget: MAIN_STORY_TARGET,
-      label: descriptor.label,
-      excerpt: descriptor.detail,
-      detail: descriptor.detail,
-      blockedReasonCode
-    };
-  });
-}
-function createRangeAnchor2(from, to) {
-  return {
-    kind: "range",
-    from,
-    to,
-    assoc: {
-      start: -1,
-      end: 1
-    }
-  };
-}
-function storyTargetKey2(storyTarget) {
-  switch (storyTarget.kind) {
-    case "main":
-      return "main";
-    case "header":
-    case "footer":
-      return `${storyTarget.kind}:${storyTarget.relationshipId}:${storyTarget.variant}:${storyTarget.sectionIndex ?? "none"}`;
-    case "footnote":
-    case "endnote":
-      return `${storyTarget.kind}:${storyTarget.noteId}`;
-  }
-}
-
-// src/runtime/document-runtime.ts
-function createDocumentRuntime(options) {
-  const clock = options.clock ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const editorBuild = options.editorBuild ?? "dev";
-  let defaultAuthorId = options.defaultAuthorId;
-  const sessionId = createSessionId(options.documentId, clock());
-  const listeners = /* @__PURE__ */ new Set();
-  const eventListeners = /* @__PURE__ */ new Set();
-  const history = {
-    past: [],
-    future: []
-  };
-  let activeStory = MAIN_STORY_TARGET;
-  const storySelections = /* @__PURE__ */ new Map();
-  let viewState = createViewState(options.initialViewState);
-  let protectionSnapshot = options.protectionSnapshot ?? options.initialSessionState?.protectionSnapshot ?? options.initialSnapshot?.protectionSnapshot ?? {
-    hasDocumentProtection: false,
-    enforcementActive: false,
-    ranges: [],
-    enforcedRangeCount: 0,
-    preservedRangeCount: 0
-  };
-  let workflowOverlay = null;
-  let hostAnnotationOverlay = null;
-  const initialPersistedSnapshot = options.initialSessionState ? persistedSnapshotFromEditorSessionState(options.initialSessionState, {
-    savedAt: options.initialSessionState.updatedAt
-  }) : options.initialSnapshot;
-  let state = createEditorState({
-    documentId: options.documentId,
-    sessionId,
-    sourceLabel: options.sourceLabel,
-    readOnly: options.readOnly,
-    persistedSnapshot: initialPersistedSnapshot,
-    canonicalDocument: options.initialCanonicalDocument,
-    fatalError: options.fatalError
-  });
-  storySelections.set(storyTargetKey(MAIN_STORY_TARGET), state.selection);
-  let cachedSurface;
-  let cachedCompatibility;
-  let cachedComments;
-  let cachedTrackedChanges;
-  let cachedPageLayout;
-  let cachedNavigation;
-  let cachedViewStateSnapshot;
-  let cachedInteractionGuardSnapshot;
-  let cachedWorkflowScopeSnapshot;
-  let cachedWorkflowMarkupSnapshot;
-  function getCachedSurface(document, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
-    if (cachedSurface && cachedSurface.revisionToken === state.revisionToken && cachedSurface.activeStoryKey === activeStoryKey) {
-      return cachedSurface.snapshot;
-    }
-    const snapshot = createEditorSurfaceSnapshot(document, state.selection, nextActiveStory);
-    recordPerfSample("snapshot.surface");
-    incrementInvalidationCounter("runtime.snapshot.surfaceMisses");
-    cachedSurface = {
-      revisionToken: state.revisionToken,
-      activeStoryKey,
-      snapshot
-    };
-    return snapshot;
-  }
-  function getCachedCompatibilityReport(nextState) {
-    if (cachedCompatibility && cachedCompatibility.revisionToken === nextState.revisionToken && cachedCompatibility.warnings === nextState.warnings && cachedCompatibility.fatalError === nextState.fatalError) {
-      return cachedCompatibility.report;
-    }
-    const derived = createDerivedCompatibility(nextState);
-    recordPerfSample("snapshot.compatibility");
-    incrementInvalidationCounter("runtime.snapshot.compatibilityMisses");
-    const report = {
-      blockExport: derived.blockExport,
-      blockExportReasons: listBlockExportReasons(derived),
-      warningCount: derived.warnings.length,
-      errorCount: derived.errors.length,
-      featureEntries: derived.featureEntries.map(
-        (entry) => toPublicCompatibilityFeatureEntry(entry)
-      )
-    };
-    cachedCompatibility = {
-      revisionToken: nextState.revisionToken,
-      warnings: nextState.warnings,
-      fatalError: nextState.fatalError,
-      report
-    };
-    return report;
-  }
-  function getCachedCommentSidebarSnapshot(nextState) {
-    if (cachedComments && cachedComments.comments === nextState.document.review.comments && cachedComments.activeCommentId === nextState.runtime.activeCommentId) {
-      return cachedComments.snapshot;
-    }
-    const snapshot = toPublicCommentSidebarSnapshot(nextState);
-    cachedComments = {
-      comments: nextState.document.review.comments,
-      activeCommentId: nextState.runtime.activeCommentId,
-      snapshot
-    };
-    return snapshot;
-  }
-  function getCachedTrackedChangesSnapshot(nextState, _surface) {
-    if (cachedTrackedChanges && cachedTrackedChanges.revisions === nextState.document.review.revisions && cachedTrackedChanges.revisionToken === nextState.revisionToken) {
-      return cachedTrackedChanges.snapshot;
-    }
-    const snapshot = toPublicTrackedChangesSnapshot(nextState);
-    cachedTrackedChanges = {
-      revisions: nextState.document.review.revisions,
-      revisionToken: nextState.revisionToken,
-      snapshot
-    };
-    return snapshot;
-  }
-  function getCachedDocumentNavigationSnapshot(nextState, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
-    if (cachedNavigation && cachedNavigation.revisionToken === nextState.revisionToken && cachedNavigation.activeStoryKey === activeStoryKey) {
-      if (cachedNavigation.selectionHead === nextState.selection.head) {
-        return cachedNavigation.snapshot;
-      }
-      const snapshot2 = createDocumentNavigationSnapshot(
-        nextState.document,
-        nextState.selection.head,
-        nextActiveStory
-      );
-      if (snapshot2.activePageIndex === cachedNavigation.snapshot.activePageIndex && snapshot2.activeSectionIndex === cachedNavigation.snapshot.activeSectionIndex) {
-        cachedNavigation = {
-          revisionToken: nextState.revisionToken,
-          activeStoryKey,
-          selectionHead: nextState.selection.head,
-          snapshot: cachedNavigation.snapshot
-        };
-        return cachedNavigation.snapshot;
-      }
-      cachedNavigation = {
-        revisionToken: nextState.revisionToken,
-        activeStoryKey,
-        selectionHead: nextState.selection.head,
-        snapshot: snapshot2
-      };
-      return snapshot2;
-    }
-    const snapshot = createDocumentNavigationSnapshot(
-      nextState.document,
-      nextState.selection.head,
-      nextActiveStory
-    );
-    recordPerfSample("snapshot.navigation");
-    incrementInvalidationCounter("runtime.snapshot.navigationMisses");
-    cachedNavigation = {
-      revisionToken: nextState.revisionToken,
-      activeStoryKey,
-      selectionHead: nextState.selection.head,
-      snapshot
-    };
-    return snapshot;
-  }
-  function resolvePageLayoutActiveSectionIndex(nextState, nextActiveStory) {
-    if (nextActiveStory.kind === "main") {
-      return getCachedDocumentNavigationSnapshot(nextState, nextActiveStory).activeSectionIndex;
-    }
-    if ("sectionIndex" in nextActiveStory && typeof nextActiveStory.sectionIndex === "number") {
-      return nextActiveStory.sectionIndex;
-    }
-    return storyTargetKey(nextActiveStory);
-  }
-  function getCachedPageLayoutSnapshot(nextState, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
-    const activeSectionIndex = resolvePageLayoutActiveSectionIndex(
-      nextState,
-      nextActiveStory
-    );
-    if (cachedPageLayout && cachedPageLayout.revisionToken === nextState.revisionToken && cachedPageLayout.activeStoryKey === activeStoryKey && cachedPageLayout.activeSectionIndex === activeSectionIndex) {
-      return cachedPageLayout.snapshot;
-    }
-    const snapshot = derivePageLayoutSnapshot(nextState, nextActiveStory, storySelections);
-    cachedPageLayout = {
-      revisionToken: nextState.revisionToken,
-      activeStoryKey,
-      activeSectionIndex,
-      snapshot
-    };
-    return snapshot;
-  }
-  function evaluateWorkflowBlockedReasons(selection, commandType) {
-    const reasons = [];
-    const selectionBounds = {
-      from: Math.min(selection.anchor, selection.head),
-      to: Math.max(selection.anchor, selection.head)
-    };
-    const selectionRange = expandSelectionRange(selectionBounds);
-    const opaqueReason = deriveOpaqueWorkflowBlockedReason(selectionRange);
-    if (opaqueReason) {
-      reasons.push(opaqueReason);
-    }
-    if (state.readOnly) {
-      reasons.push({
-        code: "document_read_only",
-        message: "Document is in read-only mode."
-      });
-    }
-    if (viewState.documentMode === "viewing") {
-      reasons.push({
-        code: "document_viewing_mode",
-        message: "Document is in viewing mode."
-      });
-    }
-    if (isBlockedByProtection(protectionSnapshot, selection)) {
-      reasons.push({
-        code: "protected_range",
-        message: "Selection falls within a protected range."
-      });
-    }
-    const effectiveDocumentMode = getEffectiveDocumentMode(selection);
-    if (effectiveDocumentMode === "suggesting" && commandType) {
-      if (activeStory.kind !== "main" && SUGGESTING_SECONDARY_STORY_UNSUPPORTED_COMMANDS.has(commandType)) {
-        reasons.push({
-          code: "suggesting_unsupported",
-          message: "Suggesting mode is not yet export-safe in this story."
-        });
-      }
-      if (SUGGESTING_UNSUPPORTED_COMMANDS.has(commandType)) {
-        reasons.push({
-          code: "suggesting_unsupported",
-          message: `"${commandType}" is not supported in suggesting mode.`
-        });
-      }
-    }
-    if (workflowOverlay) {
-      const matchingScope = getMatchingWorkflowScope(selection);
-      if (!matchingScope && workflowOverlay.scopes.length > 0) {
-        reasons.push({
-          code: "outside_workflow_scope",
-          message: "Selection is outside any active workflow scope."
-        });
-      } else if (matchingScope) {
-        if (matchingScope.mode === "comment") {
-          const isCommentCommand = commandType?.startsWith("comment.") ?? false;
-          if (!isCommentCommand) {
-            reasons.push({
-              code: "workflow_comment_only",
-              message: `Scope "${matchingScope.label ?? matchingScope.scopeId}" allows comments only.`,
-              scopeId: matchingScope.scopeId,
-              workItemId: matchingScope.workItemId
-            });
-          }
-        } else if (matchingScope.mode === "view") {
-          reasons.push({
-            code: "workflow_view_only",
-            message: `Scope "${matchingScope.label ?? matchingScope.scopeId}" is view-only.`,
-            scopeId: matchingScope.scopeId,
-            workItemId: matchingScope.workItemId
-          });
-        }
-      }
-    }
-    return reasons;
-  }
-  function getMatchingWorkflowScope(selection) {
-    if (!workflowOverlay) {
-      return null;
-    }
-    const selectionBounds = {
-      from: Math.min(selection.anchor, selection.head),
-      to: Math.max(selection.anchor, selection.head)
-    };
-    const activeScopes = getEffectiveWorkflowScopes(workflowOverlay);
-    return activeScopes.find((scope) => {
-      if (scope.anchor.kind === "detached") return false;
-      const scopeFrom = scope.anchor.kind === "range" ? scope.anchor.from : scope.anchor.at;
-      const scopeTo = scope.anchor.kind === "range" ? scope.anchor.to : scope.anchor.at;
-      return selectionBounds.from >= scopeFrom && selectionBounds.to <= scopeTo;
-    }) ?? null;
-  }
-  function getEffectiveDocumentMode(selection) {
-    if (viewState.documentMode === "viewing") {
-      return "viewing";
-    }
-    const matchingScope = getMatchingWorkflowScope(selection);
-    if (matchingScope?.mode === "suggest") {
-      return "suggesting";
-    }
-    return viewState.documentMode;
-  }
-  function expandSelectionRange(range) {
-    return {
-      from: range.from,
-      to: range.to > range.from ? range.to : range.from + 1
-    };
-  }
-  function deriveOpaqueWorkflowBlockedReason(range) {
-    const targetPartPath = getStoryTargetOpaquePartPath(activeStory);
-    if (!targetPartPath) {
-      return null;
-    }
-    const fragments = findOpaqueFragmentsIntersectingRange(
-      state.document.preservation,
-      range
-    ).filter((fragment2) => fragment2.packagePartName === targetPartPath);
-    if (fragments.length === 0) {
-      return null;
-    }
-    const blockedImportFeatureKeys = /* @__PURE__ */ new Set([
-      "alt-chunk",
-      "alternate-content",
-      "custom-xml"
-    ]);
-    const blockedImportFragment = fragments.find(
-      (fragment2) => blockedImportFeatureKeys.has(describeOpaqueFragment(fragment2).featureKey)
-    ) ?? null;
-    const fragment = blockedImportFragment ?? fragments[0];
-    const descriptor = describeOpaqueFragment(fragment);
-    const isBlockedImport = blockedImportFragment !== null;
-    return {
-      code: isBlockedImport ? "workflow_blocked_import" : "workflow_preserve_only",
-      message: isBlockedImport ? `${descriptor.label} remains a blocked import and cannot be edited.` : `${descriptor.label} remains preserve-only and cannot be edited.`,
-      anchor: toPublicAnchorProjection(
-        createRangeAnchor(fragment.lastKnownRange.from, fragment.lastKnownRange.to, {
-          start: -1,
-          end: 1
-        })
-      ),
-      storyTarget: activeStory
-    };
-  }
-  function getStoryTargetOpaquePartPath(storyTarget) {
-    if (storyTarget.kind === "main") {
-      return "/word/document.xml";
-    }
-    if (storyTarget.kind === "header") {
-      return state.document.subParts?.headers.find(
-        (header) => header.relationshipId === storyTarget.relationshipId && header.variant === storyTarget.variant && header.sectionIndex === storyTarget.sectionIndex
-      )?.partPath ?? null;
-    }
-    if (storyTarget.kind === "footer") {
-      return state.document.subParts?.footers.find(
-        (footer) => footer.relationshipId === storyTarget.relationshipId && footer.variant === storyTarget.variant && footer.sectionIndex === storyTarget.sectionIndex
-      )?.partPath ?? null;
-    }
-    if (storyTarget.kind === "footnote") {
-      return "/word/footnotes.xml";
-    }
-    if (storyTarget.kind === "endnote") {
-      return "/word/endnotes.xml";
-    }
-    return null;
-  }
-  function deriveWorkflowScopeSnapshot() {
-    if (!workflowOverlay) return null;
-    const blockedReasons = getCachedInteractionGuardSnapshot().blockedReasons;
-    const activeItem = workflowOverlay.activeWorkItemId ? workflowOverlay.workItems?.find(
-      (item) => item.workItemId === workflowOverlay.activeWorkItemId
-    ) : void 0;
-    return {
-      overlayPresent: true,
-      activeWorkItemId: workflowOverlay.activeWorkItemId ?? null,
-      activeWorkItem: activeItem,
-      scopes: workflowOverlay.scopes,
-      candidates: workflowOverlay.candidates ?? [],
-      blockedReasons
-    };
-  }
-  function deriveHostAnnotationSnapshot() {
-    return {
-      totalCount: hostAnnotationOverlay?.annotations.length ?? 0,
-      annotations: structuredClone(hostAnnotationOverlay?.annotations ?? [])
-    };
-  }
-  function getEffectiveWorkflowScopes(overlay) {
-    const activeWorkItemId = overlay.activeWorkItemId ?? null;
-    const activeWorkItemScopeIds = activeWorkItemId === null ? null : new Set(
-      overlay.workItems?.find((item) => item.workItemId === activeWorkItemId)?.scopeIds ?? []
-    );
-    return overlay.scopes.filter((scope) => {
-      const scopeStoryTarget = scope.storyTarget ?? MAIN_STORY_TARGET;
-      if (!storyTargetsEqual(scopeStoryTarget, activeStory)) {
-        return false;
-      }
-      if (activeWorkItemId === null) {
-        return true;
-      }
-      return scope.workItemId === activeWorkItemId || activeWorkItemScopeIds?.has(scope.scopeId) === true;
-    });
-  }
-  function getCachedInteractionGuardSnapshot() {
-    const activeStoryKey = storyTargetKey(activeStory);
-    if (cachedInteractionGuardSnapshot && cachedInteractionGuardSnapshot.revisionToken === state.revisionToken && cachedInteractionGuardSnapshot.activeStoryKey === activeStoryKey && cachedInteractionGuardSnapshot.selection === state.selection && cachedInteractionGuardSnapshot.readOnly === state.readOnly && cachedInteractionGuardSnapshot.documentMode === viewState.documentMode && cachedInteractionGuardSnapshot.protectionSnapshot === protectionSnapshot && cachedInteractionGuardSnapshot.workflowOverlay === workflowOverlay) {
-      return cachedInteractionGuardSnapshot.snapshot;
-    }
-    const blockedReasons = evaluateWorkflowBlockedReasons(state.selection);
-    const matchingScope = getMatchingWorkflowScope(state.selection);
-    const primaryBlockedReason = blockedReasons[0];
-    const snapshot = {
-      effectiveMode: primaryBlockedReason ? primaryBlockedReason.code === "workflow_comment_only" ? "comment" : primaryBlockedReason.code === "workflow_view_only" ? "view" : "blocked" : getEffectiveDocumentMode(state.selection) === "suggesting" ? "suggest" : matchingScope?.mode ?? "edit",
-      ...matchingScope?.scopeId ? { matchedScopeId: matchingScope.scopeId } : {},
-      ...matchingScope?.mode ? { matchedScopeMode: matchingScope.mode } : {},
-      ...primaryBlockedReason ? { disabledReason: primaryBlockedReason.message } : {},
-      blockedReasons
-    };
-    cachedInteractionGuardSnapshot = {
-      revisionToken: state.revisionToken,
-      activeStoryKey,
-      selection: state.selection,
-      readOnly: state.readOnly,
-      documentMode: viewState.documentMode,
-      protectionSnapshot,
-      workflowOverlay,
-      snapshot
-    };
-    return snapshot;
-  }
-  function getCachedWorkflowScopeSnapshot() {
-    if (!workflowOverlay) {
-      return null;
-    }
-    const interactionGuardSnapshot = getCachedInteractionGuardSnapshot();
-    if (cachedWorkflowScopeSnapshot && cachedWorkflowScopeSnapshot.workflowOverlay === workflowOverlay && cachedWorkflowScopeSnapshot.interactionGuardSnapshot === interactionGuardSnapshot) {
-      return cachedWorkflowScopeSnapshot.snapshot;
-    }
-    const snapshot = deriveWorkflowScopeSnapshot();
-    cachedWorkflowScopeSnapshot = {
-      workflowOverlay,
-      interactionGuardSnapshot,
-      snapshot
-    };
-    return snapshot;
-  }
-  function getCachedWorkflowMarkupSnapshot() {
-    const activeStoryKey = storyTargetKey(activeStory);
-    if (cachedWorkflowMarkupSnapshot && cachedWorkflowMarkupSnapshot.revisionToken === state.revisionToken && cachedWorkflowMarkupSnapshot.activeStoryKey === activeStoryKey && cachedWorkflowMarkupSnapshot.protectionSnapshot === protectionSnapshot && cachedWorkflowMarkupSnapshot.preservation === state.document.preservation) {
-      return cachedWorkflowMarkupSnapshot.snapshot;
-    }
-    const snapshot = collectWorkflowMarkupSnapshot({
-      renderSnapshot: cachedRenderSnapshot,
-      fieldSnapshot: buildFieldSnapshot(state.document),
-      protectionSnapshot,
-      preservation: state.document.preservation
-    });
-    cachedWorkflowMarkupSnapshot = {
-      revisionToken: state.revisionToken,
-      activeStoryKey,
-      protectionSnapshot,
-      preservation: state.document.preservation,
-      snapshot
-    };
-    return snapshot;
-  }
-  function refreshRenderSnapshot() {
-    const surface = getCachedSurface(state.document, activeStory);
-    return {
-      documentId: state.documentId,
-      sessionId: state.sessionId,
-      sourceLabel: state.sourceLabel,
-      revisionToken: state.revisionToken,
-      isReady: state.phase === "ready",
-      isDirty: state.isDirty,
-      readOnly: state.readOnly,
-      documentMode: viewState.documentMode,
-      selection: toPublicSelectionSnapshot(state.selection, activeStory),
-      activeStory,
-      pageLayout: getCachedPageLayoutSnapshot(state, activeStory) ?? void 0,
-      documentStats: toPublicDocumentStats(state),
-      comments: getCachedCommentSidebarSnapshot(state),
-      trackedChanges: getCachedTrackedChangesSnapshot(state, surface),
-      compatibility: getCachedCompatibilityReport(state),
-      warnings: state.warnings.map((warning) => toPublicWarning(warning)),
-      fatalError: state.fatalError ? toPublicError(state.fatalError) : void 0,
-      commandState: {
-        canUndo: history.past.length > 0,
-        canRedo: history.future.length > 0,
-        readOnly: state.readOnly
-      },
-      surface,
-      protectionSnapshot
-    };
-  }
-  function getCachedViewStateSnapshot() {
-    const activeStoryKey = storyTargetKey(activeStory);
-    const pageLayout = cachedRenderSnapshot.pageLayout;
-    if (cachedViewStateSnapshot && cachedViewStateSnapshot.revisionToken === state.revisionToken && cachedViewStateSnapshot.activeStoryKey === activeStoryKey && cachedViewStateSnapshot.selection === state.selection && cachedViewStateSnapshot.viewStateRef === viewState && cachedViewStateSnapshot.pageLayout === pageLayout) {
-      return cachedViewStateSnapshot.snapshot;
-    }
-    const surface = cachedRenderSnapshot.surface;
-    const mainSurface = activeStory.kind === "main" ? surface : getCachedSurface(state.document, MAIN_STORY_TARGET);
-    const snapshot = createEditorViewStateSnapshot(
-      viewState,
-      activeStory,
-      toPublicSelectionSnapshot(state.selection, activeStory),
-      surface,
-      mainSurface,
-      pageLayout,
-      state.document.numbering
-    );
-    cachedViewStateSnapshot = {
-      revisionToken: state.revisionToken,
-      activeStoryKey,
-      selection: state.selection,
-      viewStateRef: viewState,
-      pageLayout,
-      snapshot
-    };
-    return snapshot;
-  }
-  let cachedRenderSnapshot = refreshRenderSnapshot();
-  emit({
-    type: "ready",
-    documentId: state.documentId,
-    sessionId: state.sessionId,
-    source: options.sourceKind ?? (options.initialSessionState ? "session" : options.initialSnapshot ? "snapshot" : "canonical"),
-    stats: toPublicDocumentStats(state),
-    compatibility: toPublicCompatibilityReport(createDerivedCompatibility(state)),
-    comments: cachedRenderSnapshot.comments,
-    trackedChanges: cachedRenderSnapshot.trackedChanges
-  });
-  if (options.fatalError) {
-    emit({
-      type: "error",
-      documentId: state.documentId,
-      error: options.fatalError
-    });
-  }
-  return {
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    subscribeToEvents(listener) {
-      eventListeners.add(listener);
-      return () => {
-        eventListeners.delete(listener);
-      };
-    },
-    getRenderSnapshot() {
-      return cachedRenderSnapshot;
-    },
-    getCanonicalDocument() {
-      return state.document;
-    },
-    getSourcePackage() {
-      return state.sourcePackage;
-    },
-    emitBlockedCommand(command, reasons) {
-      emit({
-        type: "command_blocked",
-        documentId: state.documentId,
-        command,
-        reasons
-      });
-    },
-    dispatch(command) {
-      const commandSelection = getCommandSelection(command, state.selection);
-      if (isMutationCommand(command)) {
-        const blockedReasons = evaluateWorkflowBlockedReasons(
-          commandSelection,
-          command.type
-        );
-        if (blockedReasons.length > 0) {
-          emit({
-            type: "command_blocked",
-            documentId: state.documentId,
-            command: command.type,
-            reasons: blockedReasons
-          });
-          return;
-        }
-      }
-      if (command.type === "history.undo") {
-        if (viewState.documentMode === "viewing") return;
-        applyHistory("undo");
-        return;
-      }
-      if (command.type === "history.redo") {
-        if (viewState.documentMode === "viewing") return;
-        applyHistory("redo");
-        return;
-      }
-      try {
-        const transaction = executeEditorCommand(state, command, {
-          timestamp: command.origin?.timestamp ?? clock(),
-          documentMode: getEffectiveDocumentMode(commandSelection),
-          defaultAuthorId: defaultAuthorId ?? void 0
-        });
-        commit(transaction);
-      } catch (error) {
-        emitError(toRuntimeError(error));
-      }
-    },
-    undo() {
-      this.dispatch({
-        type: "history.undo",
-        origin: createOrigin("runtime", clock())
-      });
-    },
-    redo() {
-      this.dispatch({
-        type: "history.redo",
-        origin: createOrigin("runtime", clock())
-      });
-    },
-    focus() {
-      viewState = setFocused(viewState, true);
-      this.dispatch({
-        type: "runtime.focus",
-        focused: true,
-        origin: createOrigin("api", clock())
-      });
-    },
-    blur() {
-      viewState = setFocused(viewState, false);
-      this.dispatch({
-        type: "runtime.focus",
-        focused: false,
-        origin: createOrigin("api", clock())
-      });
-    },
-    setDefaultAuthorId(authorId) {
-      defaultAuthorId = authorId;
-    },
-    replaceText(text, target) {
-      try {
-        const timestamp = clock();
-        applyTextCommandInActiveStory(
-          {
-            type: "text.insert",
-            text,
-            origin: createOrigin("api", timestamp)
-          },
-          {
-            selection: target ? createSelectionFromPublicAnchor(target) : state.selection,
-            blockedCommandName: "replaceText"
-          }
-        );
-      } catch (error) {
-        emitError(toRuntimeError(error));
-      }
-    },
-    applyActiveStoryTextCommand(command) {
-      try {
-        applyTextCommandInActiveStory(command);
-      } catch (error) {
-        emitError(toRuntimeError(error));
-      }
-    },
-    addComment(params) {
-      if (viewState.documentMode === "viewing") {
-        throw new Error("Cannot add comments in viewing mode.");
-      }
-      const commentId = createEntityId("comment", state.document.review.comments, clock());
-      const anchor = params.anchor ? toInternalAnchorProjection(params.anchor) : state.selection.activeRange;
-      const selection = params.anchor ? createSelectionFromPublicAnchor(params.anchor) : state.selection;
-      if (!canCreateDocxCommentAnchor(state.document.content, anchor)) {
-        const message = "DOCX comments must use a non-empty range that stays within a single paragraph.";
-        emitError({
-          errorId: createSessionId("comment-anchor", clock()),
-          code: "validation_failed",
-          isFatal: false,
-          message,
-          source: "runtime"
-        });
-        throw new Error(message);
-      }
-      const authorId = params.authorId ?? defaultAuthorId ?? "unknown";
-      const createdAt = clock();
-      const entries = [
-        {
-          entryId: `${commentId}-entry-1`,
-          authorId,
-          body: params.body ?? "",
-          createdAt
-        }
-      ];
-      const comment = {
-        commentId,
-        anchor,
-        createdAt,
-        createdBy: authorId,
-        authorId,
-        body: params.body ?? "",
-        entries,
-        status: anchor.kind === "detached" ? "detached" : "open",
-        warningIds: [],
-        isResolved: false,
-        metadata: {
-          source: "runtime"
-        }
-      };
-      this.dispatch({
-        type: "comment.add",
-        comment,
-        selection,
-        origin: createOrigin("api", clock())
-      });
-      return commentId;
-    },
-    openComment(commentId) {
-      this.dispatch({
-        type: "comment.open",
-        commentId,
-        origin: createOrigin("api", clock())
-      });
-    },
-    resolveComment(commentId) {
-      this.dispatch({
-        type: "comment.resolve",
-        commentId,
-        resolvedBy: defaultAuthorId ?? "unknown",
-        origin: createOrigin("api", clock())
-      });
-    },
-    reopenComment(commentId) {
-      this.dispatch({
-        type: "comment.reopen",
-        commentId,
-        origin: createOrigin("api", clock())
-      });
-    },
-    addCommentReply(commentId, body, authorId) {
-      this.dispatch({
-        type: "comment.add-reply",
-        commentId,
-        body,
-        authorId: authorId ?? defaultAuthorId,
-        origin: createOrigin("api", clock())
-      });
-    },
-    editCommentBody(commentId, body) {
-      this.dispatch({
-        type: "comment.edit-body",
-        commentId,
-        body,
-        origin: createOrigin("api", clock())
-      });
-    },
-    acceptChange(changeId) {
-      this.dispatch({
-        type: "change.accept",
-        changeId,
-        origin: createOrigin("api", clock())
-      });
-    },
-    rejectChange(changeId) {
-      this.dispatch({
-        type: "change.reject",
-        changeId,
-        origin: createOrigin("api", clock())
-      });
-    },
-    acceptAllChanges() {
-      this.dispatch({
-        type: "change.accept-all",
-        origin: createOrigin("api", clock())
-      });
-    },
-    rejectAllChanges() {
-      this.dispatch({
-        type: "change.reject-all",
-        origin: createOrigin("api", clock())
-      });
-    },
-    openStory(target) {
-      const normalizedTarget = target.kind === "header" || target.kind === "footer" ? normalizeHeaderFooterTarget(
-        state.document,
-        target,
-        cachedRenderSnapshot.pageLayout?.sectionIndex
-      ) ?? target : target;
-      if (storyTargetsEqual(activeStory, normalizedTarget)) {
-        return true;
-      }
-      if (!isValidStoryTarget(state, normalizedTarget)) {
-        return false;
-      }
-      switchActiveStory(normalizedTarget);
-      return true;
-    },
-    closeStory() {
-      if (activeStory.kind === "main") {
-        return;
-      }
-      switchActiveStory(MAIN_STORY_TARGET);
-    },
-    getActiveStory() {
-      return activeStory;
-    },
-    getViewState() {
-      return getCachedViewStateSnapshot();
-    },
-    setViewMode(mode) {
-      viewState = setViewMode(viewState, mode);
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    setDocumentMode(mode) {
-      viewState = setDocumentMode(viewState, mode);
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    getProtectionSnapshot() {
-      return cachedRenderSnapshot.protectionSnapshot;
-    },
-    setWorkspaceMode(mode) {
-      viewState = setWorkspaceMode(viewState, mode);
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    setZoom(level) {
-      viewState = setZoomLevel(viewState, level);
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    getPageLayoutSnapshot() {
-      return getCachedPageLayoutSnapshot(state, activeStory);
-    },
-    getDocumentNavigationSnapshot() {
-      return getCachedDocumentNavigationSnapshot(state, activeStory);
-    },
-    getFieldSnapshot() {
-      return buildFieldSnapshot(state.document);
-    },
-    updateFields(options2) {
-      const refreshed = refreshDocumentFields(
-        state.document,
-        state.selection.head,
-        activeStory,
-        options2
-      );
-      if (refreshed.changed) {
-        this.dispatch({
-          type: "document.replace",
-          document: refreshed.document,
-          mapping: createEmptyMapping(),
-          protectionSelection: refreshed.protectionSelection,
-          origin: createOrigin("api", clock())
-        });
-      }
-      const snapshot = buildFieldSnapshot(refreshed.document);
-      return {
-        totalCount: snapshot.totalCount,
-        updatedCount: refreshed.updatedCount,
-        preserveOnlyCount: snapshot.preserveOnlyCount
-      };
-    },
-    updateTableOfContents(options2) {
-      const refreshed = refreshDocumentTableOfContents(
-        state.document,
-        state.selection.head,
-        activeStory,
-        options2
-      );
-      if (refreshed.changed) {
-        this.dispatch({
-          type: "document.replace",
-          document: refreshed.document,
-          mapping: createEmptyMapping(),
-          protectionSelection: refreshed.protectionSelection,
-          origin: createOrigin("api", clock())
-        });
-      }
-      return refreshed.result;
-    },
-    getSessionState() {
-      const compatibility = createDerivedCompatibility(state);
-      return editorSessionStateFromPersistedSnapshot(
-        createPersistedEditorSnapshot(state, {
-          editorBuild,
-          savedAt: clock(),
-          compatibility,
-          protectionSnapshot
-        })
-      );
-    },
-    getPersistedSnapshot() {
-      return persistedSnapshotFromEditorSessionState(this.getSessionState(), {
-        savedAt: clock()
-      });
-    },
-    getCompatibilityReport() {
-      return toPublicCompatibilityReport(createDerivedCompatibility(state));
-    },
-    getWarnings() {
-      return state.warnings.map((warning) => toPublicWarning(warning));
-    },
-    async exportDocx(exportOptions) {
-      if (!options.exportDocx) {
-        const error = {
-          errorId: createEntityId("error", {}, clock()),
-          code: "export_failed",
-          isFatal: false,
-          message: "DOCX export requires an injected exporter until the IO substrate lands.",
-          source: "export",
-          details: {
-            requestedOptions: exportOptions ?? {}
-          }
-        };
-        emitError(error);
-        throw new Error(error.message);
-      }
-      const result = await options.exportDocx(this.getSessionState(), exportOptions);
-      emit({
-        type: "export_completed",
-        documentId: state.documentId,
-        result
-      });
-      return result;
-    },
-    setWorkflowOverlay(overlay) {
-      workflowOverlay = structuredClone(overlay);
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      const snapshot = deriveWorkflowScopeSnapshot();
-      emit({
-        type: "workflow_overlay_changed",
-        documentId: state.documentId,
-        snapshot
-      });
-      if (workflowOverlay.activeWorkItemId !== void 0) {
-        emit({
-          type: "workflow_active_work_item_changed",
-          documentId: state.documentId,
-          activeWorkItemId: workflowOverlay.activeWorkItemId ?? null
-        });
-      }
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    clearWorkflowOverlay() {
-      workflowOverlay = null;
-      cachedRenderSnapshot = refreshRenderSnapshot();
-      emit({
-        type: "workflow_active_work_item_changed",
-        documentId: state.documentId,
-        activeWorkItemId: null
-      });
-      emit({
-        type: "workflow_overlay_changed",
-        documentId: state.documentId,
-        snapshot: {
-          overlayPresent: false,
-          activeWorkItemId: null,
-          scopes: [],
-          candidates: [],
-          blockedReasons: []
-        }
-      });
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    getWorkflowScopeSnapshot() {
-      return getCachedWorkflowScopeSnapshot();
-    },
-    getInteractionGuardSnapshot() {
-      return getCachedInteractionGuardSnapshot();
-    },
-    getWorkflowMarkupSnapshot() {
-      return getCachedWorkflowMarkupSnapshot();
-    },
-    setHostAnnotationOverlay(overlay) {
-      hostAnnotationOverlay = structuredClone(overlay);
-      emit({
-        type: "host_annotation_overlay_changed",
-        documentId: state.documentId,
-        snapshot: deriveHostAnnotationSnapshot()
-      });
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    clearHostAnnotationOverlay() {
-      hostAnnotationOverlay = null;
-      emit({
-        type: "host_annotation_overlay_changed",
-        documentId: state.documentId,
-        snapshot: deriveHostAnnotationSnapshot()
-      });
-      for (const listener of listeners) {
-        listener();
-      }
-    },
-    getHostAnnotationSnapshot() {
-      return deriveHostAnnotationSnapshot();
-    },
-    getWorkflowCandidateRanges(options2) {
-      return deriveWorkflowCandidateRangesFromMarkup(this.getWorkflowMarkupSnapshot(), options2);
-    },
-    replaceWorkflowMarkupText(markupId, text) {
-      const target = this.getWorkflowMarkupSnapshot().items.find((item) => item.markupId === markupId);
-      if (!target || target.anchor.kind === "detached") {
-        return;
-      }
-      const targetStory = target.storyTarget ?? MAIN_STORY_TARGET;
-      if (!storyTargetsEqual(activeStory, targetStory)) {
-        if (targetStory.kind === "main") {
-          this.closeStory();
-        } else if (!this.openStory(targetStory)) {
-          return;
-        }
-      }
-      this.replaceText(text, target.anchor);
-    }
-  };
-  function applyHistory(direction) {
-    const source = direction === "undo" ? history.past : history.future;
-    const target = source.pop();
-    if (!target) {
-      return;
-    }
-    const counterpart = direction === "undo" ? history.future : history.past;
-    counterpart.push(state);
-    const previous = state;
-    state = finalizeState(target, true, clock(), previous.revision);
-    storySelections.set(storyTargetKey(activeStory), state.selection);
-    cachedRenderSnapshot = refreshRenderSnapshot();
-    notify(previous, state, {
-      nextState: state,
-      mapping: { steps: [] },
-      effects: {
-        warningsAdded: [],
-        warningsCleared: []
-      },
-      historyBoundary: "skip",
-      markDirty: true
-    });
-  }
-  function commit(transaction) {
-    const previous = state;
-    if (transaction.historyBoundary === "push") {
-      history.past.push(state);
-      history.future = [];
-    }
-    protectionSnapshot = remapProtectionSnapshot(protectionSnapshot, transaction.mapping);
-    state = finalizeState(transaction.nextState, transaction.markDirty, clock());
-    storySelections.set(storyTargetKey(activeStory), state.selection);
-    cachedRenderSnapshot = refreshRenderSnapshot();
-    notify(previous, state, transaction);
-  }
-  function notify(previous, next, transaction) {
-    if (previous.isDirty !== next.isDirty) {
-      emit({
-        type: "dirty_changed",
-        documentId: next.documentId,
-        isDirty: next.isDirty
-      });
-    }
-    if (selectionChanged(previous.selection, next.selection)) {
-      emit({
-        type: "selection_changed",
-        documentId: next.documentId,
-        selection: toPublicSelectionSnapshot(next.selection, activeStory)
-      });
-    }
-    if (transaction.effects.commentAdded) {
-      emit({
-        type: "comment_added",
-        documentId: next.documentId,
-        commentId: transaction.effects.commentAdded.commentId,
-        anchor: toPublicAnchorProjection(transaction.effects.commentAdded.anchor)
-      });
-    }
-    if (transaction.effects.commentResolved) {
-      emit({
-        type: "comment_resolved",
-        documentId: next.documentId,
-        commentId: transaction.effects.commentResolved.commentId
-      });
-    }
-    if (transaction.effects.changeAccepted) {
-      emit({
-        type: "change_accepted",
-        documentId: next.documentId,
-        changeId: transaction.effects.changeAccepted.changeId
-      });
-    }
-    if (transaction.effects.changeRejected) {
-      emit({
-        type: "change_rejected",
-        documentId: next.documentId,
-        changeId: transaction.effects.changeRejected.changeId
-      });
-    }
-    if (transaction.effects.revisionAuthored) {
-      emit({
-        type: "change_authored",
-        documentId: next.documentId,
-        changeId: transaction.effects.revisionAuthored.changeId,
-        kind: transaction.effects.revisionAuthored.kind
-      });
-    }
-    if (transaction.effects.commandBlocked) {
-      emit({
-        type: "command_blocked",
-        documentId: next.documentId,
-        command: transaction.effects.commandBlocked.code,
-        reasons: [{
-          code: transaction.effects.commandBlocked.code,
-          message: transaction.effects.commandBlocked.message
-        }]
-      });
-    }
-    for (const warning of transaction.effects.warningsAdded) {
-      const publicWarning = toPublicWarning(warning);
-      emit({
-        type: "warning_added",
-        documentId: next.documentId,
-        warning: publicWarning
-      });
-      options.onWarning?.(publicWarning);
-    }
-    for (const cleared of transaction.effects.warningsCleared) {
-      emit({
-        type: "warning_cleared",
-        documentId: next.documentId,
-        warningId: cleared.warningId,
-        code: cleared.code
-      });
-    }
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  function applyTextCommandInActiveStory(command, options2 = {}) {
-    const selection = options2.selection ?? state.selection;
-    const blockedReasons = evaluateWorkflowBlockedReasons(selection, command.type);
-    if (blockedReasons.length > 0) {
-      emit({
-        type: "command_blocked",
-        documentId: state.documentId,
-        command: options2.blockedCommandName ?? command.type,
-        reasons: blockedReasons
-      });
-      return;
-    }
-    const timestamp = command.origin?.timestamp ?? clock();
-    const context = {
-      timestamp,
-      documentMode: getEffectiveDocumentMode(selection),
-      defaultAuthorId: defaultAuthorId ?? void 0
-    };
-    const baseState = selection === state.selection ? state : {
-      ...state,
-      selection
-    };
-    if (activeStory.kind === "main") {
-      commit(executeEditorCommand(baseState, command, context));
-      return;
-    }
-    const localState = createEditorState({
-      documentId: state.documentId,
-      sessionId,
-      sourceLabel: state.sourceLabel,
-      readOnly: state.readOnly,
-      canonicalDocument: {
-        ...state.document,
-        content: {
-          type: "doc",
-          children: [...getStoryBlocks(state.document, activeStory)]
-        },
-        review: createSecondaryStoryLocalReviewState(state.document.review, activeStory)
-      },
-      compatibility: state.compatibility,
-      warnings: state.warnings,
-      fatalError: state.fatalError
-    });
-    localState.selection = selection;
-    const localTransaction = executeEditorCommand(localState, command, context);
-    if (!localTransaction.markDirty) {
-      notify(state, state, {
-        nextState: state,
-        mapping: createEmptyMapping(),
-        effects: localTransaction.effects,
-        historyBoundary: "skip",
-        markDirty: false
-      });
-      return;
-    }
-    const nextDocument = replaceStoryBlocks(
-      state.document,
-      activeStory,
-      localTransaction.nextState.document.content.children
-    );
-    const nextDocumentWithReview = {
-      ...nextDocument,
-      review: mergeSecondaryStoryReviewState(
-        state.document.review,
-        localTransaction.nextState.document.review,
-        localTransaction.effects,
-        activeStory
-      )
-    };
-    const fullTransaction = executeEditorCommand(
-      baseState,
-      {
-        type: "document.replace",
-        document: nextDocumentWithReview,
-        selection: localTransaction.nextState.selection,
-        mapping: createEmptyMapping(),
-        protectionSelection: selection,
-        origin: command.origin
-      },
-      context
-    );
-    commit({
-      ...fullTransaction,
-      effects: mergeTransactionEffects(fullTransaction.effects, localTransaction.effects)
-    });
-  }
-  function mergeTransactionEffects(base, local) {
-    return {
-      warningsAdded: [...base.warningsAdded, ...local.warningsAdded],
-      warningsCleared: [...base.warningsCleared, ...local.warningsCleared],
-      commentAdded: base.commentAdded ?? local.commentAdded,
-      commentResolved: base.commentResolved ?? local.commentResolved,
-      commentReopened: base.commentReopened ?? local.commentReopened,
-      commentReplyAdded: base.commentReplyAdded ?? local.commentReplyAdded,
-      commentBodyEdited: base.commentBodyEdited ?? local.commentBodyEdited,
-      changeAccepted: base.changeAccepted ?? local.changeAccepted,
-      changeRejected: base.changeRejected ?? local.changeRejected,
-      revisionAuthored: base.revisionAuthored ?? local.revisionAuthored,
-      commandBlocked: base.commandBlocked ?? local.commandBlocked
-    };
-  }
-  function mergeSecondaryStoryReviewState(currentReview, localReview, effects, storyTarget) {
-    const nextReview = {
-      comments: { ...currentReview.comments },
-      revisions: { ...currentReview.revisions }
-    };
-    const currentStoryRevisionIds = Object.values(currentReview.revisions).filter((revision) => storyTargetsEqual(getRevisionStoryTarget(revision), storyTarget)).map((revision) => revision.changeId);
-    for (const revisionId of currentStoryRevisionIds) {
-      delete nextReview.revisions[revisionId];
-    }
-    for (const revision of Object.values(localReview.revisions)) {
-      nextReview.revisions[revision.changeId] = {
-        ...revision,
-        metadata: {
-          ...revision.metadata,
-          storyTarget: createRevisionStoryTargetRecord(storyTarget)
-        }
-      };
-    }
-    if (effects.commentAdded) {
-      const commentId = effects.commentAdded.commentId;
-      const comment = localReview.comments[commentId];
-      if (comment) {
-        nextReview.comments[commentId] = comment;
-      }
-    }
-    return nextReview;
-  }
-  function emit(event) {
-    options.onEvent?.(event);
-    for (const listener of eventListeners) {
-      listener(event);
-    }
-  }
-  function emitError(error) {
-    const nextState = {
-      ...state,
-      phase: error.isFatal ? "error" : state.phase,
-      fatalError: error.isFatal ? error : state.fatalError
-    };
-    state = nextState;
-    storySelections.set(storyTargetKey(activeStory), state.selection);
-    cachedRenderSnapshot = refreshRenderSnapshot();
-    const publicError = toPublicError(error);
-    options.onError?.(publicError);
-    emit({
-      type: "error",
-      documentId: state.documentId,
-      error: publicError
-    });
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-  function switchActiveStory(target) {
-    const previousStory = activeStory;
-    const previousSelection = state.selection;
-    storySelections.set(storyTargetKey(previousStory), previousSelection);
-    const restoredSelection = storySelections.get(storyTargetKey(target)) ?? createSelectionSnapshot(0, 0);
-    activeStory = target;
-    state = {
-      ...state,
-      selection: restoredSelection
-    };
-    storySelections.set(storyTargetKey(target), restoredSelection);
-    cachedRenderSnapshot = refreshRenderSnapshot();
-    if (selectionChanged(previousSelection, restoredSelection)) {
-      emit({
-        type: "selection_changed",
-        documentId: state.documentId,
-        selection: toPublicSelectionSnapshot(restoredSelection, activeStory)
-      });
-    }
-    emit({
-      type: "story_changed",
-      documentId: state.documentId,
-      activeStory
-    });
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-}
-function createSessionId(documentId, timestamp) {
-  return `session-${documentId}-${timestamp.replace(/[^0-9]/gu, "")}`;
-}
-function createOrigin(source, timestamp) {
-  return {
-    source,
-    timestamp
-  };
-}
-function createEntityId(prefix, existing, timestamp) {
-  let counter = Object.keys(existing).length;
-  let nextId = `${prefix}-${timestamp.replace(/[^0-9]/gu, "")}-${counter}`;
-  while (existing[nextId]) {
-    counter += 1;
-    nextId = `${prefix}-${timestamp.replace(/[^0-9]/gu, "")}-${counter}`;
-  }
-  return nextId;
-}
-function finalizeState(state, markDirty, timestamp, baseRevision) {
-  const revision = markDirty ? (baseRevision ?? state.revision) + 1 : state.revision;
-  return {
-    ...state,
-    document: {
-      ...state.document,
-      updatedAt: markDirty ? timestamp : state.document.updatedAt
-    },
-    selection: state.selection,
-    revision,
-    revisionToken: `${state.sessionId}:${revision}`,
-    isDirty: state.isDirty || markDirty
-  };
-}
-function toRuntimeError(error) {
-  if (typeof error === "object" && error && "message" in error) {
-    return {
-      errorId: createSessionId("runtime-error", (/* @__PURE__ */ new Date()).toISOString()),
-      code: "internal_invariant",
-      isFatal: false,
-      message: String(error.message ?? "Runtime error"),
-      source: "runtime"
-    };
-  }
-  return {
-    errorId: createSessionId("runtime-error", (/* @__PURE__ */ new Date()).toISOString()),
-    code: "internal_invariant",
-    isFatal: false,
-    message: "Runtime error",
-    source: "runtime"
-  };
-}
-function toPublicDocumentStats(state) {
-  const stats = deriveDocumentStats(state);
-  return {
-    storyLength: stats.characterCount,
-    commentCount: stats.commentCount,
-    revisionCount: stats.revisionCount,
-    opaqueFragmentCount: countOpaqueFragments(state.document.preservation.opaqueFragments)
-  };
-}
-function toPublicSelectionSnapshot(selection, storyTarget) {
-  return {
-    anchor: selection.anchor,
-    head: selection.head,
-    isCollapsed: selection.isCollapsed,
-    activeRange: toPublicAnchorProjection(selection.activeRange),
-    ...storyTarget && storyTarget.kind !== "main" ? { storyTarget } : {}
-  };
-}
-function toPublicAnchorProjection(anchor) {
-  switch (anchor.kind) {
-    case "range":
-      return {
-        kind: "range",
-        from: anchor.range.from,
-        to: anchor.range.to,
-        assoc: anchor.assoc
-      };
-    case "node":
-      return {
-        kind: "node",
-        at: anchor.at,
-        assoc: anchor.assoc
-      };
-    case "detached":
-      return {
-        kind: "detached",
-        lastKnownRange: anchor.lastKnownRange,
-        reason: anchor.reason
-      };
-  }
-}
-function toInternalAnchorProjection(anchor) {
-  switch (anchor.kind) {
-    case "range":
-      return createRangeAnchor(anchor.from, anchor.to, anchor.assoc);
-    case "node":
-      return createNodeAnchor(anchor.at, anchor.assoc);
-    case "detached":
-      return createDetachedAnchor(anchor.lastKnownRange, anchor.reason);
-  }
-}
-function createSelectionFromPublicAnchor(anchor) {
-  switch (anchor.kind) {
-    case "range":
-      return createSelectionSnapshot(anchor.from, anchor.to);
-    case "node":
-      return createSelectionSnapshot(anchor.at, anchor.at);
-    case "detached":
-      return createSelectionSnapshot(
-        anchor.lastKnownRange.from,
-        anchor.lastKnownRange.to
-      );
-  }
-}
-function toPublicCompatibilityReport(report) {
-  return {
-    reportVersion: report.reportVersion,
-    generatedAt: report.generatedAt,
-    blockExport: report.blockExport,
-    featureEntries: report.featureEntries.map(
-      (entry) => toPublicCompatibilityFeatureEntry(entry)
-    ),
-    warnings: report.warnings.map((warning) => toPublicWarning(warning)),
-    errors: report.errors.map((error) => toPublicError(error))
-  };
-}
-function toPublicCompatibilityFeatureEntry(entry) {
-  return {
-    ...entry,
-    affectedAnchor: entry.affectedAnchor ? toPublicAnchorProjection(entry.affectedAnchor) : void 0
-  };
-}
-function toPublicWarning(warning) {
-  return {
-    ...warning,
-    affectedAnchor: warning.affectedAnchor ? toPublicAnchorProjection(warning.affectedAnchor) : void 0
-  };
-}
-function toPublicError(error) {
-  return { ...error };
-}
-function countOpaqueFragments(opaqueFragments) {
-  return Object.keys(opaqueFragments).length;
-}
-function createDerivedCompatibility(state) {
-  const derived = buildCompatibilityReport({
-    document: state.document,
-    warnings: state.warnings,
-    fatalError: state.fatalError,
-    generatedAt: state.document.updatedAt
-  });
-  return mergeCompatibilityReports([state.compatibility, derived], {
-    generatedAt: state.document.updatedAt,
-    blockExport: state.compatibility.blockExport || derived.blockExport
-  });
-}
-function toPublicCommentSidebarSnapshot(state) {
-  const projection = createCommentSidebarProjection(
-    createCommentStoreFromRuntimeComments(state.document.review.comments),
-    state.runtime.activeCommentId
-  );
-  return {
-    activeCommentId: state.runtime.activeCommentId,
-    openCommentIds: projection.openCommentIds,
-    resolvedCommentIds: projection.resolvedCommentIds,
-    detachedCommentIds: projection.detachedCommentIds,
-    totalCount: projection.totalCount,
-    threads: projection.threads.map((thread) => {
-      const sourceThread = state.document.review.comments[thread.commentId];
-      const projectedEntries = sourceThread?.entries?.map((entry) => ({
-        entryId: entry.entryId,
-        authorId: entry.authorId,
-        body: entry.body,
-        createdAt: entry.createdAt
-      })) ?? (sourceThread?.body ? [
-        {
-          entryId: `${thread.commentId}-entry-1`,
-          authorId: sourceThread.authorId ?? sourceThread.createdBy ?? "unknown",
-          body: sourceThread.body,
-          createdAt: sourceThread.createdAt
-        }
-      ] : []);
-      return {
-        commentId: thread.commentId,
-        status: thread.status,
-        anchor: toPublicAnchorProjection(
-          sourceThread?.anchor ?? createDetachedAnchor({ from: 0, to: 0 }, "importAmbiguity")
-        ),
-        excerpt: thread.excerpt,
-        entryCount: thread.entryCount,
-        createdAt: thread.createdAt,
-        createdBy: thread.createdBy,
-        warningCount: thread.warningCount,
-        anchorLabel: thread.anchorLabel,
-        isActive: thread.isActive,
-        resolvedAt: thread.resolvedAt,
-        resolvedBy: thread.resolvedBy,
-        entries: projectedEntries
-      };
-    })
-  };
-}
-function toPublicTrackedChangesSnapshot(state) {
-  const projection = createRevisionSidebarProjection(
-    createRevisionStoreFromDocument(state)
-  );
-  const storyPlainTextCache = /* @__PURE__ */ new Map();
-  return {
-    pendingChangeIds: projection.activeRevisionIds,
-    acceptedChangeIds: projection.acceptedRevisionIds,
-    rejectedChangeIds: projection.rejectedRevisionIds,
-    detachedChangeIds: projection.detachedRevisionIds,
-    actionableChangeIds: projection.actionableRevisionIds,
-    preserveOnlyChangeIds: projection.preserveOnlyRevisionIds,
-    totalCount: projection.totalCount,
-    revisions: projection.revisions.map((revision) => {
-      const sourceRevision = state.document.review.revisions[revision.revisionId];
-      const storyTarget = getRevisionStoryTarget(sourceRevision);
-      const preview = describeRevisionPreview(
-        revision,
-        sourceRevision?.anchor ?? createDetachedAnchor({ from: 0, to: 0 }, "importAmbiguity"),
-        getStoryPlainText(state.document, storyTarget, storyPlainTextCache)
-      );
-      return {
-        revisionId: revision.revisionId,
-        kind: revision.kind,
-        label: revision.label,
-        status: revision.status,
-        actionability: revision.actionability,
-        storyTarget,
-        anchor: toPublicAnchorProjection(
-          sourceRevision?.anchor ?? createDetachedAnchor({ from: 0, to: 0 }, "importAmbiguity")
-        ),
-        anchorLabel: revision.anchorLabel,
-        createdAt: revision.createdAt,
-        authorId: revision.authorId,
-        warningCount: revision.warningCount,
-        canAccept: revision.canAccept,
-        canReject: revision.canReject,
-        importedRevisionForm: sourceRevision?.metadata?.importedRevisionForm,
-        preserveOnlyReason: revision.preserveOnlyReason,
-        excerpt: preview.excerpt,
-        detail: preview.detail
-      };
-    })
-  };
-}
-function createRevisionStoreFromDocument(state) {
-  return {
-    version: "revision-store/1",
-    revisions: Object.fromEntries(
-      Object.values(state.document.review.revisions).map((revision) => [
-        revision.changeId,
-        {
-          revisionId: revision.changeId,
-          kind: revision.kind,
-          anchor: revision.anchor,
-          authorId: revision.authorId ?? "unknown",
-          createdAt: revision.createdAt,
-          status: revision.status === "open" ? "active" : revision.status,
-          warningIds: [...revision.warningIds ?? []],
-          metadata: {
-            source: revision.metadata?.source ?? "runtime",
-            storyTarget: revision.metadata?.storyTarget,
-            preserveOnlyReason: revision.metadata?.preserveOnlyReason,
-            importedRevisionForm: revision.metadata?.importedRevisionForm,
-            originalRevisionType: revision.metadata?.originalRevisionType,
-            ooxmlRevisionId: revision.metadata?.ooxmlRevisionId
-          }
-        }
-      ])
-    )
-  };
-}
-function getRevisionStoryTarget(revision) {
-  const storyTarget = revision?.metadata?.storyTarget;
-  return storyTarget ? { ...storyTarget } : MAIN_STORY_TARGET;
-}
-function createSecondaryStoryLocalReviewState(review, storyTarget) {
-  return {
-    comments: {},
-    revisions: Object.fromEntries(
-      Object.values(review.revisions).filter((revision) => storyTargetsEqual(getRevisionStoryTarget(revision), storyTarget)).map((revision) => [
-        revision.changeId,
-        {
-          ...revision,
-          metadata: {
-            ...revision.metadata,
-            storyTarget: createRevisionStoryTargetRecord(storyTarget)
-          }
-        }
-      ])
-    )
-  };
-}
-function getStoryPlainText(document, storyTarget, cache) {
-  const key = storyTargetKey(storyTarget);
-  const cached = cache.get(key);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const plainText = createEditorSurfaceSnapshot(
-    document,
-    createSelectionSnapshot(0, 0),
-    storyTarget
-  ).plainText;
-  cache.set(key, plainText);
-  return plainText;
-}
-function createRevisionStoryTargetRecord(storyTarget) {
-  return { ...storyTarget };
-}
-function listBlockExportReasons(report) {
-  return [
-    ...report.featureEntries.filter((entry) => entry.featureClass === "unsupported-fatal").map((entry) => entry.message),
-    ...report.errors.filter((error) => error.isFatal).map((error) => error.message)
-  ];
-}
-function describeRevisionPreview(revision, anchor, plainText) {
-  const { from, to } = toAnchorBounds(anchor);
-  const excerpt = summarizeRevisionExcerpt(plainText, from, to, revision.label);
-  if (revision.actionability === "preserve-only") {
-    return {
-      excerpt,
-      detail: revision.preserveOnlyReason ?? "Visible for review, but this change remains preserve-only in the current runtime."
-    };
-  }
-  if (revision.status === "accepted") {
-    return {
-      excerpt,
-      detail: "Accepted in the live review runtime and retained here for audit visibility."
-    };
-  }
-  if (revision.status === "rejected") {
-    return {
-      excerpt,
-      detail: "Rejected in the live review runtime and retained here for audit visibility."
-    };
-  }
-  return {
-    excerpt,
-    detail: revision.kind === "deletion" ? "Deleted content stays reviewable here until it is accepted or rejected." : "Runtime-backed change. Review it here or reopen the anchor in the canvas."
-  };
-}
-function toAnchorBounds(anchor) {
-  switch (anchor.kind) {
-    case "range":
-      return {
-        from: Math.min(anchor.range.from, anchor.range.to),
-        to: Math.max(anchor.range.from, anchor.range.to)
-      };
-    case "node":
-      return {
-        from: anchor.at,
-        to: anchor.at + 1
-      };
-    case "detached":
-      return {
-        from: Math.min(anchor.lastKnownRange.from, anchor.lastKnownRange.to),
-        to: Math.max(anchor.lastKnownRange.from, anchor.lastKnownRange.to)
-      };
-  }
-}
-function summarizeRevisionExcerpt(plainText, from, to, fallback) {
-  const normalizedFrom = Math.max(0, Math.min(from, plainText.length));
-  const normalizedTo = Math.max(normalizedFrom, Math.min(to, plainText.length));
-  const collapsed = plainText.slice(normalizedFrom, normalizedTo).replace(/\s+/g, " ").trim();
-  if (!collapsed) {
-    return fallback;
-  }
-  return collapsed.length > 96 ? `${collapsed.slice(0, 93)}...` : collapsed;
-}
-function isValidStoryTarget(state, target) {
-  if (target.kind === "main") return true;
-  const subParts = state.document.subParts;
-  if (!subParts) return false;
-  switch (target.kind) {
-    case "header":
-      return Boolean(normalizeHeaderFooterTarget(state.document, target));
-    case "footer":
-      return Boolean(normalizeHeaderFooterTarget(state.document, target));
-    case "footnote":
-      return Boolean(subParts.footnoteCollection?.footnotes?.[target.noteId]);
-    case "endnote":
-      return Boolean(subParts.footnoteCollection?.endnotes?.[target.noteId]);
-  }
-}
-function derivePageLayoutSnapshot(state, activeStory, storySelections) {
-  const subParts = state.document.subParts;
-  const sections = buildResolvedSections(state.document);
-  if (!subParts && sections.length === 0) {
-    return null;
-  }
-  const activeSection = resolveActiveSection(
-    state,
-    activeStory,
-    sections,
-    storySelections
-  );
-  return buildPageLayoutSnapshot(
-    activeSection?.index ?? 0,
-    activeSection?.properties ?? subParts?.finalSectionProperties,
-    subParts
-  );
-}
-var NON_MUTATION_COMMANDS = /* @__PURE__ */ new Set([
-  "selection.set",
-  "runtime.set-read-only",
-  "runtime.focus",
-  "warning.add",
-  "warning.clear",
-  "comment.open"
-]);
-var SUGGESTING_UNSUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
-  "paragraph.split"
-]);
-var SUGGESTING_SECONDARY_STORY_UNSUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
-  "text.insert",
-  "text.delete-backward",
-  "text.delete-forward",
-  "text.insert-tab",
-  "text.insert-hard-break"
-]);
-function isMutationCommand(command) {
-  return !NON_MUTATION_COMMANDS.has(command.type);
-}
-function buildFieldSnapshot(document) {
-  const entries = [];
-  let index = 0;
-  for (const block of document.content.children) {
-    index = collectFieldsFromBlock(block, entries, index);
-  }
-  index = collectFieldsFromSubParts(document.subParts, entries, index);
-  const supportedCount = entries.filter((e) => e.supported).length;
-  return {
-    totalCount: entries.length,
-    supportedCount,
-    preserveOnlyCount: entries.length - supportedCount,
-    fields: entries
-  };
-}
-function collectFieldsFromBlock(block, entries, index) {
-  if (block.type === "paragraph") {
-    for (const child of block.children) {
-      index = collectFieldsFromInline(child, entries, index);
-    }
-  } else if (block.type === "table") {
-    for (const row of block.rows) {
-      for (const cell of row.cells) {
-        for (const child of cell.children) {
-          index = collectFieldsFromBlock(child, entries, index);
-        }
-      }
-    }
-  } else if (block.type === "sdt" || block.type === "custom_xml") {
-    for (const child of block.children) {
-      index = collectFieldsFromBlock(child, entries, index);
-    }
-  }
-  return index;
-}
-function collectFieldsFromInline(node, entries, index) {
-  if (node.type === "field") {
-    const fieldFamily = node.fieldFamily ?? "UNKNOWN";
-    const supported = isSupportedFieldFamily(fieldFamily);
-    const displayText = extractFieldDisplayText(node);
-    entries.push({
-      index,
-      fieldFamily,
-      supported,
-      instruction: node.instruction,
-      fieldTarget: node.fieldTarget,
-      refreshStatus: node.refreshStatus ?? (supported ? "stale" : "preserve-only"),
-      displayText
-    });
-    index++;
-    for (const child of node.children) {
-      index = collectFieldsFromInline(child, entries, index);
-    }
-  } else if (node.type === "hyperlink") {
-    for (const child of node.children) {
-      index = collectFieldsFromInline(child, entries, index);
-    }
-  }
-  return index;
-}
-function extractFieldDisplayText(field) {
-  return flattenInlineDisplayText(field.children);
-}
-function flattenInlineDisplayText(children) {
-  return children.map((child) => {
-    switch (child.type) {
-      case "text":
-        return child.text;
-      case "tab":
-        return "	";
-      case "hard_break":
-      case "column_break":
-        return "\n";
-      case "hyperlink":
-      case "field":
-        return flattenInlineDisplayText(child.children);
-      case "footnote_ref":
-        return child.noteId;
-      default:
-        return "";
-    }
-  }).join("");
-}
-function refreshDocumentFields(document, selectionHead, activeStory, options) {
-  const supportedOnly = options?.supportedOnly ?? true;
-  const bookmarkMap = buildBookmarkNameMap(document);
-  const paragraphs = collectParagraphContexts(document.content.children);
-  const navigation = createDocumentNavigationSnapshot(document, selectionHead, activeStory);
-  let updatedCount = 0;
-  let changed = false;
-  let changedFrom;
-  let changedTo;
-  const nextChildren = refreshBlocksWithCursor(document.content.children, (field, range) => {
-    if (!field.fieldFamily || !isSupportedFieldFamily(field.fieldFamily)) {
-      return field;
-    }
-    if (supportedOnly && field.fieldFamily === "TOC") {
-      return field;
-    }
-    const display = resolveSupportedFieldDisplay(
-      field,
-      document,
-      bookmarkMap,
-      paragraphs,
-      navigation
-    );
-    if (!display) {
-      return field;
-    }
-    updatedCount += 1;
-    const nextField = {
-      ...field,
-      children: buildInlineNodesFromDisplayText(display.displayText),
-      refreshStatus: display.refreshStatus
-    };
-    if (nextField.refreshStatus !== field.refreshStatus || flattenInlineDisplayText(nextField.children) !== flattenInlineDisplayText(field.children)) {
-      changed = true;
-      changedFrom = changedFrom === void 0 ? range.from : Math.min(changedFrom, range.from);
-      changedTo = changedTo === void 0 ? range.to : Math.max(changedTo, range.to);
-    }
-    return nextField;
-  }).blocks;
-  if (!changed) {
-    return { document, updatedCount, changed: false };
-  }
-  const nextDocument = {
-    ...document,
-    content: {
-      ...document.content,
-      children: nextChildren
-    }
-  };
-  const nextRegistry = buildFieldRegistry({
-    content: nextDocument.content,
-    styles: nextDocument.styles,
-    subParts: nextDocument.subParts
-  });
-  nextDocument.fieldRegistry = nextRegistry;
-  let protectionSelection;
-  if (changedFrom !== void 0 && changedTo !== void 0) {
-    protectionSelection = createSelectionSnapshot(changedFrom, changedTo);
-  }
-  return {
-    document: nextDocument,
-    updatedCount,
-    changed: true,
-    ...protectionSelection ? { protectionSelection } : {}
-  };
-}
-function refreshDocumentTableOfContents(document, selectionHead, activeStory, options) {
-  const navigation = createDocumentNavigationSnapshot(document, selectionHead, activeStory);
-  let changed = false;
-  let resultEntries = [];
-  let changedFrom;
-  let changedTo;
-  const nextChildren = refreshBlocksWithCursor(document.content.children, (field, range) => {
-    if (field.fieldFamily !== "TOC") {
-      return field;
-    }
-    const levelRange = options?.maxLevel ? { from: 1, to: options.maxLevel } : parseTocLevelRange(field.instruction);
-    const entries = navigation.headings.filter((heading) => heading.level >= levelRange.from && heading.level <= levelRange.to).map((heading) => ({
-      level: heading.level,
-      text: heading.text,
-      pageIndex: heading.pageIndex
-    }));
-    if (resultEntries.length === 0) {
-      resultEntries = entries;
-    }
-    const nextField = {
-      ...field,
-      children: buildTocInlineNodes(entries),
-      refreshStatus: "current"
-    };
-    if (flattenInlineDisplayText(nextField.children) !== flattenInlineDisplayText(field.children)) {
-      changed = true;
-      changedFrom = changedFrom === void 0 ? range.from : Math.min(changedFrom, range.from);
-      changedTo = changedTo === void 0 ? range.to : Math.max(changedTo, range.to);
-    }
-    return nextField;
-  }).blocks;
-  if (!changed) {
-    return {
-      document,
-      result: { entryCount: resultEntries.length, entries: resultEntries },
-      changed: false
-    };
-  }
-  const nextDocument = {
-    ...document,
-    content: {
-      ...document.content,
-      children: nextChildren
-    }
-  };
-  const nextRegistry = buildFieldRegistry({
-    content: nextDocument.content,
-    styles: nextDocument.styles,
-    subParts: nextDocument.subParts
-  });
-  nextDocument.fieldRegistry = nextRegistry.tocStructure ? {
-    ...nextRegistry,
-    tocStructure: {
-      ...nextRegistry.tocStructure,
-      status: "current"
-    }
-  } : nextRegistry;
-  let protectionSelection;
-  if (changedFrom !== void 0 && changedTo !== void 0) {
-    protectionSelection = createSelectionSnapshot(changedFrom, changedTo);
-  }
-  return {
-    document: nextDocument,
-    result: { entryCount: resultEntries.length, entries: resultEntries },
-    changed: true,
-    ...protectionSelection ? { protectionSelection } : {}
-  };
-}
-function refreshBlocksWithCursor(blocks, visitField, cursor = 0, previousParagraph = false) {
-  const nextBlocks = blocks.map((block) => {
-    if (block.type === "paragraph") {
-      const paragraphStart = previousParagraph ? cursor + 1 : cursor;
-      const refreshedChildren = refreshInlineNodesWithCursor(
-        block.children,
-        visitField,
-        paragraphStart
-      );
-      cursor = paragraphStart + refreshedChildren.cursor;
-      previousParagraph = true;
-      return {
-        ...block,
-        children: refreshedChildren.nodes
-      };
-    }
-    if (block.type === "table") {
-      cursor += 1;
-      previousParagraph = false;
-      return {
-        ...block,
-        rows: block.rows.map((row) => ({
-          ...row,
-          cells: row.cells.map((cell) => ({
-            ...cell,
-            children: (() => {
-              const refreshed = refreshBlocksWithCursor(cell.children, visitField, cursor, false);
-              cursor = refreshed.cursor;
-              return refreshed.blocks;
-            })()
-          }))
-        }))
-      };
-    }
-    if (block.type === "sdt" || block.type === "custom_xml") {
-      const refreshed = refreshBlocksWithCursor(
-        block.children,
-        visitField,
-        cursor,
-        previousParagraph
-      );
-      cursor = refreshed.cursor;
-      previousParagraph = refreshed.previousParagraph;
-      return {
-        ...block,
-        children: refreshed.blocks
-      };
-    }
-    cursor += 1;
-    previousParagraph = false;
-    return block;
-  });
-  return { blocks: nextBlocks, cursor, previousParagraph };
-}
-function refreshInlineNodesWithCursor(nodes, visitField, cursor = 0) {
-  const nextNodes = nodes.map((node) => {
-    if (node.type === "field") {
-      const fieldStart = cursor;
-      const refreshedChildren = refreshInlineNodesWithCursor(node.children, visitField, cursor);
-      const fieldLength = measureInlineNodes(node.children);
-      cursor = fieldStart + fieldLength;
-      return visitField({
-        ...node,
-        children: refreshedChildren.nodes
-      }, {
-        from: fieldStart,
-        to: fieldStart + fieldLength
-      });
-    }
-    if (node.type === "hyperlink") {
-      cursor += measureInlineNodes(node.children);
-      return {
-        ...node,
-        // Hyperlinks only contain text-like children in the canonical model.
-        children: [...node.children]
-      };
-    }
-    cursor += measureInlineNode(node);
-    return node;
-  });
-  return { nodes: nextNodes, cursor };
-}
-function buildInlineNodesFromDisplayText(text) {
-  if (text.length === 0) {
-    return [];
-  }
-  const children = [];
-  let buffer = "";
-  const flushBuffer = () => {
-    if (buffer.length > 0) {
-      children.push({ type: "text", text: buffer });
-      buffer = "";
-    }
-  };
-  for (const character of text) {
-    if (character === "	") {
-      flushBuffer();
-      children.push({ type: "tab" });
-      continue;
-    }
-    if (character === "\n") {
-      flushBuffer();
-      children.push({ type: "hard_break" });
-      continue;
-    }
-    buffer += character;
-  }
-  flushBuffer();
-  return children;
-}
-function buildTocInlineNodes(entries) {
-  const children = [];
-  entries.forEach((entry, index) => {
-    children.push({ type: "text", text: entry.text });
-    children.push({ type: "tab" });
-    children.push({ type: "text", text: String(entry.pageIndex + 1) });
-    if (index < entries.length - 1) {
-      children.push({ type: "hard_break" });
-    }
-  });
-  return children;
-}
-function collectFieldsFromSubParts(subParts, entries, index) {
-  if (!subParts) {
-    return index;
-  }
-  let nextIndex = index;
-  for (const header of subParts.headers ?? []) {
-    for (const block of header.blocks) {
-      nextIndex = collectFieldsFromBlock(block, entries, nextIndex);
-    }
-  }
-  for (const footer of subParts.footers ?? []) {
-    for (const block of footer.blocks) {
-      nextIndex = collectFieldsFromBlock(block, entries, nextIndex);
-    }
-  }
-  if (subParts.footnoteCollection) {
-    for (const note of Object.values(subParts.footnoteCollection.footnotes)) {
-      for (const block of note.blocks) {
-        nextIndex = collectFieldsFromBlock(block, entries, nextIndex);
-      }
-    }
-    for (const note of Object.values(subParts.footnoteCollection.endnotes)) {
-      for (const block of note.blocks) {
-        nextIndex = collectFieldsFromBlock(block, entries, nextIndex);
-      }
-    }
-  }
-  return nextIndex;
-}
-function resolveSupportedFieldDisplay(field, document, bookmarkMap, paragraphs, navigation) {
-  if (!field.fieldFamily || !isSupportedFieldFamily(field.fieldFamily)) {
-    return void 0;
-  }
-  if (!field.fieldTarget) {
-    return field.fieldFamily === "TOC" ? void 0 : { displayText: "", refreshStatus: "unresolvable" };
-  }
-  if (field.fieldFamily === "REF") {
-    const result = resolveRefFieldText(document, bookmarkMap, field.fieldTarget);
-    return result ? { displayText: result.text, refreshStatus: result.refreshStatus } : { displayText: "", refreshStatus: "unresolvable" };
-  }
-  const bookmark = bookmarkMap.get(field.fieldTarget);
-  if (!bookmark) {
-    return { displayText: "", refreshStatus: "unresolvable" };
-  }
-  if (field.fieldFamily === "PAGEREF") {
-    const paragraph = paragraphs[bookmark.paragraphIndex];
-    if (!paragraph) {
-      return { displayText: "", refreshStatus: "unresolvable" };
-    }
-    const pageIndex = findPageForOffset(navigation.pages, paragraph.startOffset);
-    return { displayText: String(pageIndex + 1), refreshStatus: "current" };
-  }
-  if (field.fieldFamily === "NOTEREF") {
-    const paragraph = paragraphs[bookmark.paragraphIndex]?.paragraph;
-    if (!paragraph) {
-      return { displayText: "", refreshStatus: "unresolvable" };
-    }
-    const noteText = resolveNoteReferenceText(paragraph, bookmark.bookmarkId);
-    return noteText ? { displayText: noteText, refreshStatus: "current" } : { displayText: "", refreshStatus: "unresolvable" };
-  }
-  return void 0;
-}
-function collectParagraphContexts(blocks) {
-  const paragraphs = [];
-  collectParagraphContextsFromBlocks(blocks, paragraphs, 0, false);
-  return paragraphs;
-}
-function collectParagraphContextsFromBlocks(blocks, paragraphs, cursor, previousParagraph) {
-  let nextCursor = cursor;
-  let nextPreviousParagraph = previousParagraph;
-  for (const block of blocks) {
-    if (block.type === "paragraph") {
-      if (nextPreviousParagraph) {
-        nextCursor += 1;
-      }
-      paragraphs.push({ paragraph: block, startOffset: nextCursor });
-      nextCursor += measureInlineNodes(block.children);
-      nextPreviousParagraph = true;
-      continue;
-    }
-    if (block.type === "table") {
-      nextCursor += 1;
-      nextPreviousParagraph = false;
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          const result = collectParagraphContextsFromBlocks(
-            cell.children,
-            paragraphs,
-            nextCursor,
-            false
-          );
-          nextCursor = result.cursor;
-        }
-      }
-      continue;
-    }
-    if (block.type === "sdt" || block.type === "custom_xml") {
-      const result = collectParagraphContextsFromBlocks(
-        block.children,
-        paragraphs,
-        nextCursor,
-        nextPreviousParagraph
-      );
-      nextCursor = result.cursor;
-      nextPreviousParagraph = result.previousParagraph;
-      continue;
-    }
-    nextCursor += 1;
-    nextPreviousParagraph = false;
-  }
-  return { cursor: nextCursor, previousParagraph: nextPreviousParagraph };
-}
-function measureInlineNodes(nodes) {
-  return nodes.reduce((size, node) => size + measureInlineNode(node), 0);
-}
-function measureInlineNode(node) {
-  switch (node.type) {
-    case "text":
-      return node.text.length;
-    case "tab":
-    case "hard_break":
-    case "column_break":
-    case "footnote_ref":
-    case "image":
-    case "opaque_inline":
-    case "bookmark_start":
-    case "bookmark_end":
-      return 1;
-    case "hyperlink":
-    case "field":
-      return measureInlineNodes(node.children);
-    default:
-      return 1;
-  }
-}
-function resolveNoteReferenceText(paragraph, bookmarkId) {
-  let inside = false;
-  let sawBoundary = false;
-  for (const child of paragraph.children) {
-    if (child.type === "bookmark_start" && child.bookmarkId === bookmarkId) {
-      inside = true;
-      sawBoundary = true;
-      continue;
-    }
-    if (child.type === "bookmark_end" && child.bookmarkId === bookmarkId) {
-      break;
-    }
-    if (!inside) {
-      continue;
-    }
-    if (child.type === "footnote_ref") {
-      return child.noteId;
-    }
-  }
-  return sawBoundary ? void 0 : void 0;
-}
-function getCommandSelection(command, fallbackSelection) {
-  if ("protectionSelection" in command && command.protectionSelection) {
-    return command.protectionSelection;
-  }
-  if ("selection" in command && command.selection) {
-    return command.selection;
-  }
-  return fallbackSelection;
-}
-function isBlockedByProtection(protection, selection) {
-  const enforcedRanges = protection.ranges.filter(
-    (range) => range.enforced && typeof range.start === "number" && typeof range.end === "number"
-  );
-  if (enforcedRanges.length === 0) {
-    return false;
-  }
-  const from = Math.min(selection.anchor, selection.head);
-  const to = Math.max(selection.anchor, selection.head);
-  return !enforcedRanges.some(
-    (range) => from >= range.start && to <= range.end
-  );
-}
-function remapProtectionSnapshot(protection, mapping) {
-  if (mapping.steps.length === 0 || protection.ranges.length === 0) {
-    return protection;
-  }
-  let changed = false;
-  const nextRanges = protection.ranges.map((range) => {
-    if (!range.enforced || typeof range.start !== "number" || typeof range.end !== "number") {
-      return range;
-    }
-    const mapped = mapRange(
-      { from: range.start, to: range.end },
-      { start: -1, end: 1 },
-      mapping
-    );
-    if (mapped.kind === "detached") {
-      changed = true;
-      return {
-        ...range,
-        start: void 0,
-        end: void 0,
-        enforced: false,
-        enforcementReason: "preserve-only: permission range could not be remapped after runtime edits"
-      };
-    }
-    if (mapped.range.from !== range.start || mapped.range.to !== range.end) {
-      changed = true;
-      return {
-        ...range,
-        start: mapped.range.from,
-        end: mapped.range.to
-      };
-    }
-    return range;
-  });
-  if (!changed) {
-    return protection;
-  }
-  return {
-    ...protection,
-    ranges: nextRanges,
-    enforcedRangeCount: nextRanges.filter((range) => range.enforced).length,
-    preservedRangeCount: nextRanges.filter((range) => !range.enforced).length
-  };
-}
-
-export {
-  createDocumentRuntime
-};
-//# sourceMappingURL=chunk-KD2QRQPY.js.map