@beyondwork/docx-react-component 1.0.73 → 1.0.75

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

@@ -1,21 +1,26 @@
 /**
- * Layer-06 Slice 3 — `createScopeFromBlockId` adapter.
+ * Layer-06 — marker-backed workflow-scope creators.
  *
- * Resolves a `blockId` (paragraph/table/sdt-index identifier minted by
- * `src/runtime/surface-projection.ts`) into the `EditorAnchorProjection`
- * that `runtime.addScope` expects, then delegates to the existing
- * marker-backed scope creator.
+ * Two adapters share `runtime.addScope` as the underlying creator:
+ *
+ * 1. `createScopeFromBlockId` — resolves a block identifier
+ *    (`paragraph-N`, `table-N`, `sdt-N`) minted by
+ *    `src/runtime/surface-projection.ts` into the whole-block range.
+ *    Use when the scope should cover an entire paragraph / table / SDT.
+ *
+ * 2. `createScopeFromAnchor` — takes a sub-block `{from, to}` range
+ *    directly. Use when the scope should bracket a sub-span — a phrase
+ *    inside a paragraph, a cross-paragraph selection, a span from a
+ *    click + drag. Resolves the KI-P9 "positions-as-references" trap:
+ *    positions are consumed **once** at creation to plant the markers;
+ *    the returned `scopeId` is durable and survives subsequent editing.
+ *    Callers must stop carrying the positions after the call returns.
  *
  * Resolution walks the canonical document directly, not the surface
  * snapshot. Going through `runtime.getRenderSnapshot().surface.blocks`
  * would miss blocks the surface replaces with `placeholder-culled-*`
  * entries under viewport culling — a real reproducibility failure on
  * CCEP-size documents.
- *
- * This adapter unblocks `v3 runtime.workflow.createScope` graduation
- * from `mock` → `live-with-adapter`. Consumers that already carry a
- * full `EditorAnchorProjection` should continue calling
- * `runtime.addScope` directly.
  */
 
 import type {
@@ -220,3 +225,200 @@ export function createScopeFromBlockId(
 
 // Exported for tests that need to verify the resolver independently.
 export { resolveBlockAnchorFromCanonical };
+
+/**
+ * Input for `createScopeFromAnchor`. The `anchor` fields are a one-shot
+ * position query — the runtime plants inline `scope_marker_start` /
+ * `scope_marker_end` at these offsets and returns a marker-backed
+ * `scopeId`. From that moment the markers travel with their bracketed
+ * content through any number of edits; callers must re-resolve by
+ * `scopeId` afterward and MUST NOT store or reuse `from`/`to`.
+ */
+export interface CreateScopeFromAnchorInput {
+  /**
+   * Range in the current document state. `from` and `to` are measured
+   * in the editor's surface-projection offset space (the same space
+   * `findText`, `replaceText`, and `addScope` ranges use). Must satisfy
+   * `0 <= from <= to <= storyLength`.
+   */
+  readonly anchor: {
+    readonly from: number;
+    readonly to: number;
+    readonly storyTarget?: EditorStoryTarget;
+  };
+  readonly mode?: WorkflowScopeMode;
+  readonly label?: string;
+  readonly scopeId?: string;
+  readonly persistence?: WorkflowMetadataPersistence;
+  readonly metadata?: Partial<WorkflowMetadataEntry>;
+  /**
+   * Per-scope edge stickiness for the range anchor. Defaults to
+   * `{ start: 1, end: -1 }` (greedy — absorbs boundary inserts). See
+   * `CreateScopeFromBlockIdInput.assoc` for the full matrix.
+   */
+  readonly assoc?: { readonly start: -1 | 1; readonly end: -1 | 1 };
+  /** Caller-steerable identity strategy; same semantics as on `CreateScopeFromBlockIdInput`. */
+  readonly stableRefHint?:
+    | "scope-id"
+    | "bookmark"
+    | "semantic-path"
+    | "runtime-handle";
+}
+
+export type CreateScopeFromAnchorResult =
+  | {
+      readonly status: "created";
+      readonly scopeId: string;
+      readonly anchor: EditorAnchorProjection;
+    }
+  | {
+      readonly status: "range-invalid";
+      readonly reason:
+        | "from-negative"
+        | "to-less-than-from"
+        | "range-exceeds-story-length";
+      readonly from: number;
+      readonly to: number;
+      readonly storyLength: number;
+      /**
+       * Single-sentence, agent-actionable explanation. Tells the caller
+       * what the failure was and the concrete next step — no guesswork
+       * required. Safe to surface directly to an LLM tool-use loop as
+       * the `error` content of the tool reply.
+       */
+      readonly message: string;
+      /**
+       * Short machine-routable next-step hint for thin consumers that
+       * don't want to pattern-match on `reason`. Examples:
+       *   "clamp-from-to-zero", "swap-from-and-to",
+       *   "clamp-to-to-storyLength-or-pick-a-different-range".
+       */
+      readonly nextStep: string;
+    };
+
+/**
+ * Sum the total length of the main story by walking blocks with
+ * inter-block gap semantics matched to `resolveBlockAnchorFromCanonical`.
+ * Used as the bounds check for `createScopeFromAnchor`.
+ */
+function computeMainStoryLength(document: CanonicalDocumentEnvelope): number {
+  const root = document.content as DocumentRootNode;
+  const blocks = root.children;
+  let total = 0;
+  for (let i = 0; i < blocks.length; i += 1) {
+    const block: BlockNode = blocks[i]!;
+    if (block.type === "paragraph") {
+      total += paragraphLength(block);
+    } else {
+      total += 1;
+    }
+    if (i < blocks.length - 1) total += 1;
+  }
+  return total;
+}
+
+/**
+ * Create a marker-backed workflow scope over a sub-block anchor range.
+ *
+ * The returned `scopeId` is the durable reference — after this call
+ * returns, `from`/`to` are not part of the scope's identity and must
+ * not be stored or reused. All later lookups use
+ * `resolveReference({kind:"scope-id", value: scopeId})` or `get_scope`,
+ * which walk to the markers' current positions regardless of
+ * intervening edits.
+ *
+ * Bounds: `0 <= from <= to <= storyLength`. Out-of-bounds or inverted
+ * ranges return `{status: "range-invalid", reason}` without mutating
+ * the document. `storyTarget` defaults to main; footnote / header /
+ * endnote stories are supported by passing the target through.
+ */
+export function createScopeFromAnchor(
+  runtime: ScopeWriterRuntime,
+  input: CreateScopeFromAnchorInput,
+): CreateScopeFromAnchorResult {
+  const doc = runtime.getCanonicalDocument();
+  const storyTarget: EditorStoryTarget =
+    input.anchor.storyTarget ?? { kind: "main" };
+  // Bounds check only covers the main story today. Non-main stories
+  // (footnote / header / endnote) skip the numeric bound check —
+  // `runtime.addScope` is the authoritative bound enforcer for those
+  // secondary stories and returns an error anchor when the range is
+  // invalid. This matches the pre-existing `createScopeFromBlockId`
+  // contract where block resolution handles story-aware bounds.
+  const storyLength =
+    storyTarget.kind === "main" ? computeMainStoryLength(doc) : Number.MAX_SAFE_INTEGER;
+
+  const { from, to } = input.anchor;
+  if (from < 0) {
+    return {
+      status: "range-invalid",
+      reason: "from-negative",
+      from,
+      to,
+      storyLength,
+      message:
+        `createScopeFromAnchor requires from >= 0 (received from=${from}). ` +
+        `Offsets are zero-based absolute positions in the current document; ` +
+        `clamp negative values to 0 before calling.`,
+      nextStep: "clamp-from-to-zero",
+    };
+  }
+  if (to < from) {
+    return {
+      status: "range-invalid",
+      reason: "to-less-than-from",
+      from,
+      to,
+      storyLength,
+      message:
+        `createScopeFromAnchor requires to >= from (received from=${from}, to=${to}). ` +
+        `The range is inverted — swap the two values before calling.`,
+      nextStep: "swap-from-and-to",
+    };
+  }
+  if (to > storyLength) {
+    return {
+      status: "range-invalid",
+      reason: "range-exceeds-story-length",
+      from,
+      to,
+      storyLength,
+      message:
+        `createScopeFromAnchor requires to <= storyLength (received to=${to}, ` +
+        `storyLength=${storyLength}). This typically means the offset was ` +
+        `captured from a stale document state (see KI-P9) — do not carry ` +
+        `offsets across mutations. Re-derive from the current document, or ` +
+        `clamp to <= storyLength and verify the result targets the intended content.`,
+      nextStep: "clamp-to-to-storyLength-or-pick-a-different-range",
+    };
+  }
+
+  const anchor: EditorAnchorProjection = {
+    kind: "range",
+    from,
+    to,
+    assoc: input.assoc ?? { start: 1, end: -1 },
+  };
+
+  const scopeMetadataFields: WorkflowScopeMetadataField[] = [];
+  if (input.stableRefHint !== undefined) {
+    scopeMetadataFields.push({
+      key: "stableRefHint",
+      valueType: "string",
+      value: input.stableRefHint,
+    });
+  }
+
+  const result: AddScopeResult = runtime.addScope({
+    anchor,
+    mode: input.mode,
+    scopeId: input.scopeId,
+    persistence: input.persistence,
+    metadata: input.metadata,
+    storyTarget,
+    label: input.label,
+    ...(scopeMetadataFields.length > 0 ? { scopeMetadataFields } : {}),
+  });
+
+  return { status: "created", scopeId: result.scopeId, anchor: result.anchor };
+}

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

@@ -289,7 +289,15 @@ export const editorSchema = new Schema({
         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+.
+        // positions the frame identically to pages 2+. Gating rules
+        // match the static path: drop-cap stays in-flow; a framePr with
+        // zero positional fields stays in-flow (no out-of-flow without
+        // a declared position — M3 review finding).
+        //
+        // N1: `position: absolute` is pushed BEFORE `hiddenTextOnly`'s
+        // `display: none` by code order; `display: none` wins visually
+        // regardless of source order, so a hidden framed paragraph
+        // collapses as expected. Do not "fix" the order — it's correct.
         const framePr = node.attrs.frameProperties as
           | {
               xTwips?: number;
@@ -298,9 +306,21 @@ export const editorSchema = new Schema({
               heightTwips?: number;
               hRule?: "auto" | "atLeast" | "exact";
               dropCap?: "none" | "drop" | "margin";
+              xAlign?: string;
+              yAlign?: string;
             }
           | null;
-        if (framePr && framePr.dropCap !== "drop" && framePr.dropCap !== "margin") {
+        const hasPosition =
+          typeof framePr?.xTwips === "number" ||
+          typeof framePr?.yTwips === "number" ||
+          typeof framePr?.xAlign === "string" ||
+          typeof framePr?.yAlign === "string";
+        if (
+          framePr &&
+          framePr.dropCap !== "drop" &&
+          framePr.dropCap !== "margin" &&
+          hasPosition
+        ) {
           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`);

package/src/ui-tailwind/editor-surface/surface-build-keys.ts

@@ -24,7 +24,7 @@ export function createSurfaceDocumentBuildKey(input: {
   showUnsupportedObjectPreviews?: boolean;
   isPageWorkspace?: boolean;
 }): string {
-  const vp = input.surface?.viewportBlockRange ?? null;
+  const ranges = input.surface?.viewportBlockRanges ?? null;
   return JSON.stringify({
     surfaceIdentity:
       input.surface === undefined || input.surface === null
@@ -34,7 +34,10 @@ export function createSurfaceDocumentBuildKey(input: {
     mediaPreviewKey: input.mediaPreviewKey,
     showUnsupportedObjectPreviews: input.showUnsupportedObjectPreviews ?? false,
     isPageWorkspace: input.isPageWorkspace ?? false,
-    viewport: vp ? `${vp.start}:${vp.end}` : "full",
+    // Serialize all intervals (sorted by start) — disjoint viewport+caret
+    // ranges must key distinctly from a single merged range so PM rebuilds
+    // when the caret's page comes into/out of the realized set.
+    viewport: ranges ? ranges.map((r) => `${r.start}:${r.end}`).join("|") : "full",
   });
 }
 

package/src/ui-tailwind/editor-surface/tw-page-block-view.helpers.ts

@@ -124,6 +124,9 @@ export function computeTabWidthsInPoints(
     if (stop) {
       const prevPos = tabIndex > 0 ? readPos(rawStops[tabIndex - 1]) : 0;
       const widthTwips = readPos(stop) - prevPos;
+      // `> 0` (not `>= 0`) is intentional — a zero-width zone between
+      // two identical stops is meaningless; skip so the caller falls
+      // back to the 32 px default.
       if (widthTwips > 0) {
         widths.set(seg.segmentId, widthTwips / 20);
       }
@@ -254,10 +257,26 @@ export function buildParagraphStyle(
   // `<w:framePr>` out-of-flow frame (ECMA-376 §17.3.1.11). L04 returns 0
   // from measureBlockHeight for these paragraphs (a298391e) so the inline
   // flow doesn't double-count; L11 renders them absolutely positioned.
-  // Drop-cap (dropCap="drop"|"margin") is in-flow — only the initial
-  // letter is framed — so skip the absolute switch there.
+  //
+  // Gating rules (M3 review finding):
+  //   - Drop-cap (`dropCap` "drop" | "margin") is in-flow — only the
+  //     initial letter is framed; paragraph body stays with its text.
+  //   - A `<w:framePr/>` with ZERO positional fields (no xTwips / yTwips
+  //     / xAlign / yAlign) is ambiguous; Word treats it as in-flow. If
+  //     we emitted `position: absolute` we'd pin the paragraph at (0,0)
+  //     of the nearest positioned ancestor — dramatically wrong.
   const framePr = block.frameProperties;
-  if (framePr && framePr.dropCap !== "drop" && framePr.dropCap !== "margin") {
+  const hasPosition =
+    typeof framePr?.xTwips === "number" ||
+    typeof framePr?.yTwips === "number" ||
+    typeof framePr?.xAlign === "string" ||
+    typeof framePr?.yAlign === "string";
+  if (
+    framePr &&
+    framePr.dropCap !== "drop" &&
+    framePr.dropCap !== "margin" &&
+    hasPosition
+  ) {
     style.position = "absolute";
     if (typeof framePr.xTwips === "number") {
       style.left = `${framePr.xTwips / 20}pt`;

package/src/ui-tailwind/page-stack/floating-image-overlay-model.ts

@@ -145,11 +145,15 @@ export function collectFloatingImageOverlayItems(input: {
   };
 
   // coord-01 §9 / §5.1 — CCEP logos live in header stories; collect from
-  // the main story for the active-story case AND from every secondary
-  // story so header/footer images reach the overlay regardless of which
-  // story is active in the editor.
+  // the active story's surface.blocks (always) + every secondary story
+  // EXCEPT the one whose target matches activeStory (runtime fills
+  // surface.blocks with that same story's blocks, so walking secondary
+  // stories unconditionally would double-emit header/footer segments
+  // the moment the user enters a header for editing — M1).
   collectFromStory(surface.blocks, activeStory);
+  const activeKey = storyTargetKey(activeStory);
   for (const secondary of surface.secondaryStories ?? []) {
+    if (storyTargetKey(secondary.target) === activeKey) continue;
     collectFromStory(secondary.blocks, secondary.target);
   }
 

package/src/ui-tailwind/page-stack/tw-endnote-area.tsx

@@ -52,7 +52,11 @@ export const TwEndnoteArea: React.FC<TwEndnoteAreaProps> = ({
           marginBottom: "8pt",
         }}
       />
-      <TwRegionBlockRenderer blocks={blocks} mediaPreviews={mediaPreviews} />
+      <TwRegionBlockRenderer
+        blocks={blocks}
+        mediaPreviews={mediaPreviews}
+        fallbackDisplay="hidden"
+      />
     </div>
   );
 };

package/src/ui-tailwind/page-stack/tw-footnote-area.tsx

@@ -66,7 +66,11 @@ export const TwFootnoteArea: React.FC<TwFootnoteAreaProps> = React.memo(({
           marginBottom: "4pt",
         }}
       />
-      <TwRegionBlockRenderer blocks={blocks} mediaPreviews={mediaPreviews} />
+      <TwRegionBlockRenderer
+        blocks={blocks}
+        mediaPreviews={mediaPreviews}
+        fallbackDisplay="hidden"
+      />
     </div>
   );
 });

package/src/ui-tailwind/page-stack/tw-region-block-renderer.tsx

@@ -14,6 +14,7 @@ import {
   headingClassList,
   resolveHeadingLevel,
 } from "../editor-surface/tw-page-block-view.helpers.ts";
+import { shouldRenderAbsoluteFloatingImageInPageOverlay } from "./floating-image-overlay-model.ts";
 
 const EMU_PER_PX = 9525;
 
@@ -94,11 +95,12 @@ function renderSegment(
     case "hard_break":
       return <br key={seg.segmentId} />;
     case "image": {
-      // §5.1 gap 3 — floating-anchor images are owned by the absolute
-      // floating-image overlay (`TwFloatingImageLayer`). Emitting them
-      // inline here would double-paint the CCEP header logo on every
-      // page. Skip entirely so only the overlay renders them.
-      if (seg.anchor?.display === "floating") {
+      // §5.1 gap 3 — floating-anchor images the overlay can render
+      // (`TwFloatingImageLayer`) are owned by the overlay. Skip inline
+      // emission ONLY for anchors the overlay predicate accepts —
+      // otherwise wrap-mode=square / column-relative / tight-wrapped
+      // floats get dropped from inline AND from the overlay (M2).
+      if (shouldRenderAbsoluteFloatingImageInPageOverlay(seg.anchor)) {
         return null;
       }
       // Mirror body-renderer behavior (`pm-state-from-snapshot.ts` :500+):