@beyondwork/docx-react-component 1.0.79 → 1.0.81

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@beyondwork/docx-react-component",
   "publisher": "beyondwork",
-  "version": "1.0.79",
+  "version": "1.0.81",
   "description": "Embeddable React Word (docx) editor with review, comments, tracked changes, and round-trip OOXML fidelity.",
   "type": "module",
   "sideEffects": [

package/src/api/public-types.ts

@@ -1211,6 +1211,18 @@ export type SurfaceInlineSegment =
        * is enforced by `test/runtime/formatting/production-boundary.test.ts`.
        */
       revisionDisplay?: {
+        /**
+         * Identity of the attached revision. Render consumers emit
+         * `data-revision-id` and route sidebar scroll-to-revision off
+         * this field rather than re-deriving from the review store.
+         */
+        revisionId: string;
+        /**
+         * The revision's kind. Mirrors `RevisionRecord.kind` on the
+         * canonical document. Render consumers branch on this (e.g.
+         * widget-bracket placement in suggestions mode).
+         */
+        kind: "insertion" | "deletion" | "formatting" | "move" | "property-change";
         markupMode: "clean" | "simple" | "all";
         hidden?: boolean;
         strikethrough?: boolean;
@@ -2517,23 +2529,20 @@ export interface AddScopeResult {
   /**
    * Structured diagnostic for the marker-plant attempt. Omitted on the
    * happy path for back-compat; populated with `planted: false` + a
-   * typed reason when the plant was refused (cross-paragraph range,
-   * non-paragraph target, out-of-bounds). Callers that previously
-   * assumed every returned `scopeId` was live should migrate to
-   * checking this field.
+   * typed reason when the plant was refused (non-paragraph target,
+   * out-of-bounds, empty-document). Cross-paragraph ranges plant
+   * successfully as of 2026-04-24 — see the multi-paragraph-scopes
+   * slice. Callers that previously assumed every returned `scopeId`
+   * was live should migrate to checking this field.
    */
   plantStatus?: {
     readonly planted: false;
     readonly reason:
-      | "cross-paragraph-range"
       | "non-paragraph-target"
       | "range-out-of-bounds"
       | "empty-document";
     readonly requestedFrom: number;
     readonly requestedTo: number;
-    /** Present on `cross-paragraph-range`. */
-    readonly fromBlockIndex?: number;
-    readonly toBlockIndex?: number;
     /** Present on `non-paragraph-target`. */
     readonly blockIndex?: number;
     readonly blockKind?: string;
@@ -5602,17 +5611,15 @@ export interface WordReviewEditorProps {
     import("../ui/headless/chrome-registry").SelectionToolRegistryEntry
   >;
   /**
-   * Phase C.γ host-callback bag. When supplied, the workspace mounts
-   * `TwWorkspaceChromeHost` which in turn mounts the right-click
-   * context menu (`TwContextMenuPortal`) and the Ctrl/Cmd+K command
-   * palette (`TwCommandPaletteMount`), dispatching through the shared
-   * `editorActionRegistry`. Actions without a wired callback are
-   * hidden from every surface — progressive disclosure per
-   * `designsystem.md §2.1 principle 4`.
-   *
-   * Omit to preserve pre-Phase-C behavior (no right-click menu, no
-   * palette). Required for the default editor to expose the
-   * Phase C.γ surfaces shipped in `5fce913a`.
+   * Optional host-callback extension bag for workspace command chrome.
+   * The default `<WordReviewEditor />` path now mounts
+   * `TwWorkspaceChromeHost` with product-backed commands for formatting,
+   * paragraph/list actions, comments, and table insertion/structure.
+   * Supplying this bag overrides or extends those defaults for host-owned
+   * actions such as custom table properties, hyperlink handling, or
+   * object metadata. Actions without a wired callback are hidden from
+   * every surface — progressive disclosure per `designsystem.md §2.1
+   * principle 4`.
    */
   editorActionHost?: import("../ui-tailwind/chrome/editor-action-registry").EditorActionHostCallbacks;
   /**
@@ -5628,8 +5635,8 @@ export interface WordReviewEditorProps {
   /**
    * Suppress the global Ctrl/Cmd+K palette listener — e.g. when a
    * higher-priority modal captures keyboard focus. Defaults to
-   * `false` (palette listener is active when `editorActionHost` is
-   * supplied).
+   * `false` (the default product command palette listener is active
+   * unless this prop suppresses it).
    */
   commandPaletteDisabled?: boolean;
   /**

package/src/api/v3/ai/resolve.ts

@@ -1,13 +1,19 @@
 /**
  * @endStateApi v3 — `ai.resolve` family.
  *
- * Slice 3 of refactor/08 graduates `resolveReference` to
- * `live-with-adapter` for the FOUR DETERMINISTIC hint kinds: `scope-id`,
- * `semantic-path`, `offset`, and `range`. Offset / range resolution now
- * honors precise nested-kind ranges (fields, table rows, table cells)
- * via the scope-compiler's specificity tie-breaker — see
- * `docs/architecture/08-semantic-scope-compiler.md` §"Resolve-reference
- * precision" for the specificity table.
+ * Slice 3 of refactor/08 graduated `resolveReference` to
+ * `live-with-adapter`. Post-KI-P9 (2026-04-24) the reference union
+ * carries **three durable reference kinds**: `scope-id`, `semantic-path`,
+ * and `natural-language`. Positional queries (`offset` / `range`) were
+ * split into `queryScopeAtPosition(at)` / `queryScopeInRange(from, to)`
+ * one-shot APIs that return `ScopeHandle | null` directly — the
+ * type-system split prevents a positional hint from being cached or
+ * round-tripped as a reference across a mutation.
+ *
+ * Offset / range lookups still honor precise nested-kind ranges (fields,
+ * table rows, table cells) via the scope-compiler's specificity
+ * tie-breaker — see `docs/architecture/08-semantic-scope-compiler.md`
+ * §"Resolve-reference precision" for the specificity table.
  *
  * The `natural-language` hint remains **partial by design**. The live
  * path is a deterministic substring matcher over:

package/src/api/v3/runtime/workflow.ts

@@ -161,14 +161,11 @@ export type CreateScopeFromAnchorResult =
         | "from-negative"
         | "to-less-than-from"
         | "range-exceeds-story-length"
-        | "cross-paragraph-range"
         | "non-paragraph-target"
         | "empty-document";
       readonly from: number;
       readonly to: number;
       readonly storyLength: number;
-      readonly fromBlockIndex?: number;
-      readonly toBlockIndex?: number;
       readonly blockIndex?: number;
       readonly blockKind?: string;
       /** Agent-actionable single-sentence explanation. Safe to surface to LLM tool replies as-is. */
@@ -540,12 +537,6 @@ export function createWorkflowFamily(runtime: RuntimeApiHandle) {
           from: adapterResult.from,
           to: adapterResult.to,
           storyLength: adapterResult.storyLength,
-          ...(adapterResult.fromBlockIndex !== undefined
-            ? { fromBlockIndex: adapterResult.fromBlockIndex }
-            : {}),
-          ...(adapterResult.toBlockIndex !== undefined
-            ? { toBlockIndex: adapterResult.toBlockIndex }
-            : {}),
           ...(adapterResult.blockIndex !== undefined
             ? { blockIndex: adapterResult.blockIndex }
             : {}),

package/src/api/v3/ui/chrome-composition.ts

@@ -131,6 +131,7 @@ export interface ChromeCompositionInput {
     | "simple"
     | "all";
   readonly activeRailTab?: EditorRailTab | null;
+  readonly railOpen?: boolean;
   readonly pinnedRailTabs?: ReadonlySet<EditorRailTab>;
   readonly density?: ChromeDensity;
   readonly containerWidth?: number;
@@ -255,13 +256,18 @@ function resolveVisibleRailTabs(
   railOpen: boolean,
   diagnosticsSignal: DiagnosticsSignal,
   pinned: ReadonlySet<EditorRailTab>,
+  mode: EditorChromeMode,
 ): ReadonlySet<EditorRailTab> {
   const visible = new Set<EditorRailTab>();
   if (railOpen) {
     visible.add("comments");
     visible.add("changes");
     visible.add("workflow");
-    if (diagnosticsSignal.severity !== "none" || diagnosticsSignal.count > 0) {
+    if (
+      diagnosticsSignal.severity !== "none" ||
+      diagnosticsSignal.count > 0 ||
+      mode === "more"
+    ) {
       visible.add("health");
     }
   }
@@ -294,11 +300,13 @@ export function resolveChromeComposition(
   const density: ChromeDensity = input.density ?? "standard";
   const pinnedRailTabs: ReadonlySet<EditorRailTab> =
     input.pinnedRailTabs ?? new Set<EditorRailTab>();
-  const railOpen = options.showReviewRail && visibility.reviewRail;
+  const railOpen =
+    input.railOpen ?? (options.showReviewRail && visibility.reviewRail);
   const visibleTabs = resolveVisibleRailTabs(
     railOpen,
     diagnosticsSignal,
     pinnedRailTabs,
+    mode,
   );
 
   // Default active tab: honor caller; otherwise land on the mode-appropriate tab.

package/src/core/commands/add-scope.ts

@@ -16,6 +16,10 @@ import type { CanonicalDocumentEnvelope } from "../state/editor-state.ts";
  * knowing whether the scope was ever live. Every non-`"planted"`
  * status is now typed so callers can discriminate + surface
  * agent-actionable recovery hints.
+ *
+ * Cross-paragraph ranges are first-class (planted) as of the
+ * 2026-04-24 multi-paragraph-scopes slice. The `cross-paragraph-range`
+ * failure variant no longer exists — markers now span paragraphs.
  */
 export type InsertScopeMarkersResult =
   | {
@@ -25,14 +29,6 @@ export type InsertScopeMarkersResult =
       /** Absolute span that got planted (after from/to normalization). */
       readonly plantedRange: { readonly from: number; readonly to: number };
     }
-  | {
-      readonly status: "cross-paragraph-range";
-      readonly scopeId: string;
-      readonly from: number;
-      readonly to: number;
-      readonly fromBlockIndex: number;
-      readonly toBlockIndex: number;
-    }
   | {
       readonly status: "non-paragraph-target";
       readonly scopeId: string;
@@ -60,13 +56,17 @@ export type InsertScopeMarkersResult =
  * pair of `scope_marker_start` / `scope_marker_end` inline nodes got
  * inserted at `[from, to]`.
  *
+ * Same-paragraph ranges insert both markers into the single owning
+ * paragraph. Cross-paragraph ranges place the start marker inside the
+ * paragraph containing `from` and the end marker inside the paragraph
+ * containing `to`; intermediate top-level blocks (paragraphs, tables,
+ * section breaks) are passed through unmodified and fall inside the
+ * scope by document order.
+ *
  * Failure modes (all previously silent — pre-2026-04-24):
- *   - `cross-paragraph-range` — `from` and `to` resolve to different
- *     top-level paragraph blocks. Multi-block marker scopes are not
- *     yet wired; narrow the range to land inside one paragraph.
- *   - `non-paragraph-target` — the target range lands inside a
+ *   - `non-paragraph-target` — either `from` or `to` lands inside a
  *     non-paragraph block (table / SDT / section_break). Marker
- *     scopes only plant inside paragraphs today.
+ *     scopes only plant inside paragraphs.
  *   - `range-out-of-bounds` — `to` exceeds the main story length.
  *   - `empty-document` — the document has no root / no children.
  *
@@ -82,10 +82,10 @@ export function insertScopeMarkers(
     to: number;
   },
 ): InsertScopeMarkersResult {
-  const { scopeId, from, to } = params;
+  const { scopeId } = params;
   const root = document.content as DocumentRootNode;
-  const normalizedFrom = Math.min(from, to);
-  const normalizedTo = Math.max(from, to);
+  const normalizedFrom = Math.min(params.from, params.to);
+  const normalizedTo = Math.max(params.from, params.to);
 
   if (!root || root.type !== "doc" || root.children.length === 0) {
     return {
@@ -96,9 +96,15 @@ export function insertScopeMarkers(
     };
   }
 
-  // First pass — locate which block each of `from` and `to` resolves to,
-  // so we can distinguish cross-paragraph / non-paragraph / out-of-bounds
-  // failures before attempting the plant.
+  // Pre-pass — locate which block each of `from` and `to` resolves to,
+  // compute story length, and build per-paragraph slot envelopes.
+  // **Invariant:** the cursor arithmetic here MUST match
+  // `src/runtime/scopes/position-map.ts::computeBlockPositions`
+  // (same `inlineLength`, same `+1` per-block boundary). Layer 04
+  // cannot change one walker without the other or cross-paragraph
+  // marker insertion silently drifts vs. enumerated scope ranges.
+  type ParaSlot = { index: number; from: number; to: number };
+  const paraSlots: ParaSlot[] = [];
   let cursor = 0;
   let fromBlockIndex = -1;
   let fromBlockKind: string | null = null;
@@ -115,15 +121,24 @@ export function insertScopeMarkers(
         (total, child) => total + inlineLength(child as InlineNode),
         0,
       );
+      paraSlots.push({ index: i, from: blockFrom, to: blockFrom + blockLength });
     } else {
       blockLength = 1;
     }
     const blockTo = blockFrom + blockLength;
-    if (fromBlockIndex === -1 && normalizedFrom >= blockFrom && normalizedFrom <= blockTo) {
+    if (
+      fromBlockIndex === -1 &&
+      normalizedFrom >= blockFrom &&
+      normalizedFrom <= blockTo
+    ) {
       fromBlockIndex = i;
       fromBlockKind = block.type;
     }
-    if (toBlockIndex === -1 && normalizedTo >= blockFrom && normalizedTo <= blockTo) {
+    if (
+      toBlockIndex === -1 &&
+      normalizedTo >= blockFrom &&
+      normalizedTo <= blockTo
+    ) {
       toBlockIndex = i;
       toBlockKind = block.type;
     }
@@ -150,62 +165,81 @@ export function insertScopeMarkers(
       storyLength,
     };
   }
-  if (fromBlockIndex !== toBlockIndex) {
+  if (fromBlockKind !== "paragraph" || toBlockKind !== "paragraph") {
+    // Either endpoint lands on a non-paragraph top-level block
+    // (table / section_break / sdt). Report the first non-paragraph
+    // offender for diagnostic clarity.
+    const nonParaIndex =
+      fromBlockKind !== "paragraph" ? fromBlockIndex : toBlockIndex;
+    const nonParaKind =
+      fromBlockKind !== "paragraph" ? fromBlockKind : toBlockKind;
     return {
-      status: "cross-paragraph-range",
+      status: "non-paragraph-target",
       scopeId,
       from: normalizedFrom,
       to: normalizedTo,
-      fromBlockIndex,
-      toBlockIndex,
+      blockIndex: nonParaIndex,
+      blockKind: nonParaKind ?? "unknown",
     };
   }
-  if (fromBlockKind !== "paragraph") {
+
+  const startSlot = paraSlots.find((s) => s.index === fromBlockIndex)!;
+  const endSlot = paraSlots.find((s) => s.index === toBlockIndex)!;
+
+  // Same-paragraph fast path: inject both markers into one paragraph.
+  // Preserves all existing single-paragraph behaviour byte-for-byte
+  // (regression pin [C9]).
+  if (startSlot.index === endSlot.index) {
+    const newChildren = injectMarkersIntoInlineList(
+      (root.children[startSlot.index] as ParagraphNode).children as InlineNode[],
+      scopeId,
+      normalizedFrom - startSlot.from,
+      normalizedTo - startSlot.from,
+      "both",
+    );
+    const children = root.children.map((block, i) =>
+      i === startSlot.index
+        ? ({ ...block, children: newChildren } as ParagraphNode)
+        : block,
+    );
     return {
-      status: "non-paragraph-target",
+      status: "planted",
+      document: { ...document, content: { ...root, children } },
       scopeId,
-      from: normalizedFrom,
-      to: normalizedTo,
-      blockIndex: fromBlockIndex,
-      blockKind: fromBlockKind ?? "unknown",
+      plantedRange: { from: normalizedFrom, to: normalizedTo },
     };
   }
 
-  // Plant — we've validated the range lands inside a single paragraph.
-  cursor = 0;
-  const children = root.children.map((block, blockIndex) => {
-    if (blockIndex !== fromBlockIndex) {
-      if (block.type === "paragraph") {
-        const len = block.children.reduce(
-          (total, child) => total + inlineLength(child as InlineNode),
-          0,
-        );
-        cursor += len;
-      } else {
-        cursor += 1;
-      }
-      if (blockIndex < root.children.length - 1) cursor += 1;
-      return block;
+  // Cross-paragraph path — start marker goes in the start-bearing
+  // paragraph; end marker goes in the end-bearing paragraph;
+  // intermediate blocks pass through unchanged.
+  const children = root.children.map((block, i) => {
+    if (i === startSlot.index) {
+      const newChildren = injectMarkersIntoInlineList(
+        (block as ParagraphNode).children as InlineNode[],
+        scopeId,
+        normalizedFrom - startSlot.from,
+        Number.POSITIVE_INFINITY,
+        "start-only",
+      );
+      return { ...block, children: newChildren } as ParagraphNode;
     }
-    const paragraphFrom = cursor;
-    const paragraph = block as ParagraphNode;
-    const startOffset = normalizedFrom - paragraphFrom;
-    const endOffset = normalizedTo - paragraphFrom;
-    const newChildren = injectMarkersIntoInlineList(
-      paragraph.children as InlineNode[],
-      scopeId,
-      startOffset,
-      endOffset,
-    );
-    return { ...paragraph, children: newChildren };
+    if (i === endSlot.index) {
+      const newChildren = injectMarkersIntoInlineList(
+        (block as ParagraphNode).children as InlineNode[],
+        scopeId,
+        Number.NEGATIVE_INFINITY,
+        normalizedTo - endSlot.from,
+        "end-only",
+      );
+      return { ...block, children: newChildren } as ParagraphNode;
+    }
+    return block;
   });
 
   return {
     status: "planted",
-    document: {
-      ...document,
-      content: { ...root, children },
-    },
+    document: { ...document, content: { ...root, children } },
     scopeId,
     plantedRange: { from: normalizedFrom, to: normalizedTo },
   };
@@ -273,28 +307,28 @@ function injectMarkersIntoInlineList(
   scopeId: string,
   startOffset: number,
   endOffset: number,
+  mode: "both" | "start-only" | "end-only",
 ): InlineNode[] {
-  const start: ScopeMarkerStartNode = {
-    type: "scope_marker_start",
-    scopeId,
-  };
-  const end: ScopeMarkerEndNode = {
-    type: "scope_marker_end",
-    scopeId,
-  };
+  const start: ScopeMarkerStartNode = { type: "scope_marker_start", scopeId };
+  const end: ScopeMarkerEndNode = { type: "scope_marker_end", scopeId };
+
+  const needStart = mode === "both" || mode === "start-only";
+  const needEnd = mode === "both" || mode === "end-only";
 
   const output: InlineNode[] = [];
   let cursor = 0;
-  let startEmitted = false;
-  let endEmitted = false;
+  let startEmitted = !needStart;
+  let endEmitted = !needEnd;
 
   for (const node of inlines) {
     const length = inlineLength(node);
     const nodeStart = cursor;
     const nodeEnd = cursor + length;
 
-    const startInside = !startEmitted && startOffset >= nodeStart && startOffset <= nodeEnd;
-    const endInside = !endEmitted && endOffset >= nodeStart && endOffset <= nodeEnd;
+    const startInside =
+      needStart && !startEmitted && startOffset >= nodeStart && startOffset <= nodeEnd;
+    const endInside =
+      needEnd && !endEmitted && endOffset >= nodeStart && endOffset <= nodeEnd;
 
     if (!startInside && !endInside) {
       output.push(node);
@@ -302,10 +336,7 @@ function injectMarkersIntoInlineList(
       continue;
     }
 
-    // Currently only text nodes support splitting for an internal cut.
     if (node.type !== "text") {
-      // For non-text nodes, markers land at the node boundary closest to the
-      // target offset — avoids mid-atom splits which would corrupt the node.
       if (startInside && !startEmitted && startOffset <= nodeStart) {
         output.push(start);
         startEmitted = true;
@@ -330,11 +361,7 @@ function injectMarkersIntoInlineList(
     const text = node.text;
     const chars = Array.from(text);
     const marks = node.marks;
-    const pieces: {
-      cut: number;
-      emit: "start" | "end";
-    }[] = [];
-
+    const pieces: { cut: number; emit: "start" | "end" }[] = [];
     if (startInside) pieces.push({ cut: startOffset - nodeStart, emit: "start" });
     if (endInside) pieces.push({ cut: endOffset - nodeStart, emit: "end" });
     pieces.sort((a, b) => a.cut - b.cut || (a.emit === "start" ? -1 : 1));
@@ -370,12 +397,11 @@ function injectMarkersIntoInlineList(
     cursor = nodeEnd;
   }
 
-  // Append markers that were at the very end of the paragraph.
-  if (!startEmitted) {
+  if (needStart && !startEmitted) {
     output.push(start);
     startEmitted = true;
   }
-  if (!endEmitted) {
+  if (needEnd && !endEmitted) {
     output.push(end);
     endEmitted = true;
   }

package/src/runtime/formatting/formatting-types.ts

@@ -110,6 +110,22 @@ export interface EffectiveFieldDisplay {
  * visual vocabulary (CSS class, inline style, decoration).
  */
 export interface RevisionDisplayFlags {
+  /**
+   * The attached revision's id. Enables render consumers to emit
+   * `data-revision-id` + route sidebar scroll-to-revision off the
+   * authoritative L03 flags rather than re-deriving from the review-store
+   * side channel. Present whenever `input.revision !== undefined` drove
+   * flag emission.
+   */
+  readonly revisionId: string;
+  /**
+   * The revision's kind. Mirrors `RevisionRecord.kind` from the canonical
+   * document (`src/model/canonical-document.ts`). Render consumers use
+   * this to branch on insertion/deletion/move/property-change variants
+   * (e.g. widget-bracket placement in suggestions mode) without reading
+   * the review store.
+   */
+  readonly kind: "insertion" | "deletion" | "formatting" | "move" | "property-change";
   readonly markupMode: "clean" | "simple" | "all";
   /** Hide the run entirely (e.g. open deletion in "clean" mode). */
   readonly hidden?: boolean;

package/src/runtime/formatting/revision-display.ts

@@ -44,16 +44,16 @@ export function applyRevisionDisplay(
   switch (markupMode) {
     case "clean": {
       if (revision.kind === "deletion" && revision.status === "open") {
-        return buildFlags(markupMode, authorColor, { hidden: true });
+        return buildFlags(revision, markupMode, authorColor, { hidden: true });
       }
-      return buildFlags(markupMode, authorColor);
+      return buildFlags(revision, markupMode, authorColor);
     }
 
     case "simple": {
       // Content visible, de-emphasized. No strikethrough / underline
       // markers — the consumer renders a muted style (opacity /
       // secondary color) uniformly.
-      return buildFlags(markupMode, authorColor, { deemphasize: true });
+      return buildFlags(revision, markupMode, authorColor, { deemphasize: true });
     }
 
     case "all": {
@@ -65,18 +65,18 @@ export function applyRevisionDisplay(
           // add the revision strikethrough flag — avoids double-struck
           // glyphs in render.
           if (run.strikethrough === true) {
-            return buildFlags(markupMode, authorColor);
+            return buildFlags(revision, markupMode, authorColor);
           }
-          return buildFlags(markupMode, authorColor, { strikethrough: true });
+          return buildFlags(revision, markupMode, authorColor, { strikethrough: true });
         }
         case "insertion": {
           // Mirror short-circuit for insertions. If the run already carries
           // a single-underline via direct formatting, skip the insertion
           // underline so the render doesn't over-paint.
           if (run.underline === "single") {
-            return buildFlags(markupMode, authorColor);
+            return buildFlags(revision, markupMode, authorColor);
           }
-          return buildFlags(markupMode, authorColor, { insertionUnderline: true });
+          return buildFlags(revision, markupMode, authorColor, { insertionUnderline: true });
         }
         case "formatting":
         case "property-change":
@@ -84,20 +84,26 @@ export function applyRevisionDisplay(
           // Paragraph-level markers (change-bar, move-from/to arrows) are
           // owned by the paragraph projection. For runs that carry these
           // revision kinds, fall through to the author-color-only posture.
-          return buildFlags(markupMode, authorColor);
+          return buildFlags(revision, markupMode, authorColor);
         }
       }
-      return buildFlags(markupMode, authorColor);
+      return buildFlags(revision, markupMode, authorColor);
     }
   }
 }
 
 function buildFlags(
+  revision: RevisionRecord,
   markupMode: RevisionMarkupMode,
   authorColor: string | undefined,
-  extras: Omit<RevisionDisplayFlags, "markupMode" | "authorColor"> = {},
+  extras: Omit<
+    RevisionDisplayFlags,
+    "revisionId" | "kind" | "markupMode" | "authorColor"
+  > = {},
 ): RevisionDisplayFlags {
   return {
+    revisionId: revision.changeId,
+    kind: revision.kind,
     markupMode,
     ...(authorColor !== undefined ? { authorColor } : {}),
     ...extras,

package/src/runtime/scopes/compile-scope-bundle.ts

@@ -18,7 +18,11 @@ import type {
   WorkflowOverlay,
 } from "./_scope-dependencies.ts";
 
-import { buildParagraphIndexMap, compileScope } from "./compile-scope.ts";
+import {
+  buildParagraphIndexMap,
+  buildSectionIndexByBlockIndex,
+  compileScope,
+} from "./compile-scope.ts";
 import type { EnumeratedScope } from "./enumerate-scopes.ts";
 import { enumerateScopes } from "./enumerate-scopes.ts";
 import { composeEvidence } from "./evidence.ts";
@@ -157,6 +161,10 @@ export function compileScopeBundleById(
     ...(fullDoc ? { document: fullDoc } : {}),
     ...(inputs.overlay !== undefined ? { overlay: inputs.overlay } : {}),
     paragraphIndexByBlockIndex: buildParagraphIndexMap(inputs.document),
+    // Thread the section-index map up-front so the `kind: "scope"` compile
+    // arm does not re-walk the document. Shared between dispatch + the
+    // `paragraph`/`heading`/`list-item` + `scope` kinds that read it.
+    sectionIndexByBlockIndex: buildSectionIndexByBlockIndex(inputs.document),
   });
   if (!compiled) return null;
   return compileScopeBundle(compiled, { ...inputs, scopes });

package/src/runtime/scopes/compile-scope.ts

@@ -61,6 +61,7 @@ import { compileHeadingScope } from "./scope-kinds/heading.ts";
 import { compileListItemScope } from "./scope-kinds/list-item.ts";
 import { compileParagraphScope } from "./scope-kinds/paragraph.ts";
 import { compileRevisionScope } from "./scope-kinds/revision.ts";
+import { compileScopeKind } from "./scope-kinds/scope.ts";
 import { compileTableScope } from "./scope-kinds/table.ts";
 import { compileTableCellScope } from "./scope-kinds/table-cell.ts";
 import { compileTableRowScope } from "./scope-kinds/table-row.ts";
@@ -256,6 +257,21 @@ export function compileScope(
       return compileCommentThreadScope(entry);
     case "revision":
       return compileRevisionScope(entry);
+    case "scope": {
+      if (!options.document) return null;
+      let scopeSectionMap = options.sectionIndexByBlockIndex;
+      if (!scopeSectionMap) {
+        scopeSectionMap = buildSectionIndexByBlockIndex(options.document);
+      }
+      const scopeSectionIndex = scopeSectionMap.get(entry.startBlockIndex);
+      return compileScopeKind(entry, {
+        document: options.document,
+        ...(workflow ? { workflow } : {}),
+        ...(typeof scopeSectionIndex === "number"
+          ? { sectionIndex: scopeSectionIndex }
+          : {}),
+      });
+    }
     default:
       return null;
   }