@beyondwork/docx-react-component 1.0.73 → 1.0.74

package/src/core/commands/index.ts

@@ -1525,9 +1525,9 @@ export function remapSelection(
 
   if (activeRange.kind === "range") {
     return {
-      anchor: activeRange.range.from,
-      head: activeRange.range.to,
-      isCollapsed: activeRange.range.from === activeRange.range.to,
+      anchor: activeRange.from,
+      head: activeRange.to,
+      isCollapsed: activeRange.from === activeRange.to,
       activeRange,
     };
   }
@@ -1664,8 +1664,8 @@ function normalizeSelection(selection: SelectionSnapshot): SelectionSnapshot {
   );
 
   if (activeRange.kind === "range") {
-    const rangeFrom = activeRange.range.from;
-    const rangeTo = activeRange.range.to;
+    const rangeFrom = activeRange.from;
+    const rangeTo = activeRange.to;
     const collapsed = rangeFrom === rangeTo;
     const anchorWithinRange = selection.anchor >= rangeFrom && selection.anchor <= rangeTo;
     const headWithinRange = selection.head >= rangeFrom && selection.head <= rangeTo;
@@ -2256,7 +2256,8 @@ function createAuthoredRevision(
     kind,
     anchor: {
       kind: "range",
-      range: { from, to },
+      from,
+      to,
       assoc: { start: 1, end: -1 },
     },
     authorId,
@@ -2396,8 +2397,7 @@ function applySuggestingInsert(
       const updatedRevision: CanonicalRevisionRecord = {
         ...existingInsertion,
         anchor: {
-          kind: "range",
-          range: { from: existingInsertion.anchor.range.from, to: insertedTo },
+          kind: "range", from: existingInsertion.anchor.from, to: insertedTo,
           assoc: { start: 1, end: -1 },
         },
       };
@@ -2635,19 +2635,18 @@ function applySuggestingDelete(
   if (existingDeletion) {
     // Extend the existing deletion revision to cover the new range
     const extendedFrom = Math.min(
-      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.from : deleteFrom,
+      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.from : deleteFrom,
       deleteFrom,
     );
     const extendedTo = Math.max(
-      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.to : deleteTo,
+      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.to : deleteTo,
       deleteTo,
     );
 
     const updatedRevision: CanonicalRevisionRecord = {
       ...existingDeletion,
       anchor: {
-        kind: "range",
-        range: { from: extendedFrom, to: extendedTo },
+        kind: "range", from: extendedFrom, to: extendedTo,
         assoc: { start: 1, end: -1 },
       },
     };
@@ -2933,7 +2932,7 @@ function findAdjacentInsertionRevision(
       revision.status === "open" &&
       revision.metadata?.source === "runtime" &&
       revision.anchor.kind === "range" &&
-      revision.anchor.range.to === cursorPos &&
+      revision.anchor.to === cursorPos &&
       revision.authorId === authorId
     ) {
       return revision;
@@ -2954,8 +2953,8 @@ function findOverlappingAuthoredDeletion(
       revision.metadata?.source === "runtime" &&
       revision.anchor.kind === "range"
     ) {
-      const revFrom = revision.anchor.range.from;
-      const revTo = revision.anchor.range.to;
+      const revFrom = revision.anchor.from;
+      const revTo = revision.anchor.to;
       // Adjacent or overlapping: the deletion is directly next to or overlapping the range
       if (
         (from >= revFrom && from <= revTo) ||

package/src/core/selection/anchor-conversion.ts

@@ -79,8 +79,8 @@ export function toPublicAnchorProjection(
     case "range":
       return {
         kind: "range",
-        from: anchor.range.from,
-        to: anchor.range.to,
+        from: anchor.from,
+        to: anchor.to,
         assoc: anchor.assoc,
       };
     case "node":

package/src/core/selection/mapping.ts

@@ -66,9 +66,11 @@ export function createRangeAnchor(
   to = from,
   assoc: BoundaryAssoc = DEFAULT_BOUNDARY_ASSOC,
 ): RangeAnchor {
+  const normalized = normalizeRange({ from, to });
   return {
     kind: "range",
-    range: normalizeRange({ from, to }),
+    from: normalized.from,
+    to: normalized.to,
     assoc,
   };
 }
@@ -89,7 +91,7 @@ export function createEmptyMapping(): TransactionMapping {
 
 export function getEffectiveRange(anchor: EditorAnchorProjection): DocRange {
   if (anchor.kind === "range") {
-    return anchor.range;
+    return { from: anchor.from, to: anchor.to };
   }
   if (anchor.kind === "node") {
     return { from: anchor.at, to: anchor.at };
@@ -140,13 +142,13 @@ export function mapAnchor(
     return createNodeAnchor(mapped.position, anchor.assoc);
   }
 
-  const from = mapPosition(anchor.range.from, anchor.assoc.start, mapping);
-  const to = mapPosition(anchor.range.to, anchor.assoc.end, mapping);
+  const from = mapPosition(anchor.from, anchor.assoc.start, mapping);
+  const to = mapPosition(anchor.to, anchor.assoc.end, mapping);
   const mappedRange = normalizeRange({ from: from.position, to: to.position });
 
   if (from.deleted && to.deleted && mappedRange.from === mappedRange.to) {
     return createDetachedAnchor(
-      anchor.range,
+      { from: anchor.from, to: anchor.to },
       mapping.metadata?.invalidatesStructures
         ? "invalidatedByStructureChange"
         : "deleted",
@@ -187,8 +189,8 @@ export function areAnchorsEqual(
 
   if (left.kind === "range" && right.kind === "range") {
     return (
-      left.range.from === right.range.from &&
-      left.range.to === right.range.to &&
+      left.from === right.from &&
+      left.to === right.to &&
       left.assoc.start === right.assoc.start &&
       left.assoc.end === right.assoc.end
     );
@@ -213,7 +215,7 @@ export function anchorUnaffectedByMapping(
 ): boolean {
   if (anchor.kind === "detached") return true;
   if (mapping.steps.length === 0) return true;
-  const end = anchor.kind === "range" ? anchor.range.to : anchor.at;
+  const end = anchor.kind === "range" ? anchor.to : anchor.at;
   return mapping.steps.every((s) => s.from > end);
 }
 

package/src/core/selection/review-anchors.ts

@@ -40,7 +40,7 @@ export function mapReviewAnchor(
 
 export function getAnchorRange(anchor: ReviewAnchor): DocRange {
   if (anchor.kind === "range") {
-    return normalizeRange(anchor.range);
+    return normalizeRange({ from: anchor.from, to: anchor.to });
   }
 
   if (anchor.kind === "node") {
@@ -136,7 +136,7 @@ export function commentAnchorRejectionReason(
     return "invalid_comment_anchor";
   }
 
-  const normalized = normalizeRange(anchor.range);
+  const normalized = normalizeRange({ from: anchor.from, to: anchor.to });
   if (normalized.from === normalized.to) {
     return "invalid_comment_anchor";
   }
@@ -164,7 +164,7 @@ export function snapCommentAnchorAwayFromTable(
 ): ReviewAnchor | null {
   if (anchor.kind !== "range") return null;
 
-  const normalized = normalizeRange(anchor.range);
+  const normalized = normalizeRange({ from: anchor.from, to: anchor.to });
   if (normalized.from === normalized.to) return null;
 
   // If the anchor is already flagged invalid for other reasons (crosses an

package/src/io/export/export-session.ts

@@ -119,6 +119,7 @@ export class ExportSession {
       this.packageRelationships,
       this.ownedPaths,
     );
+    ensurePicNamespaceOnStoryParts(this.workingParts);
     const parts = pruneReservedManifestParts(this.workingParts);
     const manifest = buildManifest(parts, this.packageRelationships, this.sourcePackage.manifest.contentTypes);
     return {
@@ -140,6 +141,58 @@ export function createExportSession(
   return new ExportSession(sourcePackage, ownedOutputPaths);
 }
 
+/**
+ * LibreOffice strict-parser safety net. Word tolerates `pic:` prefix
+ * usage (from `<pic:pic>` / `<pic:spPr>` inside drawings) without
+ * declaring `xmlns:pic` at the part root, because it inherits scope
+ * from `<wp:inline xmlns:pic=…>` wrappers or from `mc:AlternateContent`
+ * fallbacks. LibreOffice refuses the file ("Namespace prefix pic on
+ * spPr is not defined"). Our own serializers already inject
+ * `xmlns:pic` on freshly serialized parts — but parts that pass
+ * through unmodified from the source package keep the original
+ * declaration (which may be missing it). This sweep runs at toPackage
+ * time over the main story + every header / footer part, and injects
+ * `xmlns:pic` on the root element when the part uses the `pic:` prefix
+ * but doesn't declare it. Byte-stable for parts already correct.
+ *
+ * See commit a3e05a8e (serializer-side fix) + this (pass-through fix).
+ */
+const PIC_NAMESPACE_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+const PIC_NAMESPACE_DECL = ` xmlns:pic="${PIC_NAMESPACE_URI}"`;
+
+function ensurePicNamespaceOnStoryParts(
+  parts: Map<string, OpcPackagePart>,
+): void {
+  for (const [path, part] of parts.entries()) {
+    if (!isPicSensitiveStoryPath(path)) continue;
+    const patched = ensurePicNamespaceOnRoot(part.bytes);
+    if (patched !== part.bytes) {
+      parts.set(path, { ...part, bytes: patched, crc32: 0 });
+    }
+  }
+}
+
+function isPicSensitiveStoryPath(path: string): boolean {
+  // Normalize for leading slash variation.
+  const normalized = path.startsWith("/") ? path.slice(1) : path;
+  if (normalized === "word/document.xml") return true;
+  if (/^word\/(?:header|footer|footnotes|endnotes)[^/]*\.xml$/.test(normalized)) return true;
+  return false;
+}
+
+function ensurePicNamespaceOnRoot(bytes: Uint8Array): Uint8Array {
+  const xml = new TextDecoder().decode(bytes);
+  // Match the first element (skipping the XML prolog + whitespace).
+  const rootMatch = xml.match(/^([\s\S]*?)<([A-Za-z][\w.:-]*)([^>]*)>/);
+  if (!rootMatch) return bytes;
+  const [fullMatch, prefix, tagName, rootAttrs] = rootMatch;
+  if (rootAttrs.includes("xmlns:pic=")) return bytes; // already declared
+  if (!/\bpic:[A-Za-z]/.test(xml)) return bytes; // doesn't use pic: prefix
+  const patchedRoot = `<${tagName}${rootAttrs}${PIC_NAMESPACE_DECL}>`;
+  const patched = `${prefix}${patchedRoot}${xml.slice(fullMatch.length)}`;
+  return new TextEncoder().encode(patched);
+}
+
 function clonePartsForExport(
   parts: Map<string, OpcPackagePart>,
   ownedPaths: ReadonlySet<string>,

package/src/io/export/serialize-comments.ts

@@ -269,16 +269,16 @@ export function serializeCommentAnchorsIntoDocumentXml(
       continue;
     }
 
-    const startParagraph = findParagraphForEndpoint(paragraphs, anchor.range.from, "start");
-    const endParagraph = findParagraphForEndpoint(paragraphs, anchor.range.to, "end");
+    const startParagraph = findParagraphForEndpoint(paragraphs, anchor.from, "start");
+    const endParagraph = findParagraphForEndpoint(paragraphs, anchor.to, "end");
 
     if (!startParagraph || !endParagraph) {
       skippedCommentIds.push(thread.commentId);
       continue;
     }
 
-    const startIndex = startParagraph.boundaries.get(anchor.range.from);
-    const endIndex = endParagraph.boundaries.get(anchor.range.to);
+    const startIndex = startParagraph.boundaries.get(anchor.from);
+    const endIndex = endParagraph.boundaries.get(anchor.to);
 
     if (startIndex === undefined || endIndex === undefined) {
       skippedCommentIds.push(thread.commentId);

package/src/io/export/serialize-runtime-revisions.ts

@@ -135,8 +135,8 @@ function createParagraphPropertyChangeReplacement(
   }
   const paragraphBoundary = findParagraphBoundaryForRange(
     boundaries,
-    revision.anchor.range.from,
-    revision.anchor.range.to,
+    revision.anchor.from,
+    revision.anchor.to,
   );
   if (!paragraphBoundary) {
     return undefined;
@@ -168,14 +168,14 @@ function createRunPropertyChangeReplacement(
   }
   const paragraphBoundary = findParagraphBoundaryForRange(
     boundaries,
-    revision.anchor.range.from,
-    revision.anchor.range.to,
+    revision.anchor.from,
+    revision.anchor.to,
   );
   if (!paragraphBoundary) {
     return undefined;
   }
-  const startIndex = paragraphBoundary.boundaries.get(revision.anchor.range.from);
-  const endIndex = paragraphBoundary.boundaries.get(revision.anchor.range.to);
+  const startIndex = paragraphBoundary.boundaries.get(revision.anchor.from);
+  const endIndex = paragraphBoundary.boundaries.get(revision.anchor.to);
   if (startIndex === undefined || endIndex === undefined || endIndex < startIndex) {
     return undefined;
   }
@@ -245,13 +245,13 @@ function createRangeRevisionReplacement(
   if (anchor.kind !== "range") {
     return undefined;
   }
-  const paragraphBoundary = findParagraphBoundaryForRange(boundaries, anchor.range.from, anchor.range.to);
+  const paragraphBoundary = findParagraphBoundaryForRange(boundaries, anchor.from, anchor.to);
   if (!paragraphBoundary) {
     return undefined;
   }
 
-  const startIndex = paragraphBoundary.boundaries.get(anchor.range.from);
-  const endIndex = paragraphBoundary.boundaries.get(anchor.range.to);
+  const startIndex = paragraphBoundary.boundaries.get(anchor.from);
+  const endIndex = paragraphBoundary.boundaries.get(anchor.to);
   if (startIndex === undefined || endIndex === undefined || endIndex < startIndex) {
     return undefined;
   }
@@ -340,7 +340,7 @@ function findParagraphBoundaryForAnchor(
   boundaries: readonly RevisionParagraphBoundary[],
   revision: RevisionRecord,
 ): RevisionParagraphBoundary | undefined {
-  const anchor = revision.anchor.kind === "range" ? revision.anchor.range.from : undefined;
+  const anchor = revision.anchor.kind === "range" ? revision.anchor.from : undefined;
   if (anchor === undefined) {
     return undefined;
   }

package/src/io/export/split-review-boundaries.ts

@@ -35,8 +35,8 @@ function collectSplitPositions(
       continue;
     }
 
-    positions.add(thread.anchor.range.from);
-    positions.add(thread.anchor.range.to);
+    positions.add(thread.anchor.from);
+    positions.add(thread.anchor.to);
   }
 
   for (const revision of revisions) {
@@ -51,8 +51,8 @@ function collectSplitPositions(
       continue;
     }
 
-    positions.add(revision.anchor.range.from);
-    positions.add(revision.anchor.range.to);
+    positions.add(revision.anchor.from);
+    positions.add(revision.anchor.to);
   }
 
   return positions;

package/src/io/export/split-story-blocks-for-runtime-revisions.ts

@@ -200,8 +200,8 @@ function collectSplitPoints(
 ): number[] {
   const points = new Set<number>();
   for (const revision of revisions) {
-    const from = revision.anchor.range.from;
-    const to = revision.anchor.range.to;
+    const from = revision.anchor.from;
+    const to = revision.anchor.to;
     if (from > start && from < end) {
       points.add(from);
     }

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/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,
       };
     }