@beyondwork/docx-react-component 1.0.72 → 1.0.74

package/src/io/normalize/normalize-text.ts

@@ -264,6 +264,7 @@ function normalizeParagraph(
     ...(paragraph.suppressLineNumbers !== undefined
       ? { suppressLineNumbers: paragraph.suppressLineNumbers }
       : {}),
+    ...(paragraph.frameProperties ? { frameProperties: paragraph.frameProperties } : {}),
     // A.7: preserve w14:paraId / w14:textId across import → export so
     // downstream tools that diff documents by paragraph id stay stable.
     ...(paragraph.wordExtensionIds
@@ -715,9 +716,30 @@ function registerComplexPreviewMedia(
 function normalizeHyperlink(node: ParsedHyperlinkNode): {
   type: "hyperlink";
   href: string;
-  children: Array<TextNode | { type: "hard_break" } | { type: "tab" }>;
+  children: Array<
+    | TextNode
+    | { type: "hard_break" }
+    | { type: "column_break" }
+    | { type: "page_break" }
+    | { type: "tab" }
+    | { type: "symbol"; char: string; font?: string; marks?: TextMark[] }
+  >;
 } {
-  const children: Array<TextNode | { type: "hard_break" } | { type: "tab" }> = [];
+  // Canonical `HyperlinkNode.children` accepts the full inline-leaf set
+  // (TextNode | HardBreakNode | ColumnBreakNode | PageBreakNode | TabNode |
+  // SymbolNode). Matching the canonical shape here keeps rare
+  // hyperlink-inside-break patterns (a link spanning a column or page
+  // break in Word's output) from silently dropping at the normalize step —
+  // same class of drop that `coord-04 §1.19.b` fixed one level up in
+  // `normalizeInlineChildren`.
+  const children: Array<
+    | TextNode
+    | { type: "hard_break" }
+    | { type: "column_break" }
+    | { type: "page_break" }
+    | { type: "tab" }
+    | { type: "symbol"; char: string; font?: string; marks?: TextMark[] }
+  > = [];
 
   for (const child of node.children) {
     switch (child.type) {
@@ -743,6 +765,20 @@ function normalizeHyperlink(node: ParsedHyperlinkNode): {
       case "hard_break":
         children.push({ type: "hard_break" });
         break;
+      case "column_break":
+        children.push({ type: "column_break" });
+        break;
+      case "page_break":
+        children.push({ type: "page_break" });
+        break;
+      case "symbol":
+        children.push({
+          type: "symbol",
+          char: child.char,
+          ...(child.font ? { font: child.font } : {}),
+          ...(child.marks && child.marks.length > 0 ? { marks: child.marks } : {}),
+        });
+        break;
     }
   }
 

package/src/io/ooxml/parse-comments.ts

@@ -652,9 +652,9 @@ function extractNodeText(node: XmlNode): string {
 
 function compareThreadsByAnchor(left: CommentThread, right: CommentThread): number {
   const leftStart =
-    left.anchor.kind === "range" ? left.anchor.range.from : Number.MAX_SAFE_INTEGER;
+    left.anchor.kind === "range" ? left.anchor.from : Number.MAX_SAFE_INTEGER;
   const rightStart =
-    right.anchor.kind === "range" ? right.anchor.range.from : Number.MAX_SAFE_INTEGER;
+    right.anchor.kind === "range" ? right.anchor.from : Number.MAX_SAFE_INTEGER;
 
   if (leftStart !== rightStart) {
     return leftStart - rightStart;

package/src/io/ooxml/parse-headers-footers.ts

@@ -328,6 +328,37 @@ function parseParagraphElement(
         activeComplexField = null;
       }
       pushFieldNode(children, child, "simple");
+    } else if (name === "sdt") {
+      // coord-11 §22 — structured-document-tag wrapping run-level content
+      // inside a header/footer paragraph. Word commonly uses these to
+      // bundle the page-number field + decorative drawings (e.g. CCEP's
+      // footer "Copyright CCEP STRICTLY CONFIDENTIAL" red rectangle +
+      // "Page N" label both sit inside one `<w:sdt>` in footer1.xml).
+      // Without this case the sdt was silently dropped at the paragraph
+      // walker and every run it carried — including WPS shapes bearing
+      // the brand-strip text — never reached the canonical tree.
+      // Treat `<w:sdtContent>` as a transparent wrapper and re-process
+      // its `<w:r>` / `<w:hyperlink>` / `<w:sdt>` children as if they
+      // were direct paragraph children.
+      const sdtContent = findChildElementOptional(child, "sdtContent");
+      if (sdtContent) {
+        for (const grandchild of sdtContent.children) {
+          if (grandchild.type !== "element") continue;
+          const gname = localName(grandchild.name);
+          if (gname === "r") {
+            activeComplexField = appendRunNodes(grandchild, children, activeComplexField, sourceXml, opts);
+          } else if (gname === "hyperlink") {
+            children.push(parseHyperlinkElement(grandchild, opts));
+          } else if (gname === "bookmarkStart" || gname === "bookmarkEnd") {
+            children.push(parseBookmarkElement(grandchild));
+          } else if (gname === "fldSimple") {
+            pushFieldNode(children, grandchild, "simple");
+          }
+          // Nested sdt / other elements ignored — deeper nesting is rare
+          // enough that opaque round-trip via the block-level sdt parser
+          // handles it if it matters.
+        }
+      }
     }
   }
 

package/src/io/ooxml/parse-main-document.ts

@@ -1,6 +1,7 @@
 import type {
   BorderSpec,
   CellShading,
+  FrameProperties,
   TextMark,
   ParagraphBorders,
   ParagraphShading,
@@ -39,6 +40,7 @@ import { parseComplexContentXml, type ChartPartLookup } from "./parse-complex-co
 import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
 import { parseObject } from "./parse-object.ts";
 import { parseDrawingFrame } from "./parse-drawing.ts";
+import { readFrameProperties } from "./parse-paragraph-formatting.ts";
 import { classifyFieldInstruction } from "./parse-fields.ts";
 import { parseFFDataFromFldChar } from "./parse-ffdata.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
@@ -217,6 +219,41 @@ function captureGrabBagFromContainer(
 export interface ParsedMainDocument {
   blocks: ParsedBlockNode[];
   finalSectionProperties?: SectionProperties;
+  /**
+   * Aggregate count of cosmetic markers stripped during parse (see
+   * {@link ParseMainDocumentOptions.stripCosmeticMarkers}). Keyed by
+   * local element name (e.g. `lastRenderedPageBreak`). Absent when no
+   * markers were stripped.
+   */
+  skippedCosmeticMarkerCounts?: Readonly<Record<string, number>>;
+}
+
+/**
+ * Cosmetic markers that Word re-inserts on reopen and that carry no
+ * contract semantics. Stripping them at parse time unblocks
+ * `replaceText` on ranges that today cross them as `opaque_inline`
+ * boundaries. See `docs/architecture/cosmetic-marker-strip.md`.
+ *
+ * This is the Phase 1 set. Bookmark-pair stripping (with reference
+ * scan) is Phase 2.
+ */
+export const COSMETIC_MARKER_ELEMENT_NAMES: ReadonlySet<string> = new Set([
+  "lastRenderedPageBreak",
+  "proofErr",
+  "noBreakHyphen",
+]);
+
+export interface ParseMainDocumentOptions {
+  /**
+   * When `true` (the default), drops `<w:lastRenderedPageBreak/>`,
+   * `<w:proofErr/>`, and `<w:noBreakHyphen/>` during the parse walk
+   * instead of emitting them as `opaque_inline` nodes. Counts are
+   * reported on {@link ParsedMainDocument.skippedCosmeticMarkerCounts}.
+   *
+   * Set to `false` to preserve the pre-strip behavior exactly — every
+   * cosmetic marker becomes an `opaque_inline` with its source XML.
+   */
+  stripCosmeticMarkers?: boolean;
 }
 
 export type ParsedBlockNode =
@@ -256,6 +293,15 @@ export interface ParsedParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  /**
+   * `<w:framePr>` declared directly on the paragraph's own `<w:pPr>`.
+   * Coord-04 §1.19.d step 2 (inline path). The style-cascade path
+   * flows through `CanonicalParagraphFormatting.frameProperties` on
+   * the style side; this slot captures the direct-override path so
+   * L02 `ParagraphNode.frameProperties` (added 2026-04-24 `4b3ea0b2`)
+   * can reach its canonical shape.
+   */
+  frameProperties?: FrameProperties;
   /** A.7: preserved w14 extension ids (paraId/textId). */
   wordExtensionIds?: {
     paraId?: string;
@@ -656,24 +702,61 @@ export function setActiveParseTelemetryBus(bus: ParseTelemetryBus | undefined):
   activeParseTelemetryBus = bus;
 }
 
+/**
+ * Request-scoped cosmetic-marker strip context. Set by
+ * `parseMainDocumentXml` for the duration of a single parse; read at
+ * the four emission sites in `parseBodyChild` / `parseRun` /
+ * `parseRunContentOnly` / `parseRevisionContainer`. Using a module
+ * variable instead of threading the flag through ~15 intermediate
+ * function signatures keeps the call sites readable; the try/finally
+ * in the entry point ensures the variable never leaks across calls.
+ *
+ * Re-entrancy invariant matches `activeChartPartLookup` above.
+ */
+interface CosmeticStripContext {
+  readonly strip: boolean;
+  readonly counts: Record<string, number>;
+}
+let activeCosmeticStripContext: CosmeticStripContext | null = null;
+
+function noteStrippedCosmeticMarker(tag: string): void {
+  if (!activeCosmeticStripContext) return;
+  activeCosmeticStripContext.counts[tag] =
+    (activeCosmeticStripContext.counts[tag] ?? 0) + 1;
+}
+
+function shouldStripCosmeticMarker(): boolean {
+  return activeCosmeticStripContext?.strip === true;
+}
+
 export function parseMainDocumentXml(
   xml: string,
   relationships: readonly OpcRelationship[] = [],
   mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
   sourcePartPath = "/word/document.xml",
   chartPartLookup?: ChartPartLookup,
+  parseOptions: ParseMainDocumentOptions = {},
 ): ParsedMainDocument {
   activeChartPartLookup = chartPartLookup;
+  const stripContext: CosmeticStripContext = {
+    strip: parseOptions.stripCosmeticMarkers !== false,
+    counts: Object.create(null) as Record<string, number>,
+  };
+  activeCosmeticStripContext = stripContext;
   const bus = activeParseTelemetryBus;
   const started = bus?.isEnabled("parse") ? performanceNow() : 0;
   try {
     const result = parseMainDocumentXmlInner(xml, relationships, mediaParts, sourcePartPath);
+    if (Object.keys(stripContext.counts).length > 0) {
+      result.skippedCosmeticMarkerCounts = Object.freeze({ ...stripContext.counts });
+    }
     if (bus?.isEnabled("parse")) {
       emitParseSummary(bus, result, sourcePartPath, performanceNow() - started);
     }
     return result;
   } finally {
     activeChartPartLookup = undefined;
+    activeCosmeticStripContext = null;
   }
 }
 
@@ -704,6 +787,13 @@ function emitParseSummary(
       blockCount: result.blocks.length,
       blockKindCounts: counts,
       ms,
+      // Strip counts are surfaced here (telemetry-only) rather than as a
+      // warning on `diagnostics.warnings` — the markers carry no
+      // contract semantics and surfacing them in the user-visible
+      // warnings feed would be noise. Available to debug UX / tests via
+      // the `parse` channel; absent when the feature is disabled or no
+      // markers were stripped.
+      skippedCosmeticMarkerCounts: result.skippedCosmeticMarkerCounts,
     },
   });
 }
@@ -1004,6 +1094,7 @@ function parseBodyChild(
   let bidi: ParsedParagraphNode["bidi"];
   let suppressLineNumbers: ParsedParagraphNode["suppressLineNumbers"];
   let cnfStyle: ParsedParagraphNode["cnfStyle"];
+  let frameProperties: ParsedParagraphNode["frameProperties"];
   let sectionProperties: SectionProperties | undefined;
   let sectionPropertiesXml: string | undefined;
   let paragraphSupported = true;
@@ -1050,6 +1141,12 @@ function parseBodyChild(
         bidi = readOnOffParagraphProperty(child, "bidi");
         suppressLineNumbers = readOnOffParagraphProperty(child, "suppressLineNumbers");
         cnfStyle = readParagraphCnfStyle(child);
+        {
+          const framePrNode = child.children.find(
+            (c): c is XmlElementNode => c.type === "element" && localName(c.name) === "framePr",
+          );
+          if (framePrNode) frameProperties = readFrameProperties(framePrNode);
+        }
         sectionProperties = readSectionPropertiesFromPPr(child);
         sectionPropertiesXml = readSectionPropertiesXmlFromPPr(child, sourceXml);
         paragraphSupported = paragraphSupported && supportsParagraphProperties(child);
@@ -1148,6 +1245,10 @@ function parseBodyChild(
         flushActiveComplexField(children, () => {
           activeComplexField = null;
         }, activeComplexField);
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker("proofErr");
+          break;
+        }
         children.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
@@ -1235,6 +1336,7 @@ function parseBodyChild(
     ...(bidi !== undefined ? { bidi } : {}),
     ...(suppressLineNumbers !== undefined ? { suppressLineNumbers } : {}),
     ...(cnfStyle ? { cnfStyle } : {}),
+    ...(frameProperties ? { frameProperties } : {}),
     ...(wordExtensionIds ? { wordExtensionIds } : {}),
     ...(sectionProperties ? { sectionProperties } : {}),
     ...(sectionPropertiesXml ? { sectionPropertiesXml } : {}),
@@ -2584,6 +2686,11 @@ function parseRun(
       }
       case "lastRenderedPageBreak":
       case "proofErr":
+      case "noBreakHyphen":
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker(localName(child.name));
+          break;
+        }
         result.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
@@ -2657,12 +2764,23 @@ function parseRevisionContainer(
         result.push(hyperlink);
         break;
       }
+      case "proofErr":
+      case "lastRenderedPageBreak":
+      case "noBreakHyphen":
+        if (shouldStripCosmeticMarker()) {
+          noteStrippedCosmeticMarker(localName(child.name));
+          break;
+        }
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end),
+          },
+        ];
       case "commentRangeStart":
       case "commentRangeEnd":
       case "bookmarkStart":
       case "bookmarkEnd":
-      case "proofErr":
-      case "lastRenderedPageBreak":
         return [
           {
             type: "opaque_inline",
@@ -2835,10 +2953,17 @@ function parseRunContentOnly(
       case "commentReference":
       case "lastRenderedPageBreak":
       case "proofErr":
+      case "noBreakHyphen": {
+        const tag = localName(child.name);
+        if (shouldStripCosmeticMarker() && tag !== "commentReference") {
+          noteStrippedCosmeticMarker(tag);
+          break;
+        }
         if (options.preserveUnsupportedReviewMarkup) {
           return { nodes: [], supported: false };
         }
         break;
+      }
       default:
         return { nodes: [], supported: false };
     }

package/src/io/ooxml/parse-paragraph-formatting.ts

@@ -204,7 +204,7 @@ function readShading(node: XmlElementNode): ParagraphShading | undefined {
  * The typed attributes cover the CCEP cases we've seen (2-column inset
  * text frames, drop-caps); extension attrs are rare in that corpus.
  */
-function readFrameProperties(node: XmlElementNode): FrameProperties | undefined {
+export function readFrameProperties(node: XmlElementNode): FrameProperties | undefined {
   const out: FrameProperties = {};
   const width = readIntAttr(node, "w:w");
   if (width !== undefined) out.widthTwips = width;

package/src/model/anchor.ts

@@ -25,9 +25,17 @@ export interface BoundaryAssoc {
   end: Assoc;
 }
 
+/**
+ * Range anchor — flat shape `{ kind: "range", from, to, assoc }` after the
+ * 2026-04-23 flat-wins collapse. Prior to the collapse this carried a nested
+ * `{ range: DocRange, assoc }` shape. See `canonical-document.ts` CanonicalAnchor
+ * for the matching canonical shape + `repairCanonicalDocumentEnvelope` for the
+ * persisted-snapshot legacy-to-flat migration.
+ */
 export interface RangeAnchor {
   kind: "range";
-  range: DocRange;
+  from: Position;
+  to: Position;
   assoc: BoundaryAssoc;
 }
 

package/src/model/canonical-document.ts

@@ -2013,7 +2013,8 @@ export interface BoundaryAssoc {
 export type CanonicalAnchor =
   | {
       kind: "range";
-      range: DocRange;
+      from: number;
+      to: number;
       assoc: BoundaryAssoc;
     }
   | {
@@ -2329,7 +2330,7 @@ export function repairCanonicalDocumentEnvelope(
     review:
       record.review === undefined
         ? base.review
-        : (record.review as CanonicalDocument["review"]),
+        : (migrateLegacyReviewAnchors(record.review) as CanonicalDocument["review"]),
     preservation:
       record.preservation === undefined
         ? base.preservation
@@ -2355,6 +2356,67 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
+/**
+ * Schema-compat shim for the 2026-04-23 flat-wins anchor collapse. Legacy
+ * persisted snapshots carry range anchors as `{kind: "range", range: {from, to},
+ * assoc}`. Rewrite those to the flat shape `{kind: "range", from, to, assoc}`
+ * on rehydration so old snapshots continue to load.
+ */
+export function migrateLegacyReviewAnchors(review: unknown): unknown {
+  if (!isPlainRecord(review)) {
+    return review;
+  }
+  const migrated: Record<string, unknown> = { ...review };
+  if (isPlainRecord(review.comments)) {
+    migrated.comments = Object.fromEntries(
+      Object.entries(review.comments).map(([id, record]) => [
+        id,
+        migrateReviewRecordAnchor(record),
+      ]),
+    );
+  }
+  if (isPlainRecord(review.revisions)) {
+    migrated.revisions = Object.fromEntries(
+      Object.entries(review.revisions).map(([id, record]) => [
+        id,
+        migrateReviewRecordAnchor(record),
+      ]),
+    );
+  }
+  return migrated;
+}
+
+function migrateReviewRecordAnchor(record: unknown): unknown {
+  if (!isPlainRecord(record)) {
+    return record;
+  }
+  const anchor = record.anchor;
+  if (!isPlainRecord(anchor) || anchor.kind !== "range") {
+    return record;
+  }
+  if (typeof anchor.from === "number" && typeof anchor.to === "number") {
+    return record;
+  }
+  const nested = anchor.range;
+  if (
+    isPlainRecord(nested) &&
+    typeof nested.from === "number" &&
+    typeof nested.to === "number"
+  ) {
+    const { range: _range, ...rest } = anchor;
+    void _range;
+    return {
+      ...record,
+      anchor: {
+        ...rest,
+        from: nested.from,
+        to: nested.to,
+      },
+    };
+  }
+  return record;
+}
+
 export function serializeCanonicalDocument(document: CanonicalDocument): string {
   assertCanonicalDocument(document);
   return stableStringify(document);
@@ -3507,7 +3569,18 @@ function validateAnchor(
   }
 
   if (kind === "range") {
-    validateRange(record.range, `${path}.range`, issues);
+    if (typeof record.from !== "number") {
+      issues.push({
+        path: `${path}.from`,
+        message: "range anchor from must be a number.",
+      });
+    }
+    if (typeof record.to !== "number") {
+      issues.push({
+        path: `${path}.to`,
+        message: "range anchor to must be a number.",
+      });
+    }
     validateBoundaryAssoc(record.assoc, `${path}.assoc`, issues);
   } else if (kind === "node") {
     if (typeof record.at !== "number") {

package/src/preservation/store.ts

@@ -170,6 +170,15 @@ export function describeStructuredWrapperBlock(
       };
     }
     if (block.properties.sdtType === "docPartObj") {
+      // coord-02 §11 P0 — a Template content control that wraps a
+      // drawing_frame (CCEP header logos, cover hero photos) must stay
+      // recursable so surface-projection emits the inner image segment.
+      // Collapsing to opaque_block here silently drops every image
+      // inside a docPartObj SDT. Only collapse when the content is
+      // genuinely wrapper-heavy with no user-visible media.
+      if (sdtContainsDrawingFrame(block)) {
+        return null;
+      }
       return {
         featureKey: "content-controls",
         label: "Template content control",
@@ -220,6 +229,21 @@ function createDetail(fragment: OpaqueFragmentRecord): string {
     : "Preserved whole-unit to keep unsupported OOXML intact.";
 }
 
+function sdtContainsDrawingFrame(block: Extract<BlockNode, { type: "sdt" }>): boolean {
+  const visit = (node: unknown): boolean => {
+    if (!node || typeof node !== "object") return false;
+    const n = node as { type?: string; children?: readonly unknown[] };
+    if (n.type === "drawing_frame") return true;
+    if (Array.isArray(n.children)) {
+      for (const child of n.children) {
+        if (visit(child)) return true;
+      }
+    }
+    return false;
+  };
+  return block.children.some(visit);
+}
+
 function isTocContentControl(block: Extract<BlockNode, { type: "sdt" }>): boolean {
   const searchText = [
     block.properties.alias,

package/src/review/store/comment-anchors.ts

@@ -47,7 +47,7 @@ export function summarizeCommentAnchor(anchor: CommentAnchor): CommentAnchorSumm
     return {
       anchor,
       state: "active",
-      range: normalizeRange(anchor.range),
+      range: normalizeRange({ from: anchor.from, to: anchor.to }),
     };
   }
 

package/src/review/store/comment-remapping.ts

@@ -98,7 +98,7 @@ function normalizeCommentAnchor(
 
   if (
     mappedAnchor.kind === "range" &&
-    !rangeStaysWithinCommentableStory(nextContent, mappedAnchor.range)
+    !rangeStaysWithinCommentableStory(nextContent, { from: mappedAnchor.from, to: mappedAnchor.to })
   ) {
     return detachReviewAnchor(previousRange, "invalidatedByStructureChange");
   }

package/src/review/store/revision-actions.ts

@@ -153,8 +153,8 @@ export function applyRevisionAction(
 
   const story = parseTextStory(options.document.content);
   const range = normalizeRange(
-    revision.anchor.range.from,
-    revision.anchor.range.to,
+    revision.anchor.from,
+    revision.anchor.to,
   );
 
   if (range.to > story.size) {
@@ -811,8 +811,8 @@ function resolveParagraphMarkDeletionRange(
 
   const paragraphs = mapParagraphRanges(story);
   const anchorPosition = normalizeRange(
-    revision.anchor.range.from,
-    revision.anchor.range.to,
+    revision.anchor.from,
+    revision.anchor.to,
   ).from;
   const paragraph = paragraphs.find(
     (candidate) =>

package/src/review/store/revision-types.ts

@@ -77,7 +77,7 @@ export function summarizeRevisionAnchor(anchor: RevisionAnchor): RevisionAnchorS
     return {
       anchor,
       state: "active",
-      range: normalizeRange(anchor.range),
+      range: normalizeRange({ from: anchor.from, to: anchor.to }),
     };
   }
 

package/src/review/store/scope-tag-diff.ts

@@ -96,7 +96,7 @@ export function collectScopeTagTouches(
 
 function anchorRange(anchor: CanonicalAnchor): { from: number; to: number } {
   if (anchor.kind === "range") {
-    return { from: anchor.range.from, to: anchor.range.to };
+    return { from: anchor.from, to: anchor.to };
   }
   if (anchor.kind === "node") {
     return { from: anchor.at, to: anchor.at };

package/src/runtime/collab/map-local-selection-on-remote-replay.ts

@@ -88,10 +88,10 @@ export function mapLocalSelectionOnRemoteReplay(
 
   if (active.kind === "range") {
     const directionForward = selection.anchor <= selection.head;
-    const isCollapsed = active.range.from === active.range.to;
+    const isCollapsed = active.from === active.to;
 
     if (isCollapsed) {
-      const collapsedAt = mapPosition(active.range.from, 1, mapping).position;
+      const collapsedAt = mapPosition(active.from, 1, mapping).position;
       return {
         anchor: collapsedAt,
         head: collapsedAt,
@@ -107,7 +107,7 @@ export function mapLocalSelectionOnRemoteReplay(
     const mapped = mapAnchor(active, mapping);
 
     if (mapped.kind === "range") {
-      const { from, to } = mapped.range;
+      const { from, to } = mapped;
       return {
         anchor: directionForward ? from : to,
         head: directionForward ? to : from,
@@ -122,7 +122,7 @@ export function mapLocalSelectionOnRemoteReplay(
     // positions that land inside a deleted span to `step.from +
     // insertSize`, which is the correct logical "where the selection
     // used to start" position.
-    const collapsedAt = mapPosition(active.range.from, 1, mapping).position;
+    const collapsedAt = mapPosition(active.from, 1, mapping).position;
     return {
       anchor: collapsedAt,
       head: collapsedAt,
@@ -147,9 +147,9 @@ export function mapLocalSelectionOnRemoteReplay(
     }
     if (mapped.kind === "range") {
       return {
-        anchor: mapped.range.from,
-        head: mapped.range.to,
-        isCollapsed: mapped.range.from === mapped.range.to,
+        anchor: mapped.from,
+        head: mapped.to,
+        isCollapsed: mapped.from === mapped.to,
         activeRange: mapped,
       };
     }