@beyondwork/docx-react-component 1.0.82 → 1.0.84

package/src/runtime/scopes/action-validation.ts

@@ -204,55 +204,64 @@ function collectGuardVerdict(
   }
 
   const guard = runtime.getInteractionGuardSnapshot();
-  if (
-    guard.effectiveMode === "view" &&
-    !blockedReasons.includes("guard:view-mode-active")
-  ) {
-    blockedReasons.push("guard:view-mode-active");
+  // Scope-targeted writes target `scope.handle.scopeId`, not the current
+  // editor selection. The target scope's own overlay posture was handled
+  // above through `scope.workflow.effectiveMode`; this second guard read is
+  // only allowed to contribute global/session-wide blockers.
+  const isSelectionScopeMembershipReason = (reason: { readonly code: string; readonly scopeId?: string }): boolean => {
+    if (reason.code === "outside_workflow_scope") return true;
+    if (
+      (reason.code === "workflow_view_only" ||
+        reason.code === "workflow_comment_only") &&
+      typeof reason.scopeId === "string" &&
+      reason.scopeId.length > 0
+    ) {
+      return true;
+    }
+    return false;
+  };
+  const rawReasons = guard.blockedReasons ?? [];
+  const nonSelectionScoped = rawReasons.filter(
+    (r) => !isSelectionScopeMembershipReason(r),
+  );
+  const pushTypedGuardBlocker = (code: string | undefined): void => {
+    const suffix = typeof code === "string" && code.length > 0
+      ? code
+      : "unspecified";
+    const typedBlocker = `guard:block-${suffix}`;
+    if (!blockedReasons.some((existing) => existing === typedBlocker)) {
+      blockedReasons.push(typedBlocker);
+    }
+  };
+  if (guard.effectiveMode === "view") {
+    const globalViewReason = nonSelectionScoped.find(
+      (reason) => reason.code === "workflow_view_only",
+    );
+    if (globalViewReason) {
+      pushTypedGuardBlocker(globalViewReason.code);
+    } else if (
+      rawReasons.length === 0 &&
+      !blockedReasons.includes("guard:view-mode-active")
+    ) {
+      blockedReasons.push("guard:view-mode-active");
+    }
+  }
+  if (guard.effectiveMode === "comment") {
+    const globalCommentReason = nonSelectionScoped.find(
+      (reason) => reason.code === "workflow_comment_only",
+    );
+    if (globalCommentReason) {
+      pushTypedGuardBlocker(globalCommentReason.code);
+    }
   }
   if (guard.effectiveMode === "blocked") {
     // Coord-06 §13e — promote the bare `guard:blocked` blocker to a typed
-    // `guard:block-<reason>` suffix so agents can route intelligently on
-    // boundary-paragraph / system-paragraph / read-only / protected-range
-    // situations. The specific sub-reason is the first NON-selection-
-    // scope-membership reason.
-    //
-    // Scope-targeted-write carve-out (coord-09, TemplateViewer repro
-    // 2026-04-24): `applyReplacementScope`, `attachExplanation`, and
-    // `createIssue` target a scopeId, not the current editor selection.
-    // The scope's own `workflow.effectiveMode` already drove the
-    // scope-level arm of `collectGuardVerdict` above (lines 159–197).
-    // The selection-scoped coordinator guard, in contrast, evaluates
-    // against the live `state.selection` — which, for scope-targeted
-    // writes, may sit anywhere in the document. Reasons that depend on
-    // selection-scope membership (`outside_workflow_scope`,
-    // `workflow_view_only`, `workflow_comment_only`) are therefore
-    // double-counting and must not block. Globally-scoped reasons
-    // (`document_read_only`, `document_viewing_mode`) still apply — a
-    // read-only doc rejects every write, scope-targeted or not.
-    const SELECTION_SCOPE_MEMBERSHIP_CODES = new Set([
-      "outside_workflow_scope",
-      "workflow_view_only",
-      "workflow_comment_only",
-    ]);
-    const rawReasons = guard.blockedReasons ?? [];
-    const nonSelectionScoped = rawReasons.filter(
-      (r) => !SELECTION_SCOPE_MEMBERSHIP_CODES.has(r.code),
-    );
-    // If every reason was selection-scope-membership for a scope-
-    // targeted write, emit no blocker — the scope-level arm above is
-    // authoritative. The defensive empty-array fallback
-    // (guard:block-unspecified) still fires when the coordinator
-    // produced effectiveMode:"blocked" without any reasons at all.
+    // `guard:block-<reason>` suffix. Selection-membership reasons are
+    // intentionally ignored here; global/session reasons such as read-only,
+    // protected ranges, shared workflow locks, and unsupported suggesting
+    // commands remain blockers.
     if (nonSelectionScoped.length > 0 || rawReasons.length === 0) {
-      const primaryCode = nonSelectionScoped[0]?.code;
-      const suffix = typeof primaryCode === "string" && primaryCode.length > 0
-        ? primaryCode
-        : "unspecified";
-      const typedBlocker = `guard:block-${suffix}`;
-      if (!blockedReasons.some((existing) => existing === typedBlocker)) {
-        blockedReasons.push(typedBlocker);
-      }
+      pushTypedGuardBlocker(nonSelectionScoped[0]?.code);
     }
   }
   for (const reason of guard.blockedReasons ?? []) {

package/src/runtime/scopes/workflow-overlap.ts

@@ -3,11 +3,13 @@
  *
  * Given a scope's canonical range and the workflow overlay, returns the
  * `SemanticScopeWorkflow` projection: the ids of overlay scopes overlapping
- * the range + the most-restrictive `effectiveMode` across them +
- * `blockedReasons` when a `view`-mode overlap blocks the scope.
+ * the range + the most-restrictive enforced `effectiveMode` across scopes
+ * whose `guardPolicy` participates in editing + `blockedReasons` when a
+ * read-only overlap blocks the scope.
  *
  * The most-restrictive rule matches layer 06's `InteractionGuardSnapshot`
- * composition (see `docs/architecture/06-workflow-review.md` §W3):
+ * composition for guard-participating scopes (see
+ * `docs/architecture/06-workflow-review.md` §W3):
  *   view > comment > suggest > edit
  *
  * When no overlay is threaded, or no overlap exists, the returned shape
@@ -19,7 +21,11 @@
  * overlap on top.
  */
 
-import type { WorkflowOverlay, WorkflowScope } from "./_scope-dependencies.ts";
+import type {
+  WorkflowOverlay,
+  WorkflowScope,
+  WorkflowScopeGuardPolicy,
+} from "./_scope-dependencies.ts";
 
 import type { ScopePositionMap, ScopePositionRange } from "./position-map.ts";
 import { rangesOverlap } from "./scope-range.ts";
@@ -27,6 +33,14 @@ import type { SemanticScopeWorkflow } from "./semantic-scope-types.ts";
 
 type WorkflowMode = "edit" | "suggest" | "comment" | "view";
 
+function getScopeGuardPolicy(scope: WorkflowScope): WorkflowScopeGuardPolicy {
+  return scope.guardPolicy ?? (scope.mode === "view" ? "read-only" : "none");
+}
+
+function getScopeGuardMode(scope: WorkflowScope): WorkflowMode {
+  return getScopeGuardPolicy(scope) === "read-only" ? "view" : scope.mode;
+}
+
 function modeRank(mode: WorkflowMode): number {
   // Higher = more restrictive (wins the merge).
   switch (mode) {
@@ -45,6 +59,21 @@ function mergeModes(a: WorkflowMode, b: WorkflowMode): WorkflowMode {
   return modeRank(a) >= modeRank(b) ? a : b;
 }
 
+function rangeForWorkflowScope(
+  scope: WorkflowScope,
+  positionMap: ScopePositionMap,
+): ScopePositionRange | null {
+  const markerRange = positionMap.markerScopes.get(scope.scopeId);
+  if (markerRange) return markerRange;
+  if (scope.anchor.kind === "range") {
+    return { from: scope.anchor.from, to: scope.anchor.to };
+  }
+  if (scope.anchor.kind === "node") {
+    return { from: scope.anchor.at, to: scope.anchor.at };
+  }
+  return null;
+}
+
 export interface WorkflowOverlapInputs {
   readonly overlay: WorkflowOverlay | null | undefined;
   readonly positionMap: ScopePositionMap;
@@ -73,12 +102,15 @@ export function resolveWorkflowOverlap(
   let mode: WorkflowMode = "edit";
   for (const scope of overlay.scopes as readonly WorkflowScope[]) {
     if (selfScopeIds && selfScopeIds.has(scope.scopeId)) continue;
-    const markerRange = positionMap.markerScopes.get(scope.scopeId);
-    if (!markerRange) continue;
-    if (!rangesOverlap(range, markerRange)) continue;
+    const scopeRange = rangeForWorkflowScope(scope, positionMap);
+    if (!scopeRange) continue;
+    if (!rangesOverlap(range, scopeRange)) continue;
     overlappingIds.push(scope.scopeId);
-    mode = mergeModes(mode, scope.mode);
-    if (scope.mode === "view") {
+    const guardPolicy = getScopeGuardPolicy(scope);
+    if (guardPolicy === "none") continue;
+    const guardMode = getScopeGuardMode(scope);
+    mode = mergeModes(mode, guardMode);
+    if (guardMode === "view") {
       blockedReasons.push(`workflow-scope-view:${scope.scopeId}`);
     }
   }

package/src/runtime/workflow/coordinator.ts

@@ -64,6 +64,7 @@ import type {
   WorkflowMetadataSnapshot,
   WorkflowOverlay,
   WorkflowScope,
+  WorkflowScopeGuardPolicy,
   WorkflowScopeMode,
   WorkflowScopeSnapshot,
 } from "../../api/public-types.ts";
@@ -227,6 +228,11 @@ export interface WorkflowCoordinator {
   addInvisibleScope(params: AddScopeParams): AddScopeResult;
   setScopeVisibility(scopeId: string, visibility: ScopeVisibility): void;
   getScopeVisibility(scopeId: string): ScopeVisibility;
+  setScopeGuardPolicy(
+    scopeId: string,
+    guardPolicy: WorkflowScopeGuardPolicy,
+  ): void;
+  getScopeGuardPolicy(scopeId: string): WorkflowScopeGuardPolicy;
   getScope(scopeId: string): WorkflowScope | null;
   getMarkerBackedScopeIds(): ReadonlySet<string>;
   /* --- scope chrome visibility (local view state) --- */
@@ -316,6 +322,18 @@ const MODE_RESTRICTIVENESS: Record<WorkflowScopeMode, number> = {
   view: 3,
 };
 
+function resolveScopeGuardPolicy(scope: WorkflowScope): WorkflowScopeGuardPolicy {
+  return scope.guardPolicy ?? (scope.mode === "view" ? "read-only" : "none");
+}
+
+function getScopeGuardMode(scope: WorkflowScope): WorkflowScopeMode {
+  return resolveScopeGuardPolicy(scope) === "read-only" ? "view" : scope.mode;
+}
+
+function participatesInInteractionGuard(scope: WorkflowScope): boolean {
+  return resolveScopeGuardPolicy(scope) !== "none";
+}
+
 export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordinator {
   const { overlayStore, clock } = deps;
 
@@ -413,8 +431,7 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     };
     const activeScopes = getEffectiveWorkflowScopes(overlay);
     const matching = activeScopes.filter((scope) => {
-      // §C8: invisible non-view scopes are transparent to the guard.
-      if (scope.visibility === "invisible" && scope.mode !== "view") return false;
+      if (!participatesInInteractionGuard(scope)) return false;
       if (scope.anchor.kind === "detached") return false;
       const scopeFrom =
         scope.anchor.kind === "range" ? scope.anchor.from : scope.anchor.at;
@@ -450,8 +467,8 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     if (stack.length === 0) return null;
     // §C6 — most-restrictive-wins across overlapping scopes.
     return stack.reduce((best, scope) =>
-      (MODE_RESTRICTIVENESS[scope.mode] ?? 0) >
-      (MODE_RESTRICTIVENESS[best.mode] ?? 0)
+      (MODE_RESTRICTIVENESS[getScopeGuardMode(scope)] ?? 0) >
+      (MODE_RESTRICTIVENESS[getScopeGuardMode(best)] ?? 0)
         ? scope
         : best,
     );
@@ -463,7 +480,9 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     const mode = deps.getDocumentMode();
     if (mode === "viewing" || mode === "commenting") return mode;
     const matchingScope = getMatchingWorkflowScope(selection);
-    if (matchingScope?.mode === "suggest") return "suggesting";
+    if (matchingScope && getScopeGuardMode(matchingScope) === "suggest") {
+      return "suggesting";
+    }
     return mode;
   }
 
@@ -536,17 +555,18 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     if (normalized) {
       const matchingScope = getMatchingWorkflowScope(selection);
       const activeScopes = getEffectiveWorkflowScopes(normalized);
-      const guardingScopes = activeScopes.filter(
-        (s) => !(s.visibility === "invisible" && s.mode !== "view"),
+      const insertOnlyScopes = activeScopes.filter(
+        (s) => resolveScopeGuardPolicy(s) === "insert-only",
       );
 
-      if (!matchingScope && guardingScopes.length > 0) {
+      if (!matchingScope && insertOnlyScopes.length > 0) {
         reasons.push({
           code: "outside_workflow_scope",
-          message: "Selection is outside any active workflow scope.",
+          message: "Selection is outside any active insert-only workflow scope.",
         });
       } else if (matchingScope) {
-        if (matchingScope.mode === "comment") {
+        const guardMode = getScopeGuardMode(matchingScope);
+        if (guardMode === "comment") {
           const isCommentCommand = commandType?.startsWith("comment.") ?? false;
           if (!isCommentCommand) {
             reasons.push({
@@ -556,7 +576,7 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
               workItemId: matchingScope.workItemId,
             });
           }
-        } else if (matchingScope.mode === "view") {
+        } else if (guardMode === "view") {
           reasons.push({
             code: "workflow_view_only",
             message: `Scope "${matchingScope.label ?? matchingScope.scopeId}" is view-only.`,
@@ -618,6 +638,9 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     const matchingScope = getMatchingWorkflowScope(state.selection);
     const scopeStack = buildMatchingScopeStack(state.selection);
     const primaryBlockedReason = blockedReasons[0];
+    const matchingGuardMode = matchingScope
+      ? getScopeGuardMode(matchingScope)
+      : undefined;
     const effectiveMode = primaryBlockedReason
       ? primaryBlockedReason.code === "workflow_comment_only"
         ? "comment"
@@ -626,19 +649,19 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
           : "blocked"
       : getEffectiveDocumentMode(state.selection) === "suggesting"
         ? "suggest"
-        : matchingScope?.mode ?? "edit";
+        : matchingGuardMode ?? "edit";
     const matchedScopeStack: InteractionGuardSnapshot["matchedScopeStack"] =
       scopeStack.length > 0
         ? scopeStack.map((s) => ({
             scopeId: s.scopeId,
-            mode: s.mode,
+            mode: getScopeGuardMode(s),
             visibility: s.visibility ?? "visible",
           }))
         : undefined;
     const snapshot: InteractionGuardSnapshot = {
       effectiveMode,
       ...(matchingScope?.scopeId ? { matchedScopeId: matchingScope.scopeId } : {}),
-      ...(matchingScope?.mode ? { matchedScopeMode: matchingScope.mode } : {}),
+      ...(matchingGuardMode ? { matchedScopeMode: matchingGuardMode } : {}),
       ...(matchedScopeStack ? { matchedScopeStack } : {}),
       targetAccess:
         effectiveMode === "edit"
@@ -888,6 +911,8 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
       anchor: publicAnchor,
       ...(params.storyTarget ? { storyTarget: params.storyTarget } : {}),
       ...(params.label ? { label: params.label } : {}),
+      ...(params.visibility ? { visibility: params.visibility } : {}),
+      ...(params.guardPolicy ? { guardPolicy: params.guardPolicy } : {}),
       ...(params.scopeMetadataFields && params.scopeMetadataFields.length > 0
         ? { metadata: [...params.scopeMetadataFields] }
         : {}),
@@ -1004,6 +1029,31 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     return scope?.visibility ?? "visible";
   }
 
+  function setScopeGuardPolicy(
+    scopeId: string,
+    guardPolicy: WorkflowScopeGuardPolicy,
+  ): void {
+    const overlay = overlayStore.getOverlay();
+    if (!overlay) return;
+    const idx = overlay.scopes.findIndex((s) => s.scopeId === scopeId);
+    if (idx === -1) return;
+    const nextScopes = overlay.scopes.map((s) =>
+      s.scopeId === scopeId ? { ...s, guardPolicy } : s,
+    );
+    deps.dispatch({
+      type: "workflow.set-overlay",
+      overlay: { ...overlay, scopes: nextScopes },
+      origin: { source: "api", at: clock() },
+    });
+  }
+
+  function getScopeGuardPolicy(scopeId: string): WorkflowScopeGuardPolicy {
+    const overlay = overlayStore.getOverlay();
+    if (!overlay) return "none";
+    const scope = overlay.scopes.find((s) => s.scopeId === scopeId);
+    return scope ? resolveScopeGuardPolicy(scope) : "none";
+  }
+
   function getScope(scopeId: string): WorkflowScope | null {
     const normalized = getNormalizedOverlay();
     const fromOverlay = normalized?.scopes.find((s) => s.scopeId === scopeId);
@@ -1360,6 +1410,8 @@ export function createWorkflowCoordinator(deps: CoordinatorDeps): WorkflowCoordi
     addInvisibleScope,
     setScopeVisibility,
     getScopeVisibility,
+    setScopeGuardPolicy,
+    getScopeGuardPolicy,
     getScope,
     getMarkerBackedScopeIds: () => overlayStore.getMarkerBackedScopeIds(),
     setScopeChromeVisibility,

package/src/runtime/workflow/scope-writer.ts

@@ -37,6 +37,8 @@ import type {
   EditorAnchorProjection,
   EditorStoryTarget,
   RuntimeRenderSnapshot,
+  ScopeVisibility,
+  WorkflowScopeGuardPolicy,
   WorkflowMetadataEntry,
   WorkflowMetadataPersistence,
   WorkflowScopeMetadataField,
@@ -62,6 +64,8 @@ export interface CreateScopeFromBlockIdInput {
   readonly persistence?: WorkflowMetadataPersistence;
   readonly metadata?: Partial<WorkflowMetadataEntry>;
   readonly storyTarget?: EditorStoryTarget;
+  readonly visibility?: ScopeVisibility;
+  readonly guardPolicy?: WorkflowScopeGuardPolicy;
   /**
    * Coord-06 §13d — per-scope edge stickiness for the range anchor.
    * Defaults to `{ start: 1, end: -1 }` (greedy — absorbs boundary
@@ -98,7 +102,23 @@ export interface CreateScopeFromBlockIdInput {
 
 export type CreateScopeFromBlockIdResult =
   | { readonly status: "created"; readonly scopeId: string; readonly anchor: EditorAnchorProjection }
-  | { readonly status: "block-not-found"; readonly blockId: string };
+  | { readonly status: "block-not-found"; readonly blockId: string }
+  | {
+      readonly status: "range-invalid";
+      readonly scopeId: "";
+      readonly reason:
+        | "range-exceeds-story-length"
+        | "non-paragraph-target"
+        | "empty-document";
+      readonly from: number;
+      readonly to: number;
+      readonly storyLength: number;
+      /** Non-paragraph target only — the offending block's index and kind. */
+      readonly blockIndex?: number;
+      readonly blockKind?: string;
+      readonly message: string;
+      readonly nextStep: string;
+    };
 
 function inlineLength(node: InlineNode): number {
   switch (node.type) {
@@ -190,8 +210,9 @@ export function createScopeFromBlockId(
   runtime: ScopeWriterRuntime,
   input: CreateScopeFromBlockIdInput,
 ): CreateScopeFromBlockIdResult {
+  const document = runtime.getCanonicalDocument();
   const anchor = resolveBlockAnchorFromCanonical(
-    runtime.getCanonicalDocument(),
+    document,
     input.blockId,
     input.assoc,
   );
@@ -216,10 +237,63 @@ export function createScopeFromBlockId(
     metadata: input.metadata,
     storyTarget: input.storyTarget,
     label: input.label,
+    ...(input.visibility ? { visibility: input.visibility } : {}),
+    ...(input.guardPolicy ? { guardPolicy: input.guardPolicy } : {}),
     ...(scopeMetadataFields.length > 0
       ? { scopeMetadataFields }
       : {}),
   });
+  if (result.plantStatus && result.plantStatus.planted === false) {
+    const ps = result.plantStatus;
+    const from = anchor.kind === "range" ? anchor.from : 0;
+    const to = anchor.kind === "range" ? anchor.to : from;
+    const storyLength = ps.storyLength ?? computeMainStoryLength(document);
+    if (ps.reason === "non-paragraph-target") {
+      return {
+        status: "range-invalid",
+        scopeId: "",
+        reason: "non-paragraph-target",
+        from,
+        to,
+        storyLength,
+        blockIndex: ps.blockIndex ?? -1,
+        blockKind: ps.blockKind ?? "unknown",
+        message:
+          `createScope refused blockId "${input.blockId}": it resolves to a ` +
+          `${ps.blockKind ?? "non-paragraph"} block (index ${ps.blockIndex}). ` +
+          `Marker-backed scopes only plant inside paragraphs today; choose a ` +
+          `paragraph block or create an overlay-only scope for table/SDT metadata.`,
+        nextStep: "pick-a-paragraph-block-or-use-overlay-only-scope",
+      };
+    }
+    if (ps.reason === "range-out-of-bounds") {
+      return {
+        status: "range-invalid",
+        scopeId: "",
+        reason: "range-exceeds-story-length",
+        from,
+        to,
+        storyLength,
+        message:
+          `createScope refused blockId "${input.blockId}": resolved range ` +
+          `[${from}, ${to}] exceeds the current story length (${storyLength}). ` +
+          `Re-query block ids from the current render snapshot before retrying.`,
+        nextStep: "re-query-current-block-id",
+      };
+    }
+    return {
+      status: "range-invalid",
+      scopeId: "",
+      reason: "empty-document",
+      from,
+      to,
+      storyLength,
+      message:
+        `createScope refused blockId "${input.blockId}": the target document ` +
+        `has no blocks, so scope markers cannot be planted.`,
+      nextStep: "initialize-document-before-creating-scopes",
+    };
+  }
   return { status: "created", scopeId: result.scopeId, anchor: result.anchor };
 }
 
@@ -251,6 +325,8 @@ export interface CreateScopeFromAnchorInput {
   readonly scopeId?: string;
   readonly persistence?: WorkflowMetadataPersistence;
   readonly metadata?: Partial<WorkflowMetadataEntry>;
+  readonly visibility?: ScopeVisibility;
+  readonly guardPolicy?: WorkflowScopeGuardPolicy;
   /**
    * Per-scope edge stickiness for the range anchor. Defaults to
    * `{ start: 1, end: -1 }` (greedy — absorbs boundary inserts). See
@@ -423,6 +499,8 @@ export function createScopeFromAnchor(
     metadata: input.metadata,
     storyTarget,
     label: input.label,
+    ...(input.visibility ? { visibility: input.visibility } : {}),
+    ...(input.guardPolicy ? { guardPolicy: input.guardPolicy } : {}),
     ...(scopeMetadataFields.length > 0 ? { scopeMetadataFields } : {}),
   });
 
@@ -448,9 +526,9 @@ export function createScopeFromAnchor(
         message:
           `createScopeFromAnchor refused: range [${from}, ${to}] targets a ` +
           `${ps.blockKind ?? "non-paragraph"} block (index ${ps.blockIndex}). ` +
-          `Marker scopes only plant inside paragraphs today. Pick a paragraph ` +
-          `target, or use runtime.workflow.createScope({blockId}) for ` +
-          `whole-block scopes on the containing structure.`,
+          `Marker-backed scopes only plant inside paragraphs today. Pick a ` +
+          `paragraph target, or create an overlay-only scope for table/SDT ` +
+          `metadata until structural marker support lands.`,
         nextStep: "pick-a-paragraph-target",
       };
     }

package/src/shell/session-bootstrap.ts

@@ -1289,6 +1289,8 @@ function createLoadingRuntimeBridge(input: {
     addInvisibleScope: () => ({ scopeId: "", anchor: { kind: "range", from: 0, to: 0, assoc: { start: -1, end: 1 } } }),
     setScopeVisibility: () => undefined,
     getScopeVisibility: () => "visible" as const,
+    setScopeGuardPolicy: () => undefined,
+    getScopeGuardPolicy: () => "none" as const,
     setScopeChromeVisibility: () => undefined,
     getScopeChromeVisibility: () => ({ mode: "all" as const }),
     subscribeToScopeQuery: (_filter, _callback) => () => undefined,