@beyondwork/docx-react-component 1.0.72 → 1.0.74

package/src/runtime/scopes/scope-kinds/paragraph.ts

@@ -12,10 +12,13 @@
  * compiler-backed.
  */
 
-import type { CanonicalDocument } from "../../../model/canonical-document.ts";
+import type {
+  CanonicalDocument,
+  InlineNode,
+} from "../../../model/canonical-document.ts";
 import { resolveEffectiveFormattingForScope } from "../_formatting-seam.ts";
 import type { ParagraphLikeEnumeratedScope } from "../enumerate-scopes.ts";
-import { computeBlockPositions } from "../position-map.ts";
+import { buildScopePositionMap, computeBlockPositions } from "../position-map.ts";
 import { deriveReplaceability } from "../replaceability.ts";
 import {
   isStructuredReplacementContent,
@@ -32,6 +35,99 @@ import {
   extractParagraphText,
 } from "./_paragraph-text.ts";
 
+function inlineLengthLocal(node: InlineNode): number {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "hyperlink":
+    case "field":
+      return (node.children as readonly InlineNode[]).reduce(
+        (total, child) => total + inlineLengthLocal(child),
+        0,
+      );
+    case "bookmark_start":
+    case "bookmark_end":
+    case "scope_marker_start":
+    case "scope_marker_end":
+      return 0;
+    default:
+      return 1;
+  }
+}
+
+/**
+ * Opt-in preservation helper: walk a paragraph's inline children,
+ * return the longest contiguous text-only run's [from, to] sub-range
+ * within the caller's `target` range. Opaque inlines / images / other
+ * non-text inlines break the run. Returns `null` when no text-only run
+ * exists inside the target range (paragraph is entirely opaques or the
+ * range falls on a non-text inline).
+ *
+ * Used by coord-08 §17 — `ReplacementPreservePolicy.opaqueFragments =
+ * true` narrows the replace range to this text-only sub-range so the
+ * opaque inlines survive the apply.
+ */
+function longestTextOnlyRangeInParagraph(
+  paragraph: ParagraphLikeEnumeratedScope["paragraph"],
+  paragraphFrom: number,
+  target: { readonly from: number; readonly to: number },
+): { readonly from: number; readonly to: number } | null {
+  let best: { readonly from: number; readonly to: number } | null = null;
+  let runStart: number | null = null;
+  let cursor = paragraphFrom;
+
+  const consider = (from: number, to: number) => {
+    // Clip to the caller's target range.
+    const clippedFrom = Math.max(from, target.from);
+    const clippedTo = Math.min(to, target.to);
+    if (clippedTo <= clippedFrom) return;
+    if (!best || clippedTo - clippedFrom > best.to - best.from) {
+      best = { from: clippedFrom, to: clippedTo };
+    }
+  };
+
+  const isTextRun = (child: InlineNode): boolean => {
+    if (child.type === "text" || child.type === "tab" || child.type === "hard_break") {
+      // tab + hard_break carry length 1 and are safe to text-replace
+      // (the runtime's text.insert handles them structurally). Treat
+      // as part of the text run.
+      return true;
+    }
+    if (child.type === "hyperlink" || child.type === "field") {
+      // Hyperlink / field wrappers contribute their text-only children
+      // to the run; they're not themselves opaque.
+      return true;
+    }
+    if (
+      child.type === "bookmark_start" ||
+      child.type === "bookmark_end" ||
+      child.type === "scope_marker_start" ||
+      child.type === "scope_marker_end"
+    ) {
+      // Zero-width boundary markers — preserve via length 0. Don't
+      // break the text run.
+      return true;
+    }
+    return false;
+  };
+
+  for (const child of paragraph.children) {
+    const len = inlineLengthLocal(child);
+    const childFrom = cursor;
+    const childTo = cursor + len;
+    if (isTextRun(child)) {
+      if (runStart === null) runStart = childFrom;
+    } else {
+      // Opaque / image / non-text inline breaks the run.
+      if (runStart !== null) consider(runStart, childFrom);
+      runStart = null;
+    }
+    cursor = childTo;
+  }
+  if (runStart !== null) consider(runStart, cursor);
+  return best;
+}
+
 export interface CompileParagraphOptions {
   readonly document?: CanonicalDocument;
   readonly paragraphIndex?: number;
@@ -125,10 +221,71 @@ export function compileParagraphReplacement(
   const blockRange = blocks.find((b) => b.blockIndex === entry.blockIndex);
   if (!blockRange) return null;
 
+  // Inline-range correction (2026-04-24 bug fix): when the scope is
+  // marker-backed AND the marker pair sits strictly INSIDE the
+  // paragraph (marker range is narrower than the paragraph's full
+  // block range), the replace range must follow the markers — not
+  // the paragraph. Otherwise surrounding text in the same paragraph
+  // gets destroyed on every applyReplacementScope call. The markers'
+  // positions are already tracked in `buildScopePositionMap().
+  // markerScopes`; we consult it here only when the scope is marker-
+  // backed so non-marker paragraphs pay zero cost.
+  let effectiveRange: { readonly from: number; readonly to: number } = {
+    from: blockRange.from,
+    to: blockRange.to,
+  };
+  let rangeKind: "block" | "inline-marker" | "opaque-preserving-text" = "block";
+  if (entry.handle.provenance === "marker-backed") {
+    const positionMap = buildScopePositionMap(options.document);
+    const markerRange = positionMap.markerScopes.get(entry.handle.scopeId);
+    if (
+      markerRange &&
+      markerRange.from >= blockRange.from &&
+      markerRange.to <= blockRange.to &&
+      // Strictly narrower than the paragraph — only then is the marker
+      // a sub-paragraph inline range. Whole-paragraph marker scopes
+      // (markers wrapping all of the paragraph's text) continue to use
+      // the block range, preserving the existing replace-whole-paragraph
+      // semantics.
+      (markerRange.from > blockRange.from || markerRange.to < blockRange.to)
+    ) {
+      effectiveRange = markerRange;
+      rangeKind = "inline-marker";
+    }
+  }
+
+  // Coord-08 §17 (2026-04-24) — opt-in opaque preservation. When the
+  // caller sets `preserve.opaqueFragments === true`, narrow the
+  // replace range to the longest contiguous text-only sub-range so
+  // opaque inlines (images, charts, preserve-only fragments) survive
+  // the apply at their original positions.
+  if (proposed.preserve?.opaqueFragments === true) {
+    const textOnly = longestTextOnlyRangeInParagraph(
+      entry.paragraph,
+      blockRange.from,
+      effectiveRange,
+    );
+    if (!textOnly) {
+      // Paragraph is entirely opaques within the target range — no
+      // text-only sub-range to replace. Refuse cleanly; the composer's
+      // `preserve:opaque-fragment:*` warning already signalled the
+      // opt-in intent.
+      return null;
+    }
+    effectiveRange = textOnly;
+    rangeKind = "opaque-preserving-text";
+  }
+
   if (proposed.proposedContent.kind === "text") {
     const text = proposed.proposedContent.text ?? "";
     const stepKind =
       options.posture === "suggest-mode" ? "text-insert-tracked" : "text-replace";
+    const summaryScope =
+      rangeKind === "inline-marker"
+        ? `paragraph #${entry.blockIndex} inline-marker range [${effectiveRange.from}..${effectiveRange.to}]`
+        : rangeKind === "opaque-preserving-text"
+          ? `paragraph #${entry.blockIndex} opaque-preserving text range [${effectiveRange.from}..${effectiveRange.to}]`
+          : `paragraph #${entry.blockIndex}`;
     return {
       scopeId: entry.handle.scopeId,
       targetKind: "paragraph",
@@ -138,9 +295,9 @@ export function compileParagraphReplacement(
           kind: stepKind,
           summary:
             stepKind === "text-replace"
-              ? `replace paragraph #${entry.blockIndex} text (len ${text.length})`
-              : `suggest-mode paragraph #${entry.blockIndex} text replace (len ${text.length})`,
-          range: { from: blockRange.from, to: blockRange.to },
+              ? `replace ${summaryScope} text (len ${text.length})`
+              : `suggest-mode ${summaryScope} text replace (len ${text.length})`,
+          range: { from: effectiveRange.from, to: effectiveRange.to },
           text,
         },
       ]),
@@ -161,6 +318,12 @@ export function compileParagraphReplacement(
     const fragment = proposed.proposedContent.structured;
     if (!isStructuredReplacementContent(fragment)) return null;
     const blockCount = fragment.blocks.length;
+    const summaryScope =
+      rangeKind === "inline-marker"
+        ? `paragraph #${entry.blockIndex} inline-marker range [${effectiveRange.from}..${effectiveRange.to}]`
+        : rangeKind === "opaque-preserving-text"
+          ? `paragraph #${entry.blockIndex} opaque-preserving text range [${effectiveRange.from}..${effectiveRange.to}]`
+          : `paragraph #${entry.blockIndex}`;
     return {
       scopeId: entry.handle.scopeId,
       targetKind: "paragraph",
@@ -168,8 +331,8 @@ export function compileParagraphReplacement(
       steps: Object.freeze([
         {
           kind: "fragment-replace",
-          summary: `replace paragraph #${entry.blockIndex} with structured fragment (${blockCount} block(s))`,
-          range: { from: blockRange.from, to: blockRange.to },
+          summary: `replace ${summaryScope} with structured fragment (${blockCount} block(s))`,
+          range: { from: effectiveRange.from, to: effectiveRange.to },
           fragment,
         },
       ]),

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

@@ -39,7 +39,7 @@ import type {
 function anchorToRange(anchor: CanonicalAnchor): ScopePositionRange | null {
   switch (anchor.kind) {
     case "range":
-      return { from: anchor.range.from, to: anchor.range.to };
+      return { from: anchor.from, to: anchor.to };
     case "node":
       return { from: anchor.at, to: anchor.at };
     case "detached":

package/src/runtime/scopes/semantic-scope-types.ts

@@ -296,6 +296,25 @@ export interface ReplacementPreservePolicy {
   readonly comments?: boolean;
   readonly revisions?: boolean;
   readonly bookmarks?: boolean;
+  /**
+   * Opt-in (2026-04-24): allow the replace to proceed when the target
+   * range contains opaque fragments (inline images, charts, or other
+   * `preserve-only` payload) that the runtime cannot safely
+   * re-serialize. When `true`:
+   *
+   *   - `computePreservationVerdict` downgrades
+   *     `preserve:opaque-fragment:*` reasons from blockers to warnings
+   *     (still surfaced on `validation.warnings` + audit-bundle).
+   *   - `compileParagraphReplacement` narrows the replace range to the
+   *     longest contiguous text-only sub-range, leaving opaques at
+   *     their original inline offsets. If no text sub-range exists
+   *     (paragraph is entirely opaques), compile still refuses.
+   *
+   * Default (absent / `false`) preserves the pre-opt-in refusal
+   * semantics. Callers that don't set this flag are protected from
+   * accidental opaque-fragment loss.
+   */
+  readonly opaqueFragments?: boolean;
 }
 
 export interface ReplacementScope {

package/src/runtime/selection/post-edit-validator.ts

@@ -64,8 +64,7 @@ export function validateSelectionAgainstDocument(
         head: collapsed,
         isCollapsed: true,
         activeRange: {
-          kind: "range",
-          range: { from: collapsed, to: collapsed },
+          kind: "range", from: collapsed, to: collapsed,
           assoc: {
             start: selection.activeRange.assoc,
             end: selection.activeRange.assoc,
@@ -84,7 +83,8 @@ export function validateSelectionAgainstDocument(
     return selection;
   }
 
-  const range = { from: Math.min(anchor, head), to: Math.max(anchor, head) };
+  const from = Math.min(anchor, head);
+  const to = Math.max(anchor, head);
   const assoc =
     selection.activeRange.kind === "range"
       ? selection.activeRange.assoc
@@ -94,7 +94,7 @@ export function validateSelectionAgainstDocument(
     anchor,
     head,
     isCollapsed: anchor === head,
-    activeRange: { kind: "range", range, assoc },
+    activeRange: { kind: "range", from, to, assoc },
   };
 }
 

package/src/runtime/surface-projection.ts

@@ -95,6 +95,20 @@ interface ParagraphAccumulator {
 }
 
 export interface SurfaceProjectionOptions {
+  /**
+   * Block-index intervals to render as real (non-placeholder). Blocks whose
+   * index falls in ANY interval are built as real `SurfaceBlockSnapshot`s;
+   * all others become size-preserving `placeholder-culled` opaque blocks.
+   *
+   * The canonical shape is an array of non-overlapping intervals (typically
+   * one for the visible viewport + overscan, and — when the caret is scrolled
+   * off-screen — a second one covering the caret's page so the selection
+   * block stays real without realizing the document-scale gap between the
+   * two). Callers still supplying the legacy scalar `viewportBlockRange` get
+   * wrapped into a single-element array internally.
+   */
+  viewportBlockRanges?: readonly { start: number; end: number }[] | null;
+  /** @deprecated use `viewportBlockRanges`. Kept for back-compat; wrapped into a 1-element array when supplied alone. */
   viewportBlockRange?: { start: number; end: number } | null;
   /**
    * Active markup mode. When set together with the document's
@@ -146,7 +160,13 @@ export function createEditorSurfaceSnapshot(
   activeStory: EditorStoryTarget = { kind: "main" },
   options: SurfaceProjectionOptions = {},
 ): EditorSurfaceSnapshot {
-  const viewportBlockRange = options.viewportBlockRange ?? null;
+  const viewportBlockRanges: readonly { start: number; end: number }[] | null = (() => {
+    if (options.viewportBlockRanges != null) {
+      return options.viewportBlockRanges.length === 0 ? null : options.viewportBlockRanges;
+    }
+    if (options.viewportBlockRange != null) return [options.viewportBlockRange];
+    return null;
+  })();
   const root = normalizeDocumentRoot({
     type: "doc",
     children: [...getStoryBlocks(document, activeStory)],
@@ -199,8 +219,8 @@ export function createEditorSurfaceSnapshot(
 
   for (let index = 0; index < root.children.length; index += 1) {
     const isInViewport =
-      viewportBlockRange === null ||
-      (index >= viewportBlockRange.start && index < viewportBlockRange.end);
+      viewportBlockRanges === null ||
+      isIndexInAnyRange(index, viewportBlockRanges);
     // L7 Phase 2.9 — viewport bail on the style-cascade work. When the
     // block is outside the viewport, the surface block produced below is
     // immediately discarded in favor of a `placeholder-culled` entry (we
@@ -293,10 +313,25 @@ export function createEditorSurfaceSnapshot(
     blocks,
     lockedFragmentIds,
     secondaryStories,
-    viewportBlockRange,
+    viewportBlockRanges,
   };
 }
 
+/**
+ * True when `index` falls in any of the given half-open intervals. Linear
+ * scan because the typical caller passes 1 or 2 ranges; switching to binary
+ * search has no measurable payoff below ~8 ranges.
+ */
+function isIndexInAnyRange(
+  index: number,
+  ranges: readonly { start: number; end: number }[],
+): boolean {
+  for (const r of ranges) {
+    if (index >= r.start && index < r.end) return true;
+  }
+  return false;
+}
+
 function createSurfaceBlock(
   block: BlockNode,
   document: CanonicalDocumentEnvelope,
@@ -796,6 +831,58 @@ function resolveSurfaceParagraphShading(
   };
 }
 
+/**
+ * Strip the verbatim-OOXML `rawXml` round-trip field from
+ * `FrameProperties` before forwarding to the public surface. Consumers
+ * (L04 paginated-layout placement, L11 render) read the modeled
+ * positioning + size fields; `rawXml` exists only so the serializer can
+ * merge extension attributes (`w14:*`, `w15:*`, `mc:Ignorable`) back
+ * onto the element on export.
+ */
+function toSurfaceFrameProperties(
+  frame: NonNullable<CanonicalParagraphFormatting["frameProperties"]>,
+): NonNullable<
+  Extract<
+    import("../api/public-types.ts").SurfaceBlockSnapshot,
+    { kind: "paragraph" }
+  >["frameProperties"]
+> {
+  const {
+    widthTwips,
+    heightTwips,
+    hRule,
+    xTwips,
+    yTwips,
+    xAlign,
+    yAlign,
+    hAnchor,
+    vAnchor,
+    wrap,
+    hSpaceTwips,
+    vSpaceTwips,
+    dropCap,
+    lines,
+    anchorLock,
+  } = frame;
+  return {
+    ...(widthTwips !== undefined ? { widthTwips } : {}),
+    ...(heightTwips !== undefined ? { heightTwips } : {}),
+    ...(hRule !== undefined ? { hRule } : {}),
+    ...(xTwips !== undefined ? { xTwips } : {}),
+    ...(yTwips !== undefined ? { yTwips } : {}),
+    ...(xAlign !== undefined ? { xAlign } : {}),
+    ...(yAlign !== undefined ? { yAlign } : {}),
+    ...(hAnchor !== undefined ? { hAnchor } : {}),
+    ...(vAnchor !== undefined ? { vAnchor } : {}),
+    ...(wrap !== undefined ? { wrap } : {}),
+    ...(hSpaceTwips !== undefined ? { hSpaceTwips } : {}),
+    ...(vSpaceTwips !== undefined ? { vSpaceTwips } : {}),
+    ...(dropCap !== undefined ? { dropCap } : {}),
+    ...(lines !== undefined ? { lines } : {}),
+    ...(anchorLock !== undefined ? { anchorLock } : {}),
+  };
+}
+
 function resolveSurfaceParagraphFormatting(
   formatting: CanonicalParagraphFormatting,
   themeResolver: ThemeColorResolver | undefined,
@@ -1066,6 +1153,9 @@ function createParagraphBlock(
       : {}),
     ...(paragraph.indentation ? { indentation: paragraph.indentation } : {}),
     ...(paragraph.borders ? { borders: paragraph.borders } : {}),
+    ...(paragraph.frameProperties
+      ? { frameProperties: toSurfaceFrameProperties(paragraph.frameProperties) }
+      : {}),
     ...(paragraph.shading
       ? { shading: resolveSurfaceParagraphShading(paragraph.shading, themeResolver) }
       : {}),

package/src/session/import/loader-types.ts

@@ -119,6 +119,24 @@ export interface LoadDocxEditorSessionOptions {
    * FRESH offload on first-open.
    */
   offloadEmbeddedDocuments?: boolean;
+  /**
+   * Phase 1 cosmetic-marker strip. When `true` (the default), the
+   * OOXML parser drops `<w:lastRenderedPageBreak/>`, `<w:proofErr/>`,
+   * and `<w:noBreakHyphen/>` during the body walk instead of emitting
+   * them as `opaque_inline` nodes. Aggregate counts are surfaced as
+   * a single `diagnostic:parser.skipped-cosmetic-markers` warning on
+   * the returned canonical document.
+   *
+   * These markers carry no contract semantics (Word regenerates them
+   * on reopen) and are structural boundaries that today cause
+   * `replaceText` to refuse ranges that happen to cross them. See
+   * `docs/architecture/cosmetic-marker-strip.md`.
+   *
+   * Set to `false` to preserve pre-strip behavior exactly — useful for
+   * byte-preservation tests and diagnostic scripts that need to
+   * inspect every marker.
+   */
+  stripCosmeticMarkers?: boolean;
 }
 
 /**

package/src/session/import/loader.ts

@@ -540,6 +540,7 @@ export async function loadDocxSessionAsync(
         mediaParts,
         mainDocumentPath,
         chartPartLookup,
+        { stripCosmeticMarkers: options.stripCosmeticMarkers !== false },
       );
     } finally {
       if (options.telemetryBus) setActiveParseTelemetryBus(undefined);
@@ -1312,6 +1313,7 @@ export function loadDocxSessionSync(
         mediaParts,
         mainDocumentPath,
         chartPartLookup,
+        { stripCosmeticMarkers: options.stripCosmeticMarkers !== false },
       );
     } finally {
       if (options.telemetryBus) setActiveParseTelemetryBus(undefined);

package/src/session/import/review-import.ts

@@ -82,7 +82,7 @@ export function normalizeImportedRevisionRecords(
 
       const preserveOnlyReason =
         getStructuralPreserveOnlyReason(revision, paragraphRanges) ??
-        (opaqueRanges.some((range) => rangesIntersect(range, anchor.range))
+        (opaqueRanges.some((range) => rangesIntersect(range, { from: anchor.from, to: anchor.to }))
           ? "Imported revision overlaps preserve-only OOXML and remains preserve-only."
           : undefined);
 
@@ -118,7 +118,7 @@ export function normalizeImportedCommentThreads(
     ) {
       return [];
     }
-    return [revision.anchor.range];
+    return [{ from: revision.anchor.from, to: revision.anchor.to }];
   });
   const preserveOnlyCommentIds = new Set(parsed.diagnostics.map((diagnostic) => diagnostic.commentId));
   const additionalDiagnostics: CommentImportDiagnostic[] = [];
@@ -129,7 +129,7 @@ export function normalizeImportedCommentThreads(
       return thread;
     }
 
-    const opaqueOverlap = opaqueRanges.some((range) => rangesIntersect(range, anchor.range));
+    const opaqueOverlap = opaqueRanges.some((range) => rangesIntersect(range, { from: anchor.from, to: anchor.to }));
     if (opaqueOverlap) {
       preserveOnlyCommentIds.add(thread.commentId);
       additionalDiagnostics.push({
@@ -143,7 +143,7 @@ export function normalizeImportedCommentThreads(
       });
       return {
         ...thread,
-        anchor: createDetachedAnchor(anchor.range, "importAmbiguity"),
+        anchor: createDetachedAnchor({ from: anchor.from, to: anchor.to }, "importAmbiguity"),
         status: "detached",
         metadata: {
           ...thread.metadata,
@@ -155,7 +155,7 @@ export function normalizeImportedCommentThreads(
     }
 
     const preserveOnlyRevisionOverlap = preserveOnlyRevisionRanges.some((range) =>
-      rangesIntersect(range, anchor.range),
+      rangesIntersect(range, { from: anchor.from, to: anchor.to }),
     );
     if (preserveOnlyRevisionOverlap) {
       preserveOnlyCommentIds.add(thread.commentId);
@@ -170,7 +170,7 @@ export function normalizeImportedCommentThreads(
       });
       return {
         ...thread,
-        anchor: createDetachedAnchor(anchor.range, "importAmbiguity"),
+        anchor: createDetachedAnchor({ from: anchor.from, to: anchor.to }, "importAmbiguity"),
         status: "detached",
         metadata: {
           ...thread.metadata,
@@ -257,7 +257,7 @@ export function getStructuralPreserveOnlyReason(
 
   if (
     (form === "run-insertion" || form === "run-deletion") &&
-    anchor.range.from === anchor.range.to
+    anchor.from === anchor.to
   ) {
     return "Imported zero-width run revision remains preserve-only.";
   }
@@ -265,9 +265,9 @@ export function getStructuralPreserveOnlyReason(
   if (form === "paragraph-insertion" || form === "paragraph-deletion") {
     const paragraphBoundary = paragraphRanges.find(
       (boundary) =>
-        boundary.end === anchor.range.from ||
-        (anchor.range.from >= boundary.start &&
-          anchor.range.from <= boundary.end),
+        boundary.end === anchor.from ||
+        (anchor.from >= boundary.start &&
+          anchor.from <= boundary.end),
     );
     return paragraphBoundary
       ? undefined
@@ -276,8 +276,8 @@ export function getStructuralPreserveOnlyReason(
 
   const paragraphBoundary = paragraphRanges.find(
     (boundary) =>
-      anchor.range.from >= boundary.start &&
-      anchor.range.to <= boundary.end,
+      anchor.from >= boundary.start &&
+      anchor.to <= boundary.end,
   );
   return paragraphBoundary
     ? undefined

package/src/session/import/workflow-scope-import.ts

@@ -6,12 +6,13 @@
  *
  * P6-clean: `CommentThread` reaches through `src/model/review/`; every
  * workflow type comes from `src/api/public-types.ts` (an allowed surface
- * for the session layer). Anchor-shape conversion reaches through the
- * shared boundary helper at `src/api/anchor-conversion.ts` (relocated in
- * slice 5e-6g).
+ * for the session layer). Anchor-shape conversion is no longer needed —
+ * L02's FLAT WINS collapse (2026-04-24, `5b2f6f56`) made `CanonicalAnchor`,
+ * `InternalEditorAnchorProjection`, and the public `EditorAnchorProjection`
+ * structurally identical, so `thread.anchor` flows directly into the
+ * `WorkflowScope.anchor` slot without a helper call.
  */
 
-import { toPublicAnchorProjection } from "../../api/anchor-conversion.ts";
 import type {
   WorkflowMetadataSnapshot,
   WorkflowOverlay,
@@ -155,7 +156,7 @@ export function createClmWorkflowScope(
       scopeId,
       version,
       mode: directive.mode,
-      anchor: toPublicAnchorProjection(thread.anchor),
+      anchor: thread.anchor,
       storyTarget: { kind: "main" },
       workItemId,
       label: directive.description,
@@ -166,7 +167,7 @@ export function createClmWorkflowScope(
     scopeId,
     version,
     mode: directive.mode,
-    anchor: toPublicAnchorProjection(thread.anchor),
+    anchor: thread.anchor,
     storyTarget: { kind: "main" },
     label: directive.description,
     metadata: createClmScopeMetadata(directive),
@@ -240,8 +241,8 @@ export function getNextClmScopeVersion(
   anchor: Extract<CommentThread["anchor"], { kind: "range" }>,
 ): number {
   const anchorRange = {
-    from: anchor.range.from,
-    to: anchor.range.to,
+    from: anchor.from,
+    to: anchor.to,
   };
   const overlappingVersions = scopes.flatMap((scope) => {
     if (scope.anchor.kind !== "range") {

package/src/shell/session-bootstrap.ts

@@ -1139,6 +1139,9 @@ function createLoadingRuntimeBridge(input: {
     },
     getScope: () => null,
     compileScopeBundleById: () => null,
+    compileScopeList: () => [],
+    compileScopeCardById: () => null,
+    compileScopeRailSnapshot: () => ({ segments: [] }),
     getMarkerBackedScopeIds: () => new Set<string>(),
     debug: createLoadingDebugFacet(),
     removeScope: () => undefined,
@@ -1281,6 +1284,7 @@ function createLoadingRuntimeBridge(input: {
     getPerfCountersSnapshot: () => ({}),
     resetPerfCounters: () => undefined,
     setVisibleBlockRange: () => undefined,
+    setVisibleBlockRanges: () => undefined,
     requestViewportRefresh: () => undefined,
     addInvisibleScope: () => ({ scopeId: "", anchor: { kind: "range", from: 0, to: 0, assoc: { start: -1, end: 1 } } }),
     setScopeVisibility: () => undefined,

package/src/ui-tailwind/editor-surface/pm-schema.ts

@@ -200,6 +200,15 @@ export const editorSchema = new Schema({
         hiddenTextOnly: { default: null },
         placeholderCulled: { default: null },
         blockId: { default: null },
+        /**
+         * `<w:framePr>` projection from `SurfaceBlockFragment.frameProperties`
+         * (ECMA-376 §17.3.1.11). When set (and `dropCap` is neither `"drop"`
+         * nor `"margin"`), `toDOM` emits `position: absolute` with the
+         * xTwips/yTwips/widthTwips/heightTwips fields; the inline flow
+         * already treats the paragraph as zero-height per L04
+         * `measureBlockHeight` short-circuit (a298391e / coord-04 §1.19.d).
+         */
+        frameProperties: { default: null },
       },
       parseDOM: [{ tag: "p" }],
       toDOM(node) {
@@ -278,6 +287,29 @@ export const editorSchema = new Schema({
         }
         const pageBreak = node.attrs.pageBreakBefore as boolean | null;
         if (pageBreak) styles.push("border-top: 2px dashed rgba(0,0,0,0.1); padding-top: 8px; margin-top: 16px");
+        // `<w:framePr>` out-of-flow frame — mirror the static-path branch in
+        // tw-page-block-view.helpers.ts so PM-rendered page 1 absolutely
+        // positions the frame identically to pages 2+.
+        const framePr = node.attrs.frameProperties as
+          | {
+              xTwips?: number;
+              yTwips?: number;
+              widthTwips?: number;
+              heightTwips?: number;
+              hRule?: "auto" | "atLeast" | "exact";
+              dropCap?: "none" | "drop" | "margin";
+            }
+          | null;
+        if (framePr && framePr.dropCap !== "drop" && framePr.dropCap !== "margin") {
+          styles.push("position: absolute");
+          if (typeof framePr.xTwips === "number") styles.push(`left: ${framePr.xTwips / 20}pt`);
+          if (typeof framePr.yTwips === "number") styles.push(`top: ${framePr.yTwips / 20}pt`);
+          if (typeof framePr.widthTwips === "number") styles.push(`width: ${framePr.widthTwips / 20}pt`);
+          if (typeof framePr.heightTwips === "number") {
+            if (framePr.hRule === "exact") styles.push(`height: ${framePr.heightTwips / 20}pt`);
+            else if (framePr.hRule === "atLeast") styles.push(`min-height: ${framePr.heightTwips / 20}pt`);
+          }
+        }
         const hiddenTextOnly = node.attrs.hiddenTextOnly as boolean | null;
         if (hiddenTextOnly) {
           attrs["data-hidden-paragraph"] = "true";