@beyondwork/docx-react-component 1.0.48 → 1.0.50

package/src/runtime/collab/runtime-collab-sync.ts

@@ -22,6 +22,7 @@ import {
 } from "./event-types.ts";
 import { computeBaseDocFingerprint } from "./base-doc-fingerprint.ts";
 import type { Checkpoint } from "./checkpoint-store.ts";
+import { createWorkflowShared, type WorkflowSharedHandle } from "./workflow-shared.ts";
 
 /** Shared Y.Map key — {@link SHARED_META_MAP_KEY}. */
 const SHARED_META_MAP_KEY = "meta";
@@ -188,6 +189,17 @@ export interface RuntimeCollabSyncOptions {
   runtime: DocumentRuntime;
   authorId: string;
   commandAppliedBridge: RuntimeCommandAppliedBridge;
+  /**
+   * Role of the local peer for workflow-shared gating. Defaults to `"author"`
+   * for backward compatibility with pre-P13 callers — ⚠ OMITTING THIS FIELD
+   * GRANTS AUTHOR-LEVEL WRITE ACCESS to the shared `workflow` Y.Map. Hosts
+   * that derive role from Awareness or an external auth layer should pass
+   * it explicitly to avoid silently promoting reviewers/observers to authors.
+   * - `"author"`: all workflow writes allowed.
+   * - `"reviewer"`: only `setAssignedReviewers` allowed; other writes refused.
+   * - `"observer"`: all writes refused with `collab_observer_readonly`.
+   */
+  role?: "author" | "reviewer" | "observer";
 }
 
 export interface RuntimeCollabSyncHandle {
@@ -217,6 +229,14 @@ export interface RuntimeCollabSyncHandle {
    * checkpoint covers previously-seen events).
    */
   getAppliedEventCount(): number;
+  /**
+   * Returns the shared workflow handle backing the `workflow` Y.Map.
+   * Hosts can call `.setLockedMode()`, `.setRoundDeadline()`,
+   * `.setAssignedReviewers()`, and `.setWorkItemId()` to propagate
+   * state changes to other peers. Role gating (passed in `options.role`)
+   * enforces write permissions per §7 of the lane plan.
+   */
+  getWorkflowShared(): WorkflowSharedHandle;
 }
 
 export function createRuntimeCommandAppliedBridge(): RuntimeCommandAppliedBridge {
@@ -332,6 +352,31 @@ export function createRuntimeCollabSync(
     emit({ type: "collab_sync_attached", baseDocFingerprint });
   }
 
+  // ---------------------------------------------------------------------------
+  // Workflow shared state — P13 Slice C
+  // ---------------------------------------------------------------------------
+  // Construct a WorkflowSharedHandle over `ydoc.getMap("workflow")`. The
+  // handle subscribes to Y.Map changes and propagates them to the runtime
+  // via `setSharedWorkflowState`. Role gating is enforced by the handle
+  // itself; the `role` option defaults to `"author"` for historical compat.
+  const effectiveRole = options.role ?? "author";
+  const workflowShared = createWorkflowShared({
+    ydoc,
+    role: effectiveRole,
+    localAuthorId: authorId,
+  });
+
+  // Seed initial state synchronously. For a fresh Y.Doc this is `{}`.
+  // For a late joiner it may already be populated — the seed ensures the
+  // runtime reflects pre-existing shared state at attach time (i.e. if a
+  // peer already set `lockedMode`, the new peer starts out locked).
+  runtime.setSharedWorkflowState(workflowShared.get());
+
+  const workflowUnsub = workflowShared.subscribe((state) => {
+    if (readOnly) return; // don't propagate while in read-only (post-mismatch)
+    runtime.setSharedWorkflowState(state);
+  });
+
   const unsubscribeCommandApplied = commandAppliedBridge.subscribe((command, _transaction, context, meta) => {
     if (readOnly) {
       return;
@@ -453,6 +498,9 @@ export function createRuntimeCollabSync(
       yEvents.unobserve(onYEventsChange);
       yMeta.unobserve(checkFingerprintAgainstMeta);
       yCheckpoints.unobserve(onCheckpointsChange);
+      workflowUnsub();
+      workflowShared.destroy();
+      runtime.setSharedWorkflowState(null);
       listeners.clear();
     },
     subscribe(listener) {
@@ -481,6 +529,9 @@ export function createRuntimeCollabSync(
     getAppliedEventCount() {
       return appliedEventIds.size;
     },
+    getWorkflowShared() {
+      return workflowShared;
+    },
   };
 
   function onYEventsChange(event: Y.YArrayEvent<CommandEvent>): void {

package/src/runtime/collab/workflow-shared.ts

@@ -0,0 +1,247 @@
+import * as Y from "yjs";
+
+import type { CollabBlockReason } from "../../api/comment-negotiation-types.ts";
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface SharedWorkflowState {
+  lockedMode?: "editing" | "suggesting" | "commenting" | "viewing";
+  roundDeadline?: string; // ISO-8601
+  assignedReviewers?: string[]; // userIds
+  workItemId?: string;
+}
+
+export interface CreateWorkflowSharedOptions {
+  ydoc: Y.Doc;
+  role: "author" | "reviewer" | "observer";
+  /**
+   * Reserved for future audit use — emit `{ actor: localAuthorId }` on
+   * writes once the audit path lands. Currently unused at runtime;
+   * optional so callers without an author-id scheme don't have to
+   * fabricate one.
+   */
+  localAuthorId?: string;
+}
+
+export type WorkflowSharedResult =
+  | { ok: true }
+  | { ok: false; reason: CollabBlockReason };
+
+export interface WorkflowSharedHandle {
+  get(): SharedWorkflowState;
+  setLockedMode(mode: SharedWorkflowState["lockedMode"]): WorkflowSharedResult;
+  setRoundDeadline(deadline: string | undefined): WorkflowSharedResult;
+  setAssignedReviewers(reviewers: string[]): WorkflowSharedResult;
+  setWorkItemId(id: string | undefined): WorkflowSharedResult;
+  subscribe(listener: (state: SharedWorkflowState) => void): () => void;
+  destroy(): void;
+}
+
+// ---------------------------------------------------------------------------
+// Y.Map key constants
+// ---------------------------------------------------------------------------
+
+const WORKFLOW_MAP_NAME = "workflow";
+const KEY_LOCKED_MODE = "lockedMode";
+const KEY_ROUND_DEADLINE = "roundDeadline";
+const KEY_ASSIGNED_REVIEWERS = "assignedReviewers";
+const KEY_WORK_ITEM_ID = "workItemId";
+
+// ---------------------------------------------------------------------------
+// Shallow-equality helpers
+// ---------------------------------------------------------------------------
+
+function arrayShallowEqual(
+  a: string[] | undefined,
+  b: string[] | undefined,
+): boolean {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function stateShallowEqual(
+  a: SharedWorkflowState,
+  b: SharedWorkflowState,
+): boolean {
+  return (
+    a.lockedMode === b.lockedMode &&
+    a.roundDeadline === b.roundDeadline &&
+    a.workItemId === b.workItemId &&
+    arrayShallowEqual(a.assignedReviewers, b.assignedReviewers)
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a handle over `ydoc.getMap<unknown>("workflow")` that propagates
+ * shared workflow state — `lockedMode`, `roundDeadline`, `assignedReviewers`,
+ * and `workItemId` — across collab peers via per-key Yjs LWW conflict
+ * resolution.
+ *
+ * Role-gating (§7 lane plan):
+ * - observer: all writes refused with `collab_observer_readonly`.
+ * - reviewer: only `setAssignedReviewers` allowed; other writes refused with
+ *   `collab_role_restricted`.
+ * - author: all writes allowed.
+ */
+export function createWorkflowShared(
+  options: CreateWorkflowSharedOptions,
+): WorkflowSharedHandle {
+  const { ydoc, role } = options;
+  // Reserved for future audit path — see CreateWorkflowSharedOptions.localAuthorId.
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const _localAuthorId = options.localAuthorId;
+
+  const yMap = ydoc.getMap<unknown>(WORKFLOW_MAP_NAME);
+
+  const listeners = new Set<(state: SharedWorkflowState) => void>();
+  let destroyed = false;
+  let lastEmitted: SharedWorkflowState | null = null;
+
+  // -------------------------------------------------------------------------
+  // Read helper
+  // -------------------------------------------------------------------------
+
+  function readState(): SharedWorkflowState {
+    const state: SharedWorkflowState = {};
+    const lockedMode = yMap.get(KEY_LOCKED_MODE);
+    if (lockedMode !== undefined) {
+      state.lockedMode = lockedMode as SharedWorkflowState["lockedMode"];
+    }
+    const roundDeadline = yMap.get(KEY_ROUND_DEADLINE);
+    if (roundDeadline !== undefined) {
+      state.roundDeadline = roundDeadline as string;
+    }
+    const assignedReviewers = yMap.get(KEY_ASSIGNED_REVIEWERS);
+    if (assignedReviewers !== undefined) {
+      state.assignedReviewers = [...(assignedReviewers as string[])];
+    }
+    const workItemId = yMap.get(KEY_WORK_ITEM_ID);
+    if (workItemId !== undefined) {
+      state.workItemId = workItemId as string;
+    }
+    return state;
+  }
+
+  // -------------------------------------------------------------------------
+  // Observer — dedup-fires listeners on any Y.Map change
+  // -------------------------------------------------------------------------
+
+  function onMapChange(): void {
+    if (destroyed) return;
+    if (listeners.size === 0) {
+      lastEmitted = null;
+      return;
+    }
+    const next = readState();
+    if (lastEmitted !== null && stateShallowEqual(lastEmitted, next)) {
+      return; // deduplicated — same state, skip fire
+    }
+    lastEmitted = next;
+    for (const listener of [...listeners]) {
+      try {
+        listener(next);
+      } catch {
+        // Listener exceptions are isolated; the handle continues.
+      }
+    }
+  }
+
+  yMap.observe(onMapChange);
+
+  // -------------------------------------------------------------------------
+  // Role-gating helpers
+  // -------------------------------------------------------------------------
+
+  function checkObserver(): WorkflowSharedResult | null {
+    if (role === "observer") {
+      return { ok: false, reason: "collab_observer_readonly" };
+    }
+    return null;
+  }
+
+  function checkReviewerRestricted(): WorkflowSharedResult | null {
+    if (role === "reviewer") {
+      return { ok: false, reason: "collab_role_restricted" };
+    }
+    return null;
+  }
+
+  // -------------------------------------------------------------------------
+  // Handle
+  // -------------------------------------------------------------------------
+
+  return {
+    get(): SharedWorkflowState {
+      return readState();
+    },
+
+    setLockedMode(mode): WorkflowSharedResult {
+      const denied = checkObserver() ?? checkReviewerRestricted();
+      if (denied) return denied;
+      if (mode === undefined) {
+        yMap.delete(KEY_LOCKED_MODE);
+      } else {
+        yMap.set(KEY_LOCKED_MODE, mode);
+      }
+      return { ok: true };
+    },
+
+    setRoundDeadline(deadline): WorkflowSharedResult {
+      const denied = checkObserver() ?? checkReviewerRestricted();
+      if (denied) return denied;
+      if (deadline === undefined) {
+        yMap.delete(KEY_ROUND_DEADLINE);
+      } else {
+        yMap.set(KEY_ROUND_DEADLINE, deadline);
+      }
+      return { ok: true };
+    },
+
+    setAssignedReviewers(reviewers): WorkflowSharedResult {
+      const denied = checkObserver();
+      if (denied) return denied;
+      // reviewer is allowed here — do NOT call checkReviewerRestricted().
+      yMap.set(KEY_ASSIGNED_REVIEWERS, [...reviewers]);
+      return { ok: true };
+    },
+
+    setWorkItemId(id): WorkflowSharedResult {
+      const denied = checkObserver() ?? checkReviewerRestricted();
+      if (denied) return denied;
+      if (id === undefined) {
+        yMap.delete(KEY_WORK_ITEM_ID);
+      } else {
+        yMap.set(KEY_WORK_ITEM_ID, id);
+      }
+      return { ok: true };
+    },
+
+    subscribe(listener): () => void {
+      listeners.add(listener);
+      // Reset dedup baseline so the next change always fires fresh.
+      lastEmitted = null;
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+
+    destroy(): void {
+      if (destroyed) return;
+      destroyed = true;
+      yMap.unobserve(onMapChange);
+      listeners.clear();
+      lastEmitted = null;
+    },
+  };
+}

package/src/runtime/document-locations.ts

@@ -18,6 +18,7 @@ import type {
 } from "../api/public-types";
 import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
 import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
+import { createPublicRangeAnchor } from "../core/selection/anchor-conversion.ts";
 import {
   createDocumentSectionSnapshots,
   findBookmarkNameForOffset,
@@ -47,15 +48,6 @@ function createLocationId(anchor: EditorAnchorProjection, storyTarget?: EditorSt
   }
 }
 
-function createPublicRangeAnchor(from: number, to: number): EditorAnchorProjection {
-  return {
-    kind: "range",
-    from,
-    to,
-    assoc: { start: -1, end: 1 },
-  };
-}
-
 function resolveOffsetMetadata(
   navigation: DocumentNavigationSnapshot,
   offset: number,

package/src/runtime/document-outline.ts

@@ -18,6 +18,7 @@ import type {
 import type { CanonicalDocumentEnvelope } from "../core/state/editor-state.ts";
 import { createSelectionSnapshot } from "../core/state/editor-state.ts";
 import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
+import { createPublicRangeAnchor } from "../core/selection/anchor-conversion.ts";
 import { parseTocLevelRange } from "../io/ooxml/parse-fields.ts";
 import { buildPageLayoutSnapshot, buildResolvedSections } from "./document-layout.ts";
 import { createDocumentNavigationSnapshot } from "./document-navigation.ts";
@@ -34,15 +35,6 @@ function getAnchorOffset(anchor: EditorAnchorProjection): number | undefined {
   }
 }
 
-function createPublicRangeAnchor(from: number, to: number): EditorAnchorProjection {
-  return {
-    kind: "range",
-    from,
-    to,
-    assoc: { start: -1, end: 1 },
-  };
-}
-
 export function resolveHeadingPath(
   headings: readonly DocumentHeadingSnapshot[],
   offset: number | undefined,

package/src/runtime/document-runtime.ts

@@ -30,6 +30,8 @@ import type {
   DocumentTextToken,
   EditorSessionState,
   EditorAnchorProjection,
+  CanonicalDocumentFragment,
+  TextFormattingDirective,
   EditorError,
   EditorStoryTarget,
   EditorViewStateSnapshot,
@@ -104,7 +106,14 @@ import {
   storyTargetsEqual,
   type EditorAnchorProjection as InternalEditorAnchorProjection,
 } from "../core/selection/mapping.ts";
-import { canCreateDocxCommentAnchor } from "../core/selection/review-anchors.ts";
+import {
+  toInternalAnchorProjection,
+  toPublicAnchorProjection,
+} from "../core/selection/anchor-conversion.ts";
+import {
+  commentAnchorRejectionReason,
+  snapCommentAnchorAwayFromTable,
+} from "../core/selection/review-anchors.ts";
 import { buildBookmarkNameMap } from "../legal/bookmarks.ts";
 import {
   describeOpaqueFragment,
@@ -232,6 +241,7 @@ import type {
 } from "../api/editor-state-types.ts";
 import { collectEditorStateForSerialize } from "./editor-state-integration.ts";
 import type { EditorStatePayload } from "../io/ooxml/workflow-payload.ts";
+import type { SharedWorkflowState } from "./collab/workflow-shared.ts";
 
 /** Internal extension of ExportDocxOptions that threads the collected
  *  editorState payload from the runtime to the docx serializer. */
@@ -257,7 +267,8 @@ export type ActiveStoryTextCommand =
   | Extract<EditorCommand, { type: "text.insert-tab" }>
   | Extract<EditorCommand, { type: "text.outdent-tab" }>
   | Extract<EditorCommand, { type: "text.insert-hard-break" }>
-  | Extract<EditorCommand, { type: "paragraph.split" }>;
+  | Extract<EditorCommand, { type: "paragraph.split" }>
+  | Extract<EditorCommand, { type: "fragment.insert" }>;
 
 export interface DocumentRuntime {
   subscribe(listener: () => void): Unsubscribe;
@@ -265,7 +276,8 @@ export interface DocumentRuntime {
   getRenderSnapshot(): RuntimeRenderSnapshot;
   getCanonicalDocument(): CanonicalDocumentEnvelope;
   getSourcePackage(): EditorSessionState["sourcePackage"] | undefined;
-  replaceText(text: string, target?: EditorAnchorProjection): void;
+  replaceText(text: string, target?: EditorAnchorProjection, formatting?: TextFormattingDirective): void;
+  insertFragment(fragment: CanonicalDocumentFragment, target?: EditorAnchorProjection): void;
   applyActiveStoryTextCommand(command: ActiveStoryTextCommand): TextCommandAck;
   dispatch(command: EditorCommand): void;
   /**
@@ -359,6 +371,7 @@ export interface DocumentRuntime {
   setWorkflowOverlay(overlay: WorkflowOverlay): void;
   clearWorkflowOverlay(): void;
   getWorkflowOverlay(): WorkflowOverlay | null;
+  setSharedWorkflowState(state: SharedWorkflowState | null): void;
   getWorkflowScopeSnapshot(): WorkflowScopeSnapshot | null;
   getInteractionGuardSnapshot(): InteractionGuardSnapshot;
   getWorkflowMarkupSnapshot(): WorkflowMarkupSnapshot;
@@ -629,6 +642,9 @@ export function createDocumentRuntime(
     ?? options.initialSnapshot?.workflowMetadata?.entries
     ?? [];
   let hostAnnotationOverlay: HostAnnotationOverlay | null = null;
+  // P13 Slice B: shared workflow state from the collab Y.Map "workflow".
+  // Set via setSharedWorkflowState(); observed by evaluateWorkflowBlockedReasons.
+  let sharedWorkflowState: SharedWorkflowState | null = null;
   const initialPersistedSnapshot = options.initialSessionState
     ? persistedSnapshotFromEditorSessionState(options.initialSessionState, {
         savedAt: options.initialSessionState.updatedAt,
@@ -873,6 +889,7 @@ export function createDocumentRuntime(
         documentMode: DocumentMode;
         protectionSnapshot: ProtectionSnapshot;
         workflowOverlay: WorkflowOverlay | null;
+        sharedWorkflowState: SharedWorkflowState | null;
         snapshot: InteractionGuardSnapshot;
       }
     | undefined;
@@ -1140,6 +1157,29 @@ export function createDocumentRuntime(
     commandType?: string,
   ): WorkflowBlockedCommandReason[] {
     const reasons: WorkflowBlockedCommandReason[] = [];
+    // P13 Slice B: shared lockedMode overrides all other scope checks when
+    // non-editing. Short-circuit: no other scope reason applies when the round
+    // is locked (the round state supersedes scope/overlay-level gating).
+    // Emit a reason code whose effectiveMode mapping matches the mode intent:
+    //   "commenting" → workflow_comment_only (maps to effectiveMode: "comment")
+    //   "viewing"    → workflow_view_only    (maps to effectiveMode: "view")
+    //   "suggesting" → workflow_round_locked (no existing mapping; stays "blocked"
+    //                   for this slice — full suggesting-mode semantics will be a
+    //                   future slice that hooks getEffectiveDocumentMode instead).
+    if (sharedWorkflowState?.lockedMode && sharedWorkflowState.lockedMode !== "editing") {
+      const lockedMode = sharedWorkflowState.lockedMode;
+      const code: WorkflowBlockedCommandReason["code"] =
+        lockedMode === "commenting"
+          ? "workflow_comment_only"
+          : lockedMode === "viewing"
+            ? "workflow_view_only"
+            : "workflow_round_locked";
+      reasons.push({
+        code,
+        message: `Round is locked to ${lockedMode} mode.`,
+      });
+      return reasons;
+    }
     const selectionBounds = {
       from: Math.min(selection.anchor, selection.head),
       to: Math.max(selection.anchor, selection.head),
@@ -1552,7 +1592,8 @@ export function createDocumentRuntime(
       cachedInteractionGuardSnapshot.readOnly === state.readOnly &&
       cachedInteractionGuardSnapshot.documentMode === viewState.documentMode &&
       cachedInteractionGuardSnapshot.protectionSnapshot === protectionSnapshot &&
-      cachedInteractionGuardSnapshot.workflowOverlay === workflowOverlay
+      cachedInteractionGuardSnapshot.workflowOverlay === workflowOverlay &&
+      cachedInteractionGuardSnapshot.sharedWorkflowState === sharedWorkflowState
     ) {
       return cachedInteractionGuardSnapshot.snapshot;
     }
@@ -1613,6 +1654,7 @@ export function createDocumentRuntime(
       documentMode: viewState.documentMode,
       protectionSnapshot,
       workflowOverlay,
+      sharedWorkflowState,
       snapshot,
     };
     return snapshot;
@@ -2256,13 +2298,14 @@ export function createDocumentRuntime(
     getDefaultAuthorId() {
       return defaultAuthorId;
     },
-    replaceText(text, target) {
+    replaceText(text, target, formatting) {
       try {
         const timestamp = clock();
         applyTextCommandInActiveStory(
           {
             type: "text.insert",
             text,
+            ...(formatting ? { formatting } : {}),
             origin: createOrigin("api", timestamp),
           },
           {
@@ -2274,6 +2317,26 @@ export function createDocumentRuntime(
         emitError(toRuntimeError(error));
       }
     },
+    insertFragment(fragment, target) {
+      // I2 Tier B Slice 1 — dispatch `fragment.insert` against the active story. The
+      // runtime command handler routes into `applyFragmentInsert` (structure-ops).
+      try {
+        const timestamp = clock();
+        applyTextCommandInActiveStory(
+          {
+            type: "fragment.insert",
+            fragment,
+            origin: createOrigin("api", timestamp),
+          },
+          {
+            selection: target ? createSelectionFromPublicAnchor(target) : state.selection,
+            blockedCommandName: "insertFragment",
+          },
+        );
+      } catch (error) {
+        emitError(toRuntimeError(error));
+      }
+    },
     applyActiveStoryTextCommand(command) {
       try {
         return applyTextCommandInActiveStory(command);
@@ -2309,22 +2372,39 @@ export function createDocumentRuntime(
         throw toStructuredRuntimeException(error);
       }
       const commentId = createEntityId("comment", state.document.review.comments, clock());
-      const anchor = params.anchor
+      let anchor = params.anchor
         ? toInternalAnchorProjection(params.anchor)
         : state.selection.activeRange;
-      const selection = params.anchor
+      let selection = params.anchor
         ? createSelectionFromPublicAnchor(params.anchor)
         : state.selection;
-      if (!canCreateDocxCommentAnchor(cachedRenderSnapshot.surface, anchor)) {
+      if (params.snapToSafeBoundary === true) {
+        const snapped = snapCommentAnchorAwayFromTable(
+          cachedRenderSnapshot.surface,
+          anchor,
+        );
+        if (snapped !== null && snapped !== anchor) {
+          anchor = snapped;
+          selection = createSelectionFromPublicAnchor(toPublicAnchorProjection(snapped));
+        }
+      }
+      const rejectionReason = commentAnchorRejectionReason(
+        cachedRenderSnapshot.surface,
+        anchor,
+      );
+      if (rejectionReason !== null) {
+        const message =
+          rejectionReason === "comment_anchor_table_adjacent"
+            ? "DOCX comments cannot currently anchor mid-run within a paragraph adjacent to a table boundary — snap the range to a paragraph or word boundary and retry."
+            : "DOCX comments must use a non-empty range that stays within a single story and does not cross table or opaque-fragment boundaries.";
         const error: InternalEditorError = {
           errorId: createSessionId("comment-anchor", clock()),
           code: "validation_failed",
           isFatal: false,
-          message:
-            "DOCX comments must use a non-empty range that stays within a single story and does not cross table or opaque-fragment boundaries.",
+          message,
           source: "runtime",
           details: {
-            reason: "invalid_comment_anchor",
+            reason: rejectionReason,
           },
         };
         emitError(error);
@@ -2954,6 +3034,13 @@ export function createDocumentRuntime(
     getWorkflowOverlay() {
       return workflowOverlay;
     },
+    setSharedWorkflowState(state) {
+      if (state === sharedWorkflowState) return;
+      sharedWorkflowState = state;
+      // Invalidate guard/scope caches so next derivation reflects the new state.
+      cachedInteractionGuardSnapshot = undefined;
+      cachedWorkflowScopeSnapshot = undefined;
+    },
     getWorkflowScopeSnapshot() {
       return getCachedWorkflowScopeSnapshot();
     },
@@ -4152,45 +4239,6 @@ function toPublicSelectionSnapshot(
   };
 }
 
-function toPublicAnchorProjection(
-  anchor: InternalEditorAnchorProjection,
-): EditorAnchorProjection {
-  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: EditorAnchorProjection,
-): InternalEditorAnchorProjection {
-  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: EditorAnchorProjection,
 ): import("../core/state/editor-state.ts").SelectionSnapshot {