@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/chunk-KD2QRQPY.js

@@ -0,0 +1,4342 @@
+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