@superdoc/mcp 1.6.0-next.17 → 1.6.0-next.19

package/dist/index.js

@@ -31600,7 +31600,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.19.0-next.17";
+var SDK_VERSION = "2.19.0-next.19";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -103230,12 +103230,19 @@ function normalizeMutationOptions(options, supportCheckOperation) {
     }
   }
   const offsetSpace = options?.offsetSpace;
+  const tableCellSelection = options?.tableCellSelection;
   return {
     expectedRevision: options?.expectedRevision,
     changeMode: options?.changeMode ?? "direct",
     dryRun: options?.dryRun ?? false,
     ...supportCheck ? { supportCheck } : {},
-    ...offsetSpace === "selection" || offsetSpace === "kernel" ? { offsetSpace } : {}
+    ...offsetSpace === "selection" || offsetSpace === "kernel" ? { offsetSpace } : {},
+    ...typeof tableCellSelection?.anchorBlockId === "string" && typeof tableCellSelection?.focusBlockId === "string" ? {
+      tableCellSelection: {
+        anchorBlockId: tableCellSelection.anchorBlockId,
+        focusBlockId: tableCellSelection.focusBlockId
+      }
+    } : {}
   };
 }
 function validateSupportCheckGuard(value, operation) {
@@ -195388,7 +195395,7 @@ function isBreakRunToken(token) {
 }
 function compileOverlapEdit(input) {
   const paragraphInlineMap = input.paragraphInlineMap ?? parseParagraphInlineMap(input.paragraphXml, input.namespaceBindings);
-  const consecutiveBreakInsertion = tryConsecutiveManualBreakInsertion(input, paragraphInlineMap);
+  const consecutiveBreakInsertion = input.newTextRunsXml === undefined ? tryConsecutiveManualBreakInsertion(input, paragraphInlineMap) : null;
   if (consecutiveBreakInsertion)
     return consecutiveBreakInsertion;
   const readsComplexDeletionForCollapsedInsert = input.newText.length > 0 && input.rangeStart === input.rangeEnd && ((input.coordinateSpace ?? "visible") === "visible" || input.changeMode === "tracked");
@@ -195483,6 +195490,12 @@ function compileParsedOverlapEdit(input, tokens, descendedEditableContainers) {
   if (touched.length === 0 && touchedBreaks.length === 0) {
     return { ok: false, reason: "invalid-range", detail: "overlap compiler: no tokens touched by the range." };
   }
+  if (input.newTextRunsXml !== undefined) {
+    const parent = touched.length === 1 ? touched[0].token : null;
+    if (input.changeMode !== "tracked" || input.rangeStart !== input.rangeEnd || !input.newText.length || parent?.kind !== "ins" || input.rangeStart <= parent.visibleStart || input.rangeStart >= parent.visibleEnd || parent.nestedDeletions?.length || parent.commentedBoundary || descendedEditableContainers.length || !parent.sourceIdentity.rsid && !parent.sourceIdentity.wId) {
+      return { ok: false, reason: "text-range-in-unsupported-tracked-wrapper" };
+    }
+  }
   if (touchedBreaks.length > 0) {
     const withBreaks = tryPureDeleteAcrossTokens(input, tokens, touched, touchedBreaks);
     if (withBreaks)
@@ -196587,7 +196600,10 @@ function foldInsideOwnInsertion(input, allTokens, parent) {
     return result2.ok && input.changeMode === "direct" ? { ...result2, requiresCollaborationSessionSync: true } : result2;
   }
   let innerXml = null;
-  if (nestedDeletions.length > 0) {
+  if (input.newTextRunsXml !== undefined) {
+    const runs = parent.innerRuns ?? [parent.inner];
+    innerXml = buildInsInnerXmlFromRuns(sliceWrappedRuns(runs, 0, localStart)) + input.newTextRunsXml + buildInsInnerXmlFromRuns(sliceWrappedRuns(runs, localEnd, text.length));
+  } else if (nestedDeletions.length > 0) {
     const runs = spliceInnerRuns(parent.innerRuns ?? [parent.inner], localStart, localEnd, input.newText, parent, localStart);
     const delta = input.newText.length - (localEnd - localStart);
     const preservedDeletions = nestedDeletions.map((entry) => {
@@ -196988,7 +197004,8 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
         runClose: insertMeta.runClose,
         rPr: insertRPr,
         text: input.newText
-      }
+      },
+      ...input.newTextRunsXml !== undefined ? { innerXml: input.newTextRunsXml } : {}
     });
     const closed = closeFreshInsertionScope(childInsXml, Object.fromEntries(parent.namespaceBindings), input.namespaceBindings ?? {});
     if (closed == null)
@@ -221707,7 +221724,12 @@ function planDirectParagraphRangeRewrite(input) {
   if (!bytes || end.partUri !== start.partUri)
     return { ok: false, reason: "unsupported-context" };
   const partXml = TD56.decode(bytes);
-  const cascadingComments = expandCommentThreadWIds(state, collectCommentsTouchedByByteRange(partXml, input.selectionStartByte, input.selectionEndByte));
+  const commentMarkers = collectBodyCommentMarkers(partXml);
+  const touchedComments = collectCommentsTouchedByByteRange(commentMarkers, input.selectionStartByte, input.selectionEndByte);
+  const retainedStarts = retainedCommentStarts(input, bytes, commentMarkers, touchedComments);
+  for (const marker of retainedStarts)
+    touchedComments.delete(marker.id);
+  const cascadingComments = expandCommentThreadWIds(state, touchedComments);
   const startXml = decodeByteRange2(bytes, start.byteStart, start.byteEnd);
   const endXml = decodeByteRange2(bytes, end.byteStart, end.byteEnd);
   const beforeWindowXml = decodeByteRange2(bytes, start.byteStart, end.byteEnd);
@@ -221741,7 +221763,13 @@ function planDirectParagraphRangeRewrite(input) {
     });
     if (!endSlice.ok)
       return endSlice;
-    const collapsed = sectionCollapse ? sectionCollapse.render(startSlice.head, endSlice.tail) : renderCollapsedParagraph(startXml, startSlice.head, endSlice.tail);
+    let movedStarts = "";
+    if (retainedStarts.length > 0) {
+      const destinationNamespaces = namespaceBindingsAtPosition(bytes, start.byteStart, matchParagraphOpenTag(startXml) ?? "");
+      const retainedHeadStarts = collectBodyCommentMarkers(startSlice.head, destinationNamespaces).filter((marker) => marker.kind === "commentRangeStart").map((marker) => marker.id);
+      movedStarts = retainedStarts.filter((marker) => !retainedHeadStarts.includes(marker.id)).map((marker) => commentMarkerWithNamespaces(bytes, marker, destinationNamespaces)).join("");
+    }
+    const collapsed = sectionCollapse ? sectionCollapse.render(startSlice.head + movedStarts, endSlice.tail) : renderCollapsedParagraph(startXml, startSlice.head + movedStarts, endSlice.tail);
     if (!collapsed)
       return { ok: false, reason: "invalid-range" };
     collapsedXml = collapsed;
@@ -223555,14 +223583,42 @@ function collectCascadingComments(paraXml, resolveNamespaceBindings) {
     return new Set;
   return new Set(collectBodyCommentMarkers(paraXml, resolveNamespaceBindings()).map((marker) => marker.id));
 }
-function collectCommentsTouchedByByteRange(xml, startByte, endByte) {
+function collectCommentsTouchedByByteRange(markers, startByte, endByte) {
   const touched = new Set;
-  for (const marker of collectBodyCommentMarkers(xml)) {
+  for (const marker of markers) {
     if (marker.range.byteStart < endByte && marker.range.byteEnd > startByte)
       touched.add(marker.id);
   }
   return touched;
 }
+function retainedCommentStarts(input, bytes, markers, touched) {
+  if (input.fullBlockReplacementXml !== undefined)
+    return [];
+  return markers.filter((marker) => {
+    if (marker.kind !== "commentRangeStart" || !touched.has(marker.id))
+      return false;
+    const anchors = markers.filter((candidate2) => candidate2.id === marker.id);
+    const end = anchors.find((candidate2) => candidate2.kind === "commentRangeEnd");
+    const reference = anchors.find((candidate2) => candidate2.kind === "commentReference");
+    if (anchors.length !== 3 || !end || !reference || marker.range.byteStart < input.selectionStartByte || marker.range.byteEnd > input.selectionEndByte || end.range.byteStart < input.selectionEndByte || reference.range.byteStart < end.range.byteEnd)
+      return false;
+    const endEntry = input.indexEntries.find((entry) => end.range.byteStart >= entry.byteStart && end.range.byteStart < entry.byteEnd);
+    if (!endEntry || endEntry.ordinal < input.end.ordinal)
+      return false;
+    const endXml = decodeByteRange2(bytes, endEntry.byteStart, endEntry.byteEnd);
+    const model = parseParagraphInlineMap(endXml, end.paragraph?.namespaceBindings);
+    const endMarkerOffset = resolveParagraphVisibleOffsetAtByte(model, end.range.byteStart - endEntry.byteStart);
+    const remainingChars = endEntry.ordinal === input.end.ordinal ? endMarkerOffset - input.endOffset : input.end.textLength - input.endOffset + endMarkerOffset + input.indexEntries.filter((entry) => entry.ordinal > input.end.ordinal && entry.ordinal < endEntry.ordinal).reduce((sum, entry) => sum + entry.textLength, 0);
+    return remainingChars > 0;
+  });
+}
+function commentMarkerWithNamespaces(bytes, marker, destinationNamespaces) {
+  const xml = decodeByteRange2(bytes, marker.range.byteStart, marker.range.byteEnd);
+  const openTag = xml.match(/^<(?:"[^"]*"|'[^']*'|[^>"'])*>/)?.[0] ?? "";
+  const localNamespaces = namespaceBindingsAtPosition(TE25.encode(xml), 0, openTag);
+  const declarations = Object.entries(namespaceBindingsAtPosition(bytes, marker.range.byteStart)).filter(([prefix, uri]) => localNamespaces[prefix] === undefined && destinationNamespaces[prefix] !== uri).map(([prefix, uri]) => ` xmlns${prefix ? `:${prefix}` : ""}="${escapeXmlAttribute(uri)}"`).join("");
+  return xml.replace(/^<[\w.-]+(?::[\w.-]+)?\b/, (tag) => tag + declarations);
+}
 function stripCommentAnchorsFromXml(xml, commentIds, resolveNamespaceBindings) {
   const bytes = TE25.encode(xml);
   if (commentIds.size === 0)
@@ -238014,6 +238070,50 @@ var init_types6 = __esm(() => {
 });
 
 // ../../../v2/editor-core/dist/document/transactions/compile-paste-splice.js
+function planTrackedInsertionSplice(input) {
+  const block = input.blocks.length === 1 ? input.blocks[0] : null;
+  const stamp = input.trackedStamp;
+  if (!stamp || input.wrapAllTracked === false || input.collapsedObjectBoundary || (input.replaceToOffset ?? input.charOffset) !== input.charOffset || block?.kind !== "paragraph" || block.styleRef || block.numbering || block.listIntent || block.paragraphProps || block.pPrXml || block.blockSdts?.length || block.complete)
+    return null;
+  const runs = input.inlineSpecs?.get(block) ?? block.runs.map(toPasteTextRunSpec);
+  if (runs.some((run) => run.kind !== undefined && run.kind !== "text" || ("commentIds" in run) && run.commentIds?.length || ("trackedInsertion" in run) && run.trackedInsertion))
+    return null;
+  const newText = runs.map((run) => ("text" in run) ? run.text : "").join("");
+  if (!newText)
+    return null;
+  const envelope = parseParagraphEnvelope(input.anchorXml);
+  if (!envelope)
+    return null;
+  const newTextRunsXml = renderPasteRuns(runs).replace(/<w:r(?=[\s>])/g, '<w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"');
+  const overlap = compileOverlapEdit({
+    storyId: input.storyId,
+    paragraphXml: input.anchorXml,
+    namespaceBindings: namespaceBindingsAtPosition(input.partBytes, input.paragraphStartByte, envelope.open),
+    rangeStart: input.charOffset,
+    rangeEnd: input.charOffset,
+    newText,
+    newTextRunsXml,
+    changeMode: "tracked",
+    currentAuthor: stamp.author,
+    txTimestamp: stamp.date,
+    rsid: stamp.rsid,
+    insRsid: stamp.rsid,
+    nextWId: () => stamp.allocateWId(),
+    reserveWId: () => stamp.allocateWId()
+  });
+  if (!overlap.ok)
+    return { ok: false, reason: overlap.reason };
+  return {
+    ok: true,
+    xml: overlap.xml,
+    createdParaIds: [],
+    destinationParaIdsByBlock: [[input.anchorParaId ?? ""]],
+    insertedVisibleChars: newText.length,
+    removedVisibleChars: 0,
+    anchorParagraphUnchanged: false,
+    trackedChangeRsids: { created: overlap.emittedRsids, updated: overlap.updatedRsids ?? [] }
+  };
+}
 function planParagraphSplice(input) {
   const start = input.charOffset;
   const end = input.replaceToOffset ?? input.charOffset;
@@ -238341,6 +238441,7 @@ function withTrackedRsid(openTag, rsid) {
 var init_compile_paste_splice = __esm(() => {
   init_paragraph_inline_model();
   init_xml_text();
+  init_overlap_edit_compiler();
   init_paragraph_contribution();
   init_paragraph_para_id_attrs();
 });
@@ -242680,7 +242781,7 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
         return deleted;
       rewrittenXml = deleted.xml;
     }
-    return planParagraphSplice({
+    const spliceInput = {
       anchorXml: rewrittenXml,
       anchorParaId: anchor.entry.blockId,
       blocks: resolvedBlocks,
@@ -242695,7 +242796,12 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
       ...stamp ? { trackedStamp: stamp, wrapAllTracked } : {},
       ...listExtras.commentIdMap ? { commentIdMap: listExtras.commentIdMap } : {},
       ...listExtras.noteIdMap ? { noteIdMap: listExtras.noteIdMap } : {}
-    });
+    };
+    const ordinary = planParagraphSplice(spliceInput);
+    if (!ordinary.ok && ordinary.reason === "paste-target-unsupported" && wrapAllTracked && (target.replaceToOffset ?? target.charOffset) === target.charOffset) {
+      return planTrackedInsertionSplice({ ...spliceInput, storyId: target.storyId }) ?? ordinary;
+    }
+    return ordinary;
   };
   const plan = planForParagraph(anchorXml, trackedStamp, () => mintParaId(state, state.packageRevision, anchor.ordinal + 1 + (mintSalt += 1)));
   if (!plan.ok)
@@ -242767,8 +242873,9 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
     nodeId: paraId,
     storyId: target.storyId
   }));
-  if (trackedStamp) {
-    createdRefs.push({ kind: "trackedChange", entityId: trackedStamp.rsid, storyId: target.storyId });
+  const createdTrackedRsids = plan.trackedChangeRsids?.created ?? (trackedStamp ? [trackedStamp.rsid] : []);
+  for (const entityId of createdTrackedRsids) {
+    createdRefs.push({ kind: "trackedChange", entityId, storyId: target.storyId });
   }
   if (listExtras.createdRefs)
     createdRefs.push(...listExtras.createdRefs);
@@ -242780,7 +242887,14 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
     textRangeShifts,
     createdParaIds: [...plan.createdParaIds],
     createdRefs,
-    updatedRefs: [{ kind: "block", nodeId: target.paraId, storyId: target.storyId }],
+    updatedRefs: [
+      { kind: "block", nodeId: target.paraId, storyId: target.storyId },
+      ...(plan.trackedChangeRsids?.updated ?? []).map((entityId) => ({
+        kind: "trackedChange",
+        entityId,
+        storyId: target.storyId
+      }))
+    ],
     relativeToBlockId: target.paraId,
     provisionalToFinal: buildPasteProvisionalMappings(txId, plan.createdParaIds, resolvedBlocks, plan.destinationParaIdsByBlock),
     extraPatchMaps: listExtras.patchMaps,
@@ -330619,6 +330733,731 @@ var init_review_read_model = __esm(() => {
   init_comparison_hunk_groups();
 });
 
+// ../../../v2/document-api-v2-adapter/dist/core/text-coordinate-space.js
+function projectVisibleOffsetToTracked(map3, offset, bias) {
+  if (!Number.isInteger(offset) || offset < 0 || offset > map3.visibleLength)
+    return null;
+  const candidates = new Set;
+  if (offset === 0)
+    candidates.add(0);
+  if (offset === map3.visibleLength)
+    candidates.add(map3.trackedLength);
+  for (const piece of map3.leaves()) {
+    const visibleWidth2 = piece.visibleEnd - piece.visibleStart;
+    const trackedWidth2 = piece.trackedEnd - piece.trackedStart;
+    if (visibleWidth2 > 0 && trackedWidth2 === visibleWidth2) {
+      if (offset >= piece.visibleStart && offset <= piece.visibleEnd) {
+        candidates.add(piece.trackedStart + offset - piece.visibleStart);
+      }
+      continue;
+    }
+    if (offset === piece.visibleStart)
+      candidates.add(piece.trackedStart);
+    if (offset === piece.visibleEnd)
+      candidates.add(piece.trackedEnd);
+  }
+  if (candidates.size === 0)
+    return null;
+  const values2 = [...candidates];
+  return bias === "upstream" ? Math.min(...values2) : Math.max(...values2);
+}
+function projectTrackedOffsetToVisible(map3, offset) {
+  if (!Number.isInteger(offset) || offset < 0 || offset > map3.trackedLength)
+    return null;
+  if (offset === map3.trackedLength)
+    return map3.visibleLength;
+  for (const piece of map3.leaves()) {
+    if (offset < piece.trackedStart || offset > piece.trackedEnd)
+      continue;
+    if (offset === piece.trackedStart)
+      return piece.visibleStart;
+    if (offset === piece.trackedEnd)
+      return piece.visibleEnd;
+    const trackedWidth2 = piece.trackedEnd - piece.trackedStart;
+    const visibleWidth2 = piece.visibleEnd - piece.visibleStart;
+    if (trackedWidth2 === 0 || visibleWidth2 === 0)
+      return piece.visibleStart;
+    if (trackedWidth2 !== visibleWidth2)
+      return null;
+    return piece.visibleStart + offset - piece.trackedStart;
+  }
+  return null;
+}
+function projectVisibleRangeToTracked(map3, start, end) {
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start)
+    return null;
+  if (start === end) {
+    const offset = projectVisibleOffsetToTracked(map3, start, "upstream");
+    return offset == null ? null : { start: offset, end: offset };
+  }
+  const trackedStart = projectVisibleOffsetToTracked(map3, start, "downstream");
+  const trackedEnd = projectVisibleOffsetToTracked(map3, end, "upstream");
+  if (trackedStart == null || trackedEnd == null || trackedEnd < trackedStart)
+    return null;
+  return { start: trackedStart, end: trackedEnd };
+}
+
+// ../../../v2/document-api-v2-adapter/dist/selection/footnote-range.js
+function resolveFootnoteRangeIndex(session, index2, start, end) {
+  if (start.story.storyType !== "footnote" || end.story.storyType !== "footnote")
+    return null;
+  const main = getSDDocumentSessionInternalSourceSignalsSnapshot(session)?.stories.find((story) => story.storyKind === "main");
+  const bytes = getSDDocumentSessionInternalPartBytes(session, FOOTNOTES_PART_URI3);
+  if (!main || main.completeness.noteAnchorRefs !== "complete" || !bytes)
+    return null;
+  const xml = new TextDecoder().decode(bytes);
+  const parsed = collectXmlElementRanges(xml);
+  if (parsed.errors.length)
+    return null;
+  const notes = parsed.ranges.filter(({ tag }) => tag.namespaceUri === W_NS6 && tag.localName === "footnote").sort((a, b) => a.start - b.start);
+  const sourceEntries = [...index2.entries].sort((a, b) => a.byteStart - b.byteStart);
+  const groups = new Map;
+  let charCursor = 0;
+  let byteCursor = bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? 3 : 0;
+  let entryCursor = 0;
+  for (const note of notes) {
+    const id = readXmlAttributes(note.tag, W_NS6, "id")[0]?.value;
+    if (!id || groups.has(id))
+      return null;
+    byteCursor += TE49.encode(xml.slice(charCursor, note.start)).byteLength;
+    const byteStart = byteCursor;
+    byteCursor += TE49.encode(xml.slice(note.start, note.end)).byteLength;
+    charCursor = note.end;
+    const group = [];
+    while (entryCursor < sourceEntries.length && sourceEntries[entryCursor].byteStart < byteCursor) {
+      const entry = sourceEntries[entryCursor++];
+      if (entry.byteStart >= byteStart && entry.byteEnd <= byteCursor)
+        group.push(entry);
+    }
+    groups.set(id, group);
+  }
+  const entries = [];
+  const seen = new Set;
+  let startOwned = false;
+  let endOwned = false;
+  const references = [...main.noteAnchorRefs].sort((a, b) => (a.bodyChildOrdinal ?? 0) - (b.bodyChildOrdinal ?? 0) || (a.sourceAnchor.stability === "byte-span" ? a.sourceAnchor.byteSpan[0] : 0) - (b.sourceAnchor.stability === "byte-span" ? b.sourceAnchor.byteSpan[0] : 0));
+  for (const ref5 of references) {
+    if (ref5.kind !== "footnote" || !ref5.nativeId || ref5.trackedChangeState === "deleted" || ref5.trackedChangeState === "move-from" || seen.has(ref5.nativeId))
+      continue;
+    seen.add(ref5.nativeId);
+    const group = groups.get(ref5.nativeId);
+    if (!group)
+      return null;
+    for (const entry of group) {
+      startOwned || (startOwned = ref5.nativeId === start.story.noteId && entry.blockId === start.blockId);
+      endOwned || (endOwned = ref5.nativeId === end.story.noteId && entry.blockId === end.blockId);
+      entries.push({ ...entry, ordinal: entries.length });
+    }
+  }
+  if (!startOwned || !endOwned)
+    return null;
+  const byBlockId = new Map(entries.map((entry) => [entry.blockId, entry]));
+  return {
+    entries,
+    duplicateParaIds: index2.duplicateParaIds,
+    entriesByBlockId: byBlockId,
+    byParaId: (blockId) => byBlockId.get(blockId) ?? null
+  };
+}
+var W_NS6 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", TE49;
+var init_footnote_range = __esm(() => {
+  init_sd_document_session_internal();
+  init_note_story();
+  TE49 = new TextEncoder;
+});
+
+// ../../../v2/document-api-v2-adapter/dist/selection/live-selection.js
+function distinctFootnotes(start, end) {
+  return start.storyType === "footnote" && end.storyType === "footnote" && start.noteId !== end.noteId;
+}
+function buildVisibleSelectionTarget(story, start, end) {
+  return {
+    kind: "selection",
+    start: { kind: "text", blockId: start.blockId, offset: start.offset, story: start.story ?? story },
+    end: { kind: "text", blockId: end.blockId, offset: end.offset, story: end.story ?? story },
+    ...distinctFootnotes(start.story ?? story, end.story ?? story) ? {} : { story }
+  };
+}
+function buildSelectionTarget(session, story, start, end, entries) {
+  const hasTrackedEndpoint = start.trackedOffset != null || end.trackedOffset != null;
+  if (!hasTrackedEndpoint)
+    return buildVisibleSelectionTarget(story, start, end);
+  const startEntry = entries[0];
+  const endEntry = entries[entries.length - 1];
+  if (!startEntry || !endEntry)
+    return null;
+  const startMap = readParagraphInlineMap(session, startEntry);
+  const endMap = startEntry === endEntry ? startMap : readParagraphInlineMap(session, endEntry);
+  if (!startMap || !endMap)
+    return null;
+  const resolvedStart = resolveTrackedSelectionEndpoint(startMap, start, "upstream");
+  const resolvedEnd = resolveTrackedSelectionEndpoint(endMap, end, "downstream");
+  if (resolvedStart == null || resolvedEnd == null) {
+    return null;
+  }
+  const [orderedStart2, orderedEnd] = start.blockId === end.blockId && resolvedEnd < resolvedStart ? [resolvedEnd, resolvedStart] : [resolvedStart, resolvedEnd];
+  return {
+    kind: "selection",
+    start: { kind: "text", blockId: start.blockId, offset: orderedStart2, story: start.story ?? story },
+    end: { kind: "text", blockId: end.blockId, offset: orderedEnd, story: end.story ?? story },
+    ...distinctFootnotes(start.story ?? story, end.story ?? story) ? {} : { story },
+    coordinateSpace: "tracked"
+  };
+}
+function readParagraphInlineMap(session, entry) {
+  const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
+  if (!bytes)
+    return null;
+  return parseParagraphInlineMap(TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
+}
+function resolveTrackedSelectionEndpoint(map3, point3, bias) {
+  if (point3.trackedOffset != null) {
+    return Number.isInteger(point3.trackedOffset) && point3.trackedOffset >= 0 && point3.trackedOffset <= map3.trackedLength ? point3.trackedOffset : null;
+  }
+  return projectVisibleOffsetToTracked(map3, clampOffset(point3.offset, map3.visibleLength), bias);
+}
+function resolveBrowserLiveSelectionParagraphIndex(session, story, startBlockId, endBlockId) {
+  const mainIndex = getSDDocumentSessionInternalParagraphIndex(session);
+  const stories = listSDDocumentSessionInternalStories(session);
+  if (!story || story.storyType === "body") {
+    return hasSelectionBlocks(mainIndex, startBlockId, endBlockId) ? mainIndex : null;
+  }
+  if (story.storyType === "headerFooterPart") {
+    const resolved = getSDDocumentSessionInternalHeaderFooterPartUriForRefId(session, story.refId);
+    if (!resolved)
+      return null;
+    const match = stories.find((candidate2) => candidate2.partUri === resolved.partUri);
+    if (!match)
+      return null;
+    return paragraphIndexForStory2(session, match.storyId, mainIndex);
+  }
+  const candidates = stories.filter((candidate2) => storyCandidateMatches(candidate2, story));
+  for (const candidate2 of candidates) {
+    const index2 = paragraphIndexForStory2(session, candidate2.storyId, mainIndex);
+    if (hasSelectionBlocks(index2, startBlockId, endBlockId))
+      return index2;
+  }
+  return null;
+}
+function paragraphIndexForStory2(session, storyId, mainIndex) {
+  if (mainIndex?.entries[0]?.storyId === storyId)
+    return mainIndex;
+  return getSDDocumentSessionInternalStoryParagraphIndex(session, storyId);
+}
+function storyCandidateMatches(candidate2, story) {
+  switch (story.storyType) {
+    case "headerFooterSlot":
+      return candidate2.storyKind === story.headerFooterKind;
+    case "footnote":
+      return candidate2.storyKind === "footnotes";
+    case "endnote":
+      return candidate2.storyKind === "endnotes";
+    case "textbox":
+      return candidate2.storyKind === "textbox" && candidate2.textboxId === story.textboxId;
+    default:
+      return false;
+  }
+}
+function hasSelectionBlocks(index2, startBlockId, endBlockId) {
+  return Boolean(index2?.byParaId(startBlockId) && index2.byParaId(endBlockId));
+}
+function clampOffset(offset, textLength) {
+  return Math.max(0, Math.min(textLength, offset));
+}
+function resolveTableCellSelectionEntries(session, story, anchorBlockId, focusBlockId) {
+  const index2 = resolveBrowserLiveSelectionParagraphIndex(session, story, anchorBlockId, focusBlockId);
+  const anchorEntry = index2?.byParaId(anchorBlockId);
+  if (!index2 || !anchorEntry || index2.duplicateParaIds.has(anchorBlockId) || index2.duplicateParaIds.has(focusBlockId))
+    return null;
+  const catalog = readTableCatalogForSession(session, anchorEntry.storyId);
+  const anchor = catalog?.byParagraphId.get(anchorBlockId);
+  const focus = catalog?.byParagraphId.get(focusBlockId);
+  if (!anchor || !focus || anchor.table !== focus.table || anchor.cell === focus.cell)
+    return null;
+  for (const endpoint of [anchor, focus]) {
+    if (endpoint.paragraph.isDirectCellChild)
+      continue;
+    const bytes = getSDDocumentSessionInternalPartBytes(session, anchorEntry.partUri);
+    if (!bytes)
+      return null;
+    const context = buildStructuralBoundaryMap(bytes.subarray(endpoint.cell.bodyByteStart, endpoint.cell.bodyByteEnd)).byBlockId(endpoint.paragraph.paragraphId);
+    if (!context?.blockSdtPath.length || context.tableCellPath.length || context.hasNonEditableBlockSdtContent)
+      return null;
+  }
+  const minRow = Math.min(anchor.row.rowIndex, focus.row.rowIndex);
+  const maxRow = Math.max(anchor.row.rowIndex, focus.row.rowIndex);
+  const minCol = Math.min(anchor.cell.cellOrdinal, focus.cell.cellOrdinal);
+  const maxCol = Math.max(anchor.cell.cellOrdinal, focus.cell.cellOrdinal);
+  const selectedCells = anchor.table.rows.filter((row) => row.rowIndex >= minRow && row.rowIndex <= maxRow).flatMap((row) => row.cells.filter((cell) => cell.cellOrdinal >= minCol && cell.cellOrdinal <= maxCol));
+  const entries = [];
+  for (const cell of selectedCells) {
+    for (const paragraph3 of cell.paragraphs) {
+      if (!paragraph3.paragraphId || index2.duplicateParaIds.has(paragraph3.paragraphId))
+        return null;
+      const entry = index2.byParaId(paragraph3.paragraphId);
+      if (!entry || entry.byteStart < cell.bodyByteStart || entry.byteEnd > cell.bodyByteEnd)
+        return null;
+      if (!entries.includes(entry))
+        entries.push(entry);
+    }
+  }
+  return entries.length ? entries.sort((a, b) => a.ordinal - b.ordinal) : null;
+}
+function resolveEntries(session, input) {
+  let index2 = resolveBrowserLiveSelectionParagraphIndex(session, input.story, input.start.blockId, input.end.blockId);
+  if (!index2)
+    return null;
+  if (input.tableCells) {
+    const entries2 = resolveTableCellSelectionEntries(session, input.story, input.start.blockId, input.end.blockId);
+    if (!entries2?.length)
+      return null;
+    const first = entries2[0];
+    const last = entries2[entries2.length - 1];
+    return {
+      entries: entries2,
+      start: { blockId: first.blockId, offset: 0 },
+      end: { blockId: last.blockId, offset: last.textLength },
+      target: {
+        kind: "text",
+        segments: entries2.map((entry) => ({
+          blockId: entry.blockId,
+          range: { start: 0, end: entry.textLength }
+        })),
+        story: input.story
+      }
+    };
+  }
+  const startStory = input.start.story ?? input.story;
+  const endStory = input.end.story ?? input.story;
+  if (distinctFootnotes(startStory, endStory)) {
+    index2 = resolveFootnoteRangeIndex(session, index2, { blockId: input.start.blockId, story: startStory }, { blockId: input.end.blockId, story: endStory });
+    if (!index2)
+      return null;
+  }
+  if (index2.duplicateParaIds.has(input.start.blockId) || index2.duplicateParaIds.has(input.end.blockId))
+    return null;
+  let startEntry = index2.byParaId(input.start.blockId);
+  let endEntry = index2.byParaId(input.end.blockId);
+  if (!startEntry || !endEntry || startEntry.storyId !== endEntry.storyId)
+    return null;
+  let startPoint = input.start;
+  let endPoint = input.end;
+  if (startEntry.ordinal > endEntry.ordinal) {
+    [startEntry, endEntry] = [endEntry, startEntry];
+    [startPoint, endPoint] = [endPoint, startPoint];
+  }
+  const entries = index2.entries.slice(startEntry.ordinal, endEntry.ordinal + 1);
+  if (entries.length === 0)
+    return null;
+  const visibleStart = resolveVisibleSelectionOffset(session, startEntry, startPoint);
+  const visibleEnd = resolveVisibleSelectionOffset(session, endEntry, endPoint);
+  if (visibleStart == null || visibleEnd == null)
+    return null;
+  const segments = entries.map((entry, idx) => {
+    const start = idx === 0 ? visibleStart : 0;
+    const end = idx === entries.length - 1 ? visibleEnd : entry.textLength;
+    return {
+      blockId: entry.blockId,
+      range: { start, end: Math.max(start, end) }
+    };
+  });
+  return {
+    target: {
+      kind: "text",
+      segments,
+      ...input.story ? { story: input.story } : {}
+    },
+    entries,
+    start: startPoint,
+    end: endPoint
+  };
+}
+function resolveVisibleSelectionOffset(session, entry, point3) {
+  if (point3.trackedOffset == null)
+    return clampOffset(point3.offset, entry.textLength);
+  const map3 = readParagraphInlineMap(session, entry);
+  return map3 ? projectTrackedOffsetToVisible(map3, point3.trackedOffset) : null;
+}
+function resolveBrowserLiveSelectionForSession(session, input, options = {}) {
+  const resolved = resolveEntries(session, input);
+  if (!resolved)
+    return null;
+  const selectionTarget = buildSelectionTarget(session, input.story, resolved.start, resolved.end, resolved.entries);
+  if (!selectionTarget)
+    return null;
+  const contiguous = resolved.entries.every((entry, i2) => i2 === 0 || entry.ordinal === resolved.entries[i2 - 1].ordinal + 1);
+  const reviewIds = readActiveReviewIds(session, resolved.entries, resolved.target.segments, options);
+  return {
+    target: distinctFootnotes(resolved.start.story ?? input.story, resolved.end.story ?? input.story) ? null : resolved.target,
+    selectionTarget: input.tableCells && !contiguous ? null : selectionTarget,
+    text: input.includeText === true ? readSelectionText(session, resolved.entries, resolved.target.segments) : "",
+    activeMarks: readActiveMarks(session, resolved.entries, resolved.target.segments),
+    activeCommentIds: reviewIds.activeCommentIds,
+    activeChangeIds: reviewIds.activeChangeIds
+  };
+}
+function readSelectionText(session, entries, segments) {
+  const slices = [];
+  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
+    const entry = entries[i2];
+    const segment = segments[i2];
+    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
+    if (!bytes)
+      return "";
+    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+    const paragraphText2 = visibleParagraphTextFromXml(xml);
+    const start = clampOffset(segment.range.start, paragraphText2.length);
+    const end = clampOffset(segment.range.end, paragraphText2.length);
+    slices.push(paragraphText2.slice(start, Math.max(start, end)));
+  }
+  return slices.join(" ");
+}
+function readActiveMarks(session, entries, segments) {
+  let common = null;
+  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
+    const entry = entries[i2];
+    const segment = segments[i2];
+    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
+    if (!bytes)
+      return [];
+    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+    const paragraphText2 = visibleParagraphTextFromXml(xml);
+    const start = clampOffset(segment.range.start, paragraphText2.length);
+    const end = clampOffset(segment.range.end, paragraphText2.length);
+    const marks = new Set(activeMarksForParagraphXmlRange(xml, start, Math.max(start, end)));
+    common = common == null ? marks : intersectStringSets(common, marks);
+  }
+  if (!common)
+    return [];
+  return ACTIVE_MARK_ORDER.filter((mark) => common.has(mark));
+}
+function readActiveReviewIds(session, entries, segments, options) {
+  return {
+    activeCommentIds: readActiveCommentIds(session, segments),
+    activeChangeIds: readActiveChangeIds(session, entries, segments, options)
+  };
+}
+function readActiveCommentIds(session, segments) {
+  const catalog = getSDDocumentSessionInternalCommentsCatalog(session);
+  if (!catalog)
+    return [];
+  const anchorIndex = getSDDocumentSessionInternalCommentAnchorIndex(session);
+  const ids = [];
+  for (const [sourceWId, hits] of anchorIndex.hitsBySourceWId) {
+    const catalogEntries = catalog.commentsBySourceWId.get(sourceWId);
+    if (!catalogEntries || catalogEntries.length === 0)
+      continue;
+    let overlaps2 = false;
+    for (const hit of hits) {
+      for (const hitSegment of hit.segments) {
+        if (!hitSegment.blockId)
+          continue;
+        const selectionSegment = segments.find((segment) => segment.blockId === hitSegment.blockId);
+        if (!selectionSegment)
+          continue;
+        if (rangesOverlap9(hitSegment.start, hitSegment.end, selectionSegment.range.start, selectionSegment.range.end)) {
+          overlaps2 = true;
+          break;
+        }
+      }
+      if (overlaps2)
+        break;
+    }
+    if (!overlaps2)
+      continue;
+    for (const entry of catalogEntries)
+      pushUnique(ids, entry.commentId);
+  }
+  return ids;
+}
+function readActiveChangeIds(session, entries, segments, options) {
+  const activeSourceIds = new Set;
+  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
+    const entry = entries[i2];
+    const segment = segments[i2];
+    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
+    if (!bytes)
+      return [];
+    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+    const paragraphText2 = visibleParagraphTextFromXml(xml);
+    const start = clampOffset(segment.range.start, paragraphText2.length);
+    const end = clampOffset(segment.range.end, paragraphText2.length);
+    for (const sourceId of activeTrackedChangeSourceIdsForParagraphXmlRange(xml, start, Math.max(start, end))) {
+      activeSourceIds.add(sourceId);
+    }
+  }
+  if (activeSourceIds.size === 0)
+    return [];
+  const resolved = options.resolveTrackChangeIds?.(activeSourceIds);
+  if (resolved)
+    return [...new Set(resolved)];
+  const sourceIdToChangeIds = buildTrackedChangeSourceMap(options.trackChangesList?.()?.items ?? []);
+  if (sourceIdToChangeIds.size === 0)
+    return [];
+  const out = [];
+  for (const sourceId of activeSourceIds) {
+    const changeIds = sourceIdToChangeIds.get(sourceId);
+    if (!changeIds)
+      continue;
+    for (const changeId of changeIds)
+      pushUnique(out, changeId);
+  }
+  return out;
+}
+function buildTrackedChangeSourceMap(items) {
+  const map3 = new Map;
+  for (const item of items) {
+    if (!item || typeof item !== "object")
+      continue;
+    const record3 = item;
+    const id = typeof record3.id === "string" ? record3.id : null;
+    if (!id)
+      continue;
+    const sourceIds = record3.sourceIds && typeof record3.sourceIds === "object" ? record3.sourceIds : {};
+    const wordRevisionIds = record3.wordRevisionIds && typeof record3.wordRevisionIds === "object" ? record3.wordRevisionIds : {};
+    pushTrackedSourceMap(map3, sourceIds.wordIdInsert, id);
+    pushTrackedSourceMap(map3, sourceIds.wordIdDelete, id);
+    for (const sourceId of Array.isArray(sourceIds.wordIdOther) ? sourceIds.wordIdOther : []) {
+      pushTrackedSourceMap(map3, sourceId, id);
+    }
+    pushTrackedSourceMap(map3, wordRevisionIds.insert, id);
+    pushTrackedSourceMap(map3, wordRevisionIds.delete, id);
+    pushTrackedSourceMap(map3, wordRevisionIds.format, id);
+  }
+  return map3;
+}
+function pushTrackedSourceMap(map3, sourceId, changeId) {
+  if (typeof sourceId !== "string" || sourceId.length === 0)
+    return;
+  const ids = map3.get(sourceId) ?? [];
+  pushUnique(ids, changeId);
+  map3.set(sourceId, ids);
+}
+function visibleParagraphTextFromXml(xml) {
+  const stripped = stripTextboxContent2(stripParagraphProperties3(stripDeletedRevisions(xml)));
+  let out = "";
+  for (const token of stripped.matchAll(/<[\w.-]+:t\b[^>]*>([\s\S]*?)<\/[\w.-]+:t>|<[\w.-]+:(tab|br|cr)\b[^>]*\/>/g)) {
+    if (token[1] != null) {
+      out += decodeXmlText10(token[1]);
+      continue;
+    }
+    out += token[2] === "tab" ? "\t" : `
+`;
+  }
+  return out;
+}
+function visibleRunMarkSlicesFromXml(xml) {
+  const stripped = stripTextboxContent2(stripParagraphProperties3(stripDeletedRevisions(xml)));
+  const slices = [];
+  let cursor = 0;
+  for (const match of stripped.matchAll(/<(?:[\w.-]+:)?r\b[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?r>/g)) {
+    const runXml = match[0];
+    const textLength = visibleParagraphTextFromXml(runXml).length;
+    if (textLength > 0) {
+      slices.push({ start: cursor, end: cursor + textLength, marks: activeMarksForRunXml(runXml) });
+    }
+    cursor += textLength;
+  }
+  return slices;
+}
+function activeMarksForRunXml(runXml) {
+  const rPr = findFirstElement(runXml, "rPr")?.xml ?? "";
+  if (!rPr)
+    return [];
+  const marks = [];
+  if (hasOnOffRunProperty(rPr, "b"))
+    marks.push("bold");
+  if (hasOnOffRunProperty(rPr, "i"))
+    marks.push("italic");
+  if (hasOnOffRunProperty(rPr, "u"))
+    marks.push("underline");
+  if (hasOnOffRunProperty(rPr, "strike"))
+    marks.push("strikethrough");
+  return marks;
+}
+function hasOnOffRunProperty(rPrXml, localName2) {
+  const match = rPrXml.match(new RegExp(`<(?:[\\w.-]+:)?${localName2}\\b([^>]*)\\/?>`, "i"));
+  if (!match)
+    return false;
+  const attrs = match[1] ?? "";
+  const val = attrs.match(/(?:^|\s)(?:[\w.-]+:)?val=(["'])(.*?)\1/i)?.[2]?.toLowerCase();
+  return val !== "0" && val !== "false" && val !== "off" && val !== "none";
+}
+function activeMarksForParagraphXmlRange(xml, start, end) {
+  const slices = visibleRunMarkSlicesFromXml(xml);
+  if (slices.length === 0)
+    return [];
+  if (start === end) {
+    const containing = slices.find((slice) => start > slice.start && start < slice.end);
+    if (containing)
+      return containing.marks;
+    let previous3 = null;
+    for (const slice of slices) {
+      if (slice.end <= start)
+        previous3 = slice;
+    }
+    if (previous3)
+      return previous3.marks;
+    return slices[0]?.marks ?? [];
+  }
+  let common = null;
+  for (const slice of slices) {
+    if (Math.max(start, slice.start) >= Math.min(end, slice.end))
+      continue;
+    const marks = new Set(slice.marks);
+    common = common == null ? marks : intersectStringSets(common, marks);
+  }
+  if (!common)
+    return [];
+  return ACTIVE_MARK_ORDER.filter((mark) => common.has(mark));
+}
+function activeTrackedChangeSourceIdsForParagraphXmlRange(xml, start, end) {
+  const slices = visibleTrackedChangeSourceSlicesFromXml(xml);
+  if (slices.length === 0)
+    return [];
+  const out = [];
+  for (const slice of slices) {
+    if (!rangesOverlap9(slice.start, slice.end, start, end))
+      continue;
+    for (const sourceId of slice.sourceIds)
+      pushUnique(out, sourceId);
+  }
+  return out;
+}
+function visibleTrackedChangeSourceSlicesFromXml(xml) {
+  const stripped = stripTextboxContent2(stripParagraphProperties3(xml));
+  const slices = [];
+  const activeSourceIdStack = [];
+  const elementStack = [];
+  let delDepth = 0;
+  let cursor = 0;
+  const tokenRe = /<\/(?:[\w.-]+:)?(ins|del|moveFrom|moveTo)>|<(?:[\w.-]+:)?t\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?t>|<(?:[\w.-]+:)?delText\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?delText>|<(?:[\w.-]+:)?(ins|del|moveFrom|moveTo|tab|br|cr)\b([^>]*)\/?>/g;
+  for (const match of stripped.matchAll(tokenRe)) {
+    const closingName = match[1];
+    const tText = match[2];
+    const delText = match[3];
+    const openingName = match[4];
+    const attrs = match[5] ?? "";
+    if (closingName) {
+      const frame = elementStack.pop();
+      if (frame?.hadId)
+        activeSourceIdStack.pop();
+      if (closingName === "del")
+        delDepth = Math.max(0, delDepth - 1);
+      continue;
+    }
+    if (tText != null) {
+      if (delDepth > 0) {
+        pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
+      } else {
+        cursor = pushTrackedSourceSlice(slices, cursor, decodeXmlText10(tText).length, activeSourceIdStack);
+      }
+      continue;
+    }
+    if (delText != null) {
+      pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
+      continue;
+    }
+    if (!openingName)
+      continue;
+    if (openingName === "tab" || openingName === "br" || openingName === "cr") {
+      if (delDepth > 0) {
+        pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
+      } else {
+        cursor = pushTrackedSourceSlice(slices, cursor, 1, activeSourceIdStack);
+      }
+      continue;
+    }
+    const sourceId = readXmlAttribute4(attrs, "id");
+    const selfClosing = match[0].endsWith("/>");
+    if (!selfClosing) {
+      elementStack.push({ name: openingName, hadId: Boolean(sourceId) });
+      if (sourceId)
+        activeSourceIdStack.push(sourceId);
+      if (openingName === "del")
+        delDepth += 1;
+    }
+  }
+  return slices;
+}
+function pushTrackedSourceSlice(slices, cursor, textLength, activeSourceIds) {
+  if (textLength <= 0)
+    return cursor;
+  if (activeSourceIds.length > 0) {
+    slices.push({ start: cursor, end: cursor + textLength, sourceIds: [...new Set(activeSourceIds)] });
+  }
+  return cursor + textLength;
+}
+function pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIds) {
+  if (activeSourceIds.length === 0)
+    return;
+  slices.push({ start: cursor, end: cursor, sourceIds: [...new Set(activeSourceIds)] });
+}
+function readXmlAttribute4(attrs, localName2) {
+  const match = attrs.match(new RegExp(`(?:^|\\s)(?:[\\w.-]+:)?${localName2}=(["'])(.*?)\\1`, "i"));
+  return match?.[2] ?? null;
+}
+function rangesOverlap9(aStart, aEnd, bStart, bEnd) {
+  const leftStart = Math.min(aStart, aEnd);
+  const leftEnd = Math.max(aStart, aEnd);
+  const rightStart = Math.min(bStart, bEnd);
+  const rightEnd = Math.max(bStart, bEnd);
+  if (rightStart === rightEnd)
+    return rightStart >= leftStart && rightStart <= leftEnd;
+  if (leftStart === leftEnd)
+    return leftStart >= rightStart && leftStart <= rightEnd;
+  return Math.max(leftStart, rightStart) < Math.min(leftEnd, rightEnd);
+}
+function intersectStringSets(left, right) {
+  const out = new Set;
+  for (const value2 of left) {
+    if (right.has(value2))
+      out.add(value2);
+  }
+  return out;
+}
+function stripParagraphProperties3(xml) {
+  return stripElements(xml, "pPr");
+}
+function stripDeletedRevisions(xml) {
+  return xml.replace(/<[\w.-]+:del\b(?![^>]*\/>)[^>]*>[\s\S]*?<\/[\w.-]+:del>/g, "");
+}
+function stripTextboxContent2(xml) {
+  return xml.replace(/<(?:[\w.-]+:)?txbxContent\b[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?txbxContent>/g, "").replace(/<(?:[\w.-]+:)?txbxContent\b[^>]*>[\s\S]*$/g, "");
+}
+function decodeXmlText10(escaped) {
+  return escaped.replace(/&(lt|gt|amp|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (_, entity) => {
+    switch (entity) {
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "amp":
+        return "&";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default: {
+        const cp = entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
+        return Number.isFinite(cp) ? String.fromCodePoint(cp) : `&${entity};`;
+      }
+    }
+  });
+}
+function pushUnique(out, id) {
+  if (typeof id === "string" && id.length > 0 && !out.includes(id))
+    out.push(id);
+}
+var TEXT_DECODER7, ACTIVE_MARK_ORDER;
+var init_live_selection = __esm(() => {
+  init_sd_document_session_internal();
+  init_sd_document_session_internal();
+  init_footnote_range();
+  TEXT_DECODER7 = new TextDecoder;
+  ACTIVE_MARK_ORDER = ["bold", "italic", "underline", "strikethrough"];
+});
+
 // ../../../v2/document-api-v2-adapter/dist/tracked-changes/local-text-projection.js
 function currentCache(context) {
   const revision = getSDDocumentSessionInternalPackageRevision(context.session);
@@ -331598,7 +332437,7 @@ class V2ClearContentAdapter {
     }
     if (options?.dryRun)
       return { success: true };
-    const nextBytes = TE49.encode(nextXml);
+    const nextBytes = TE50.encode(nextXml);
     const committed = commitKernelStorySurfacePatch({
       context: this.context,
       txIdPrefix: selectedBlockIds ? "range-ref-whole-body-replace" : "internal-clearContent",
@@ -331701,14 +332540,14 @@ function rewriteBodyToSingleEmptyParagraph(xml, paragraphId2) {
   const emptyParagraph = `<${wordPrefix}:p${identityNamespace} ${identityPrefix}:paraId="${paragraphId2}">` + `<${wordPrefix}:r><${wordPrefix}:t></${wordPrefix}:t></${wordPrefix}:r></${wordPrefix}:p>`;
   return `${xml.slice(0, body.openEnd)}${emptyParagraph}${sectPrXml}${xml.slice(body.closeStart)}`;
 }
-var TE49, WORD_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", STRICT_WORD_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main", WORD_2010_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
+var TE50, WORD_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", STRICT_WORD_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main", WORD_2010_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
 var init_clear_content_adapter = __esm(() => {
   init_sd_document_session_internal();
   init_document_reader();
   init_xml();
   init_tracked_body_replacement();
   init_receipt_entities();
-  TE49 = new TextEncoder;
+  TE50 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/selection-mutation/replacement-span.js
@@ -333135,7 +333974,35 @@ async function readEffectiveInlineUniformity(context, input) {
     ...input.offsetSpace ? { offsetSpace: input.offsetSpace } : {}
   };
   let ranges;
-  if (target.start.blockId !== target.end.blockId) {
+  if (input.tableCellSelection) {
+    const entries = resolveTableCellSelectionEntries(context.session, storyLocator ?? { kind: "story", storyType: "body" }, input.tableCellSelection.anchorBlockId, input.tableCellSelection.focusBlockId);
+    if (!entries) {
+      return {
+        success: false,
+        failure: { code: "TARGET_NOT_FOUND", message: "The selected table cells no longer resolve." }
+      };
+    }
+    const cellRanges = [];
+    for (const entry of entries) {
+      if (entry.textLength === 0)
+        continue;
+      const resolved = resolveSelectionTargetToRange({
+        ...resolveInput,
+        target: {
+          kind: "selection",
+          start: { kind: "text", blockId: entry.blockId, offset: 0 },
+          end: { kind: "text", blockId: entry.blockId, offset: entry.textLength },
+          ...storyLocator ? { story: storyLocator } : {}
+        },
+        offsetSpace: "kernel"
+      });
+      if ("error" in resolved) {
+        return { success: false, failure: { code: resolved.error, message: resolved.message } };
+      }
+      cellRanges.push(resolved);
+    }
+    ranges = cellRanges;
+  } else if (target.start.blockId !== target.end.blockId) {
     const plan = resolveCrossBlockFormatSelection(resolveInput, input.in);
     if ("error" in plan) {
       return { success: false, failure: { code: plan.error, message: plan.message } };
@@ -333239,6 +334106,7 @@ var init_effective_inline_uniformity = __esm(() => {
   init_sd_document_session_internal();
   init_story_surface();
   init_part();
+  init_live_selection();
   TD92 = new TextDecoder;
   MODEL_CACHE = new WeakMap;
   TABLE_CELLS_BY_CATALOG = new WeakMap;
@@ -333370,7 +334238,7 @@ class V2SelectionMutationAdapter {
       };
       if (newText.length !== 0)
         return { on, newText, ...stamps, resultKey };
-      const matchingFields = fieldEntries.filter((entry) => entry.storyId === on.storyId && entry.blockId === on.startBlockId && entry.descriptor.resultText === resolution.text && rangesOverlap9(on.startByte, on.endByte, entry.descriptor.byteStart, entry.descriptor.byteEnd));
+      const matchingFields = fieldEntries.filter((entry) => entry.storyId === on.storyId && entry.blockId === on.startBlockId && entry.descriptor.resultText === resolution.text && rangesOverlap10(on.startByte, on.endByte, entry.descriptor.byteStart, entry.descriptor.byteEnd));
       if (matchingFields.length !== 1)
         return { on, newText, ...stamps, resultKey };
       if (options?.changeMode === "tracked") {
@@ -333442,11 +334310,11 @@ class V2SelectionMutationAdapter {
     const updatedRefs = receipt3.updatedRefs ?? [];
     const inserted = createdRefs.length <= 100 ? projectTrackedTextEntities(this.context, createdRefs, edits[0].on.startBlockId) : undefined;
     const updated = updatedRefs.length <= 100 ? projectTrackedTextEntities(this.context, updatedRefs, edits[0].on.startBlockId) : undefined;
-    const trackedOutcomeRawIds = new Set((receipt3.trackedTextEditOutcomes ?? []).flatMap((outcome) => [
-      ...outcome.createdRsids,
-      ...outcome.updatedRsids
-    ]));
-    const trackedOutcomeLogicalView = trackedOutcomeRawIds.size <= 100 && trackedOutcomeRawIds.size > 0 ? buildCachedTrackedChangeLogicalView(this.context).logical : null;
+    let trackedOutcomeLogicalView = null;
+    const resolveTrackedOutcomeId = (rawId) => {
+      trackedOutcomeLogicalView ?? (trackedOutcomeLogicalView = buildCachedTrackedChangeLogicalView(this.context).logical);
+      return trackedOutcomeLogicalView.rsidToLogicalId.get(rawId) ?? rawId;
+    };
     const trackedChangeOutcomes = (receipt3.trackedTextEditOutcomes ?? []).map((outcome) => {
       const source = edits[Number(outcome.resultKey)];
       const origin = source.rewriteIntent ? ownerIds.get(source.ownerStepId ?? "") : undefined;
@@ -333454,7 +334322,7 @@ class V2SelectionMutationAdapter {
       const refs = parentId && (outcome.createdRsids.length > 0 || outcome.updatedRsids.length > 0) ? [{ kind: "entity", entityType: "trackedChange", entityId: parentId }] : dedupeTrackedChangeReceiptEntities([...outcome.createdRsids, ...outcome.updatedRsids].map((rawId) => ({
         kind: "entity",
         entityType: "trackedChange",
-        entityId: trackedOutcomeLogicalView?.rsidToLogicalId.get(rawId) ?? rawId
+        entityId: resolveTrackedOutcomeId(rawId)
       })));
       return {
         editIndex: Number(outcome.resultKey),
@@ -334676,7 +335544,8 @@ class V2SelectionMutationAdapter {
     };
   }
   executeFormat(request, options, offsetSpace) {
-    const resolvedTarget = request.ref !== undefined && request.target === undefined ? this.resolveRefSelection(request.ref, request.in, options) : this.resolveExplicitSelection(request.target, request.in, options, offsetSpace);
+    const cellSelection = options?.tableCellSelection;
+    const resolvedTarget = cellSelection ? this.resolveCellFormatSelection(request.target, request.in, options, cellSelection) : request.ref !== undefined && request.target === undefined ? this.resolveRefSelection(request.ref, request.in, options) : this.resolveExplicitSelection(request.target, request.in, options, offsetSpace);
     if (!resolvedTarget.ok)
       return resolvedTarget.receipt;
     const { resolution, storyLocator } = resolvedTarget.value;
@@ -334822,6 +335691,49 @@ class V2SelectionMutationAdapter {
       resolution
     };
   }
+  resolveCellFormatSelection(target, overrideStory, options, cellSelection) {
+    const story = target ? pickStoryLocator(target, overrideStory) : overrideStory;
+    const entries = resolveTableCellSelectionEntries(this.context.session, story ?? { kind: "story", storyType: "body" }, cellSelection.anchorBlockId, cellSelection.focusBlockId);
+    if (!entries)
+      return {
+        ok: false,
+        receipt: failureWithoutResolution("TARGET_NOT_FOUND", "The selected table cells no longer resolve.")
+      };
+    const ranges = [];
+    const texts = [];
+    let firstResolved;
+    for (const entry of entries) {
+      if (entry.textLength === 0)
+        continue;
+      const selected = this.resolveExplicitSelection({
+        kind: "selection",
+        start: { kind: "text", blockId: entry.blockId, offset: 0 },
+        end: { kind: "text", blockId: entry.blockId, offset: entry.textLength },
+        ...story ? { story } : {}
+      }, overrideStory, options, "kernel");
+      if (!selected.ok)
+        return selected;
+      firstResolved ?? (firstResolved = selected.value);
+      ranges.push(...selected.value.mode === "multi" ? selected.value.ranges : [selected.value.resolved]);
+      texts.push(selected.value.resolution.text);
+    }
+    if (!firstResolved || !ranges.length)
+      return { ok: false, receipt: failureWithoutResolution("NO_OP", "The selected cells contain no text.") };
+    return {
+      ok: true,
+      value: {
+        mode: "multi",
+        ranges,
+        storyLocator: firstResolved.storyLocator,
+        resolution: {
+          ...firstResolved.resolution,
+          text: texts.join(`
+`),
+          range: { from: ranges[0].startByte, to: ranges[ranges.length - 1].endByte }
+        }
+      }
+    };
+  }
   resolveExplicitSelection(target, overrideStory, _options, offsetSpace) {
     if (!target) {
       return {
@@ -335125,7 +336037,7 @@ class V2SelectionMutationAdapter {
       txIdPrefix: "range-ref-whole-body-replace",
       expectedRevision: options?.expectedRevision != null ? String(options.expectedRevision) : undefined,
       perPart: {
-        [story.partUri]: replaceWholePartEntry(bytes, TE50.encode(nextXml))
+        [story.partUri]: replaceWholePartEntry(bytes, TE51.encode(nextXml))
       },
       storyIds: [story.storyId],
       createdRefs,
@@ -335412,7 +336324,7 @@ function typingHistoryMetadata(options) {
 function tryDeleteMatchedFieldRef(context, replacementText, outcome, resolution) {
   if (replacementText.length !== 0)
     return null;
-  const matches = listCanonicalFieldEntries(context).filter((entry2) => entry2.storyId === outcome.payload.storyId && entry2.blockId === outcome.payload.blockId && entry2.descriptor.resultText === outcome.payload.matchText && rangesOverlap9(outcome.resolved.startByte, outcome.resolved.endByte, entry2.descriptor.byteStart, entry2.descriptor.byteEnd));
+  const matches = listCanonicalFieldEntries(context).filter((entry2) => entry2.storyId === outcome.payload.storyId && entry2.blockId === outcome.payload.blockId && entry2.descriptor.resultText === outcome.payload.matchText && rangesOverlap10(outcome.resolved.startByte, outcome.resolved.endByte, entry2.descriptor.byteStart, entry2.descriptor.byteEnd));
   if (matches.length !== 1)
     return null;
   const entry = matches[0];
@@ -335432,7 +336344,7 @@ function tryDeleteMatchedFieldRef(context, replacementText, outcome, resolution)
     resolution
   };
 }
-function rangesOverlap9(start, end, otherStart, otherEnd) {
+function rangesOverlap10(start, end, otherStart, otherEnd) {
   return start < otherEnd && end > otherStart;
 }
 function failureWithoutResolution(code2, message) {
@@ -335940,9 +336852,10 @@ function rewriteReviewId(on, resolution, origin) {
   const noteId = story && "noteId" in story ? story.noteId : undefined;
   return buildTextRewriteReviewGroupId(on.storyId, origin, noteId);
 }
-var TD93, TE50, PERMISSION_DENIED_DOC_PROTECTION = "document protection permits edits only within an everyone permission range.", FORMAT_STRADDLE_MARKER_KINDS;
+var TD93, TE51, PERMISSION_DENIED_DOC_PROTECTION = "document protection permits edits only within an everyone permission range.", FORMAT_STRADDLE_MARKER_KINDS;
 var init_adapter9 = __esm(() => {
   init_review_read_model();
+  init_live_selection();
   init_sd_document_session_internal();
   init_logical_view_cache();
   init_local_text_projection();
@@ -335976,7 +336889,7 @@ var init_adapter9 = __esm(() => {
   init_cross_cell_delete();
   init_effective_inline_uniformity();
   TD93 = new TextDecoder;
-  TE50 = new TextEncoder;
+  TE51 = new TextEncoder;
   FORMAT_STRADDLE_MARKER_KINDS = new Set([
     "bookmarkStart",
     "bookmarkEnd",
@@ -336770,7 +337683,7 @@ function richWriteAnalysisSha256(input) {
   return digest({ ...input, atomic: true });
 }
 function digest(value2) {
-  return sha256HexSync(TE51.encode(canonicalJson(value2)));
+  return sha256HexSync(TE52.encode(canonicalJson(value2)));
 }
 function canonicalJson(value2) {
   if (value2 === null || typeof value2 === "boolean" || typeof value2 === "string")
@@ -336788,10 +337701,10 @@ function canonicalJson(value2) {
   }
   throw new Error(`Support-check digests cannot encode ${typeof value2}.`);
 }
-var TE51;
+var TE52;
 var init_digest = __esm(() => {
   init_sd_document_session_internal();
-  TE51 = new TextEncoder;
+  TE52 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/write/rich-fragment-apply.js
@@ -337589,7 +338502,7 @@ function commitKernelXmlRewrites(input) {
         }
       };
     }
-    const nextBytes = TE52.encode(rewrite.nextXml);
+    const nextBytes = TE53.encode(rewrite.nextXml);
     return bytesEqual16(currentBytes, nextBytes) ? null : {
       rewrite,
       currentBytes,
@@ -337664,11 +338577,11 @@ function bytesEqual16(left, right) {
   }
   return true;
 }
-var TE52, TD95;
+var TE53, TD95;
 var init_xml_rewrite = __esm(() => {
   init_sd_document_session_internal();
   init_xml();
-  TE52 = new TextEncoder;
+  TE53 = new TextEncoder;
   TD95 = new TextDecoder;
 });
 
@@ -347232,7 +348145,7 @@ function storyErrorMessage3(error48) {
   }
 }
 function splicePartBytes(bytes, start, end, replacementXml) {
-  const replacement = TE53.encode(replacementXml);
+  const replacement = TE54.encode(replacementXml);
   const next = new Uint8Array(start + replacement.length + (bytes.length - end));
   next.set(bytes.subarray(0, start), 0);
   next.set(replacement, start);
@@ -347335,7 +348248,7 @@ function txIdPrefixToOperation(prefix) {
       return prefix;
   }
 }
-var TD97, TE53;
+var TD97, TE54;
 var init_adapter15 = __esm(() => {
   init_sd_document_session_internal();
   init_src6();
@@ -347349,7 +348262,7 @@ var init_adapter15 = __esm(() => {
   init_part();
   init_paragraph();
   TD97 = new TextDecoder;
-  TE53 = new TextEncoder;
+  TE54 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/header-footers/page-numbers.js
@@ -351016,7 +351929,7 @@ function readInsertedTextFromXml(xml) {
   const textRe = /<([\w.-]+):t\b([^>]*?)>([\s\S]*?)<\/\1:t>/g;
   let match;
   while (match = textRe.exec(xml)) {
-    out.push(decodeXmlText10(match[3] ?? ""));
+    out.push(decodeXmlText11(match[3] ?? ""));
   }
   return out.join("");
 }
@@ -351259,7 +352172,7 @@ function computeFragmentCharRangesForParagraph(paragraphXml, paragraphByteStart,
         }
       }
     } else if (m[7]) {
-      const decoded = decodeXmlText10(m[9] ?? "");
+      const decoded = decodeXmlText11(m[9] ?? "");
       charCursor += decoded.length;
     }
   }
@@ -351542,7 +352455,7 @@ function rangesContainOrAreContained(left, right) {
 function rangesAreAdjacent(left, right) {
   return Math.abs(left.start - right.byteEnd) <= 64 || Math.abs(right.byteStart - left.end) <= 64;
 }
-function decodeXmlText10(value2) {
+function decodeXmlText11(value2) {
   return value2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
 function escapeRegex12(value2) {
@@ -358673,11 +359586,11 @@ function findStructuredImageDrawings(partXml, identity2) {
     const relationshipId = /\br:embed="([^"]+)"/.exec(drawing.xml)?.[1] ?? null;
     if (!relationshipId || normalizeImageIdComponent(relationshipId) !== identity2.relationshipScope)
       continue;
-    const byteStart = TE54.encode(partXml.slice(0, drawing.start)).byteLength;
+    const byteStart = TE55.encode(partXml.slice(0, drawing.start)).byteLength;
     out.push({
       start: drawing.start,
       byteStart,
-      byteEnd: byteStart + TE54.encode(drawing.xml).byteLength,
+      byteEnd: byteStart + TE55.encode(drawing.xml).byteLength,
       relationshipId,
       xml: drawing.xml
     });
@@ -359155,14 +360068,14 @@ function decodeXmlAttr2(value2) {
 function emuToPx(value2) {
   return value2 / EMU_PER_PX4;
 }
-var TD98, TE54, EMU_PER_PX4 = 9525, CROP_SCALE = 1000, DECORATIVE_DESCRIPTION_CLEARED, BODY_IMAGE_ENTRIES_CACHE, TRACKED_WRAPPER_KINDS2;
+var TD98, TE55, EMU_PER_PX4 = 9525, CROP_SCALE = 1000, DECORATIVE_DESCRIPTION_CLEARED, BODY_IMAGE_ENTRIES_CACHE, TRACKED_WRAPPER_KINDS2;
 var init_public_model = __esm(() => {
   init_sd_document_session_internal();
   init_caption_style();
   init_xml_rewrite();
   init_document_reader();
   TD98 = new TextDecoder;
-  TE54 = new TextEncoder;
+  TE55 = new TextEncoder;
   DECORATIVE_DESCRIPTION_CLEARED = new WeakMap;
   BODY_IMAGE_ENTRIES_CACHE = new WeakMap;
   TRACKED_WRAPPER_KINDS2 = new Set(["ins", "del", "moveFrom", "moveTo"]);
@@ -364558,7 +365471,7 @@ function computeFragmentParagraphCharRange(paragraphXml, fragLocalStart, fragLoc
   let match;
   while (match = re.exec(paragraphXml)) {
     const raw = match[1] ?? "";
-    const decoded = decodeXmlText11(raw);
+    const decoded = decodeXmlText12(raw);
     const tOpenStart = match.index;
     const tCloseEnd = match.index + match[0].length;
     const insideFragment = tOpenStart >= fragLocalStart && tCloseEnd <= fragLocalEnd;
@@ -364650,7 +365563,7 @@ function buildParagraphCharOffsetMap(paragraphXml, paragraphByteStart, coordinat
   const re = coordinateSpace === "tracked" ? /<[\w.-]+:(?:t|delText)\b[^>]*>([\s\S]*?)<\/[\w.-]+:(?:t|delText)>/g : /<[\w.-]+:t\b[^>]*>([\s\S]*?)<\/[\w.-]+:t>/g;
   for (const match of paragraphXml.matchAll(re)) {
     const raw = match[1] ?? "";
-    const decoded = decodeXmlText11(raw);
+    const decoded = decodeXmlText12(raw);
     const contentCharStart = (match.index ?? 0) + match[0].indexOf(">") + 1;
     advanceXmlTo(contentCharStart);
     const contentStart = paragraphByteStart + xmlByteCursor;
@@ -364717,7 +365630,7 @@ function deriveStoryLocatorForFragment(context, fragment4) {
   }
   return;
 }
-function decodeXmlText11(value2) {
+function decodeXmlText12(value2) {
   return value2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
 function fail4(code2, message) {
@@ -366782,8 +367695,8 @@ var init_adapter23 = __esm(() => {
 
 // ../../../v2/document-api-v2-adapter/dist/diff/tracked-table-property-replay.js
 function buildTrackedTablePropertyReplayPlan(base3, target) {
-  const baseBytes = TE55.encode(base3.xml);
-  const targetBytes = TE55.encode(target.xml);
+  const baseBytes = TE56.encode(base3.xml);
+  const targetBytes = TE56.encode(target.xml);
   const baseTables = buildTableCatalog({ bytes: baseBytes, storyId: STORY_ID });
   const targetTables = buildTableCatalog({ bytes: targetBytes, storyId: STORY_ID });
   const baseBody = collectXmlElementRanges(base3.xml).ranges.find((range) => range.tag.namespaceUri === W20 && range.tag.localName === "body");
@@ -366829,10 +367742,10 @@ function buildTrackedTablePropertyReplayPlan(base3, target) {
   }
   return steps.length ? { steps } : null;
 }
-var TE55, TD101, STORY_ID = "body:/word/document.xml", W20 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var TE56, TD101, STORY_ID = "body:/word/document.xml", W20 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var init_tracked_table_property_replay = __esm(() => {
   init_sd_document_session_internal();
-  TE55 = new TextEncoder;
+  TE56 = new TextEncoder;
   TD101 = new TextDecoder;
 });
 
@@ -366931,15 +367844,15 @@ var init_fingerprint = __esm(() => {
 // ../../../v2/document-api-v2-adapter/dist/compare/part-fingerprint.js
 function comparePartContentFingerprint(partUri, bytes) {
   const partHash = sha256HexSync(bytes);
-  return `fp:${sha256HexSync(TE56.encode(`${partUri}:${partHash}`))}`;
+  return `fp:${sha256HexSync(TE57.encode(`${partUri}:${partHash}`))}`;
 }
 function comparePartXmlFingerprint(partUri, xml) {
-  return comparePartContentFingerprint(partUri, TE56.encode(xml));
+  return comparePartContentFingerprint(partUri, TE57.encode(xml));
 }
-var TE56;
+var TE57;
 var init_part_fingerprint = __esm(() => {
   init_sd_document_session_internal();
-  TE56 = new TextEncoder;
+  TE57 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/compare/inventory.js
@@ -367160,7 +368073,7 @@ function captureCompareSourceInventory(context) {
   return buildCompareSourceInventory(buildCompareSourceObservation(context));
 }
 function textBytes(value2) {
-  return TE57.encode(value2);
+  return TE58.encode(value2);
 }
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -367217,19 +368130,19 @@ function accumulateStoryCatalogs(context, story, acc) {
     }
   } catch {}
 }
-var TD102, BODY_PART_URI = "/word/document.xml", TE57;
+var TD102, BODY_PART_URI = "/word/document.xml", TE58;
 var init_inventory = __esm(() => {
   init_src2();
   init_sd_document_session_internal();
   init_document_reader();
   init_part_fingerprint();
   TD102 = new TextDecoder("utf-8", { fatal: false });
-  TE57 = new TextEncoder;
+  TE58 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/compare/definitions.js
 function digest2(value2) {
-  return sha256HexSync(TE58.encode(value2));
+  return sha256HexSync(TE59.encode(value2));
 }
 function tagAttr2(tag, local) {
   const match = new RegExp(`\\b(?:[\\w.-]+:)?${local}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
@@ -367533,14 +368446,14 @@ function projectCompareDefinitions(context) {
     { family: "theme", entries: projectTheme(context) }
   ];
 }
-var TD103, TE58, SETTINGS_PART_URI4 = "/word/settings.xml", WORDPROCESSINGML_NS3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", XML_ATTR_RE;
+var TD103, TE59, SETTINGS_PART_URI4 = "/word/settings.xml", WORDPROCESSINGML_NS3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", XML_ATTR_RE;
 var init_definitions = __esm(() => {
   init_src2();
   init_sd_document_session_internal();
   init_adapter13();
   init_part();
   TD103 = new TextDecoder("utf-8", { fatal: false });
-  TE58 = new TextEncoder;
+  TE59 = new TextEncoder;
   XML_ATTR_RE = /\s+[\w.-]+(?::[\w.-]+)?=(?:"[^"]*"|'[^']*')/g;
 });
 
@@ -367555,7 +368468,7 @@ function contentControlIdentity(properties) {
 
 // ../../../v2/document-api-v2-adapter/dist/compare/annotations.js
 function digest3(value2) {
-  return sha256HexSync(TE59.encode(value2));
+  return sha256HexSync(TE60.encode(value2));
 }
 function storyLocatorSignature(story) {
   if (!story || story.storyType === "body")
@@ -367902,17 +368815,17 @@ function projectCompareAnnotations(context) {
     { family: "permissions", entries: projectPermissions(context) }
   ];
 }
-var TD104, TE59, BODY_PART_URI2 = "/word/document.xml", CUSTOM_XML_PROPS_RELS_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps";
+var TD104, TE60, BODY_PART_URI2 = "/word/document.xml", CUSTOM_XML_PROPS_RELS_TYPE2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps";
 var init_annotations2 = __esm(() => {
   init_sd_document_session_internal();
   init_read();
   TD104 = new TextDecoder("utf-8", { fatal: false });
-  TE59 = new TextEncoder;
+  TE60 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/compare/objects.js
 function digest4(value2) {
-  return sha256HexSync(TE60.encode(value2));
+  return sha256HexSync(TE61.encode(value2));
 }
 function isMediaKind(partKind) {
   return classifyComparePartKind(partKind).family === "media";
@@ -368129,12 +369042,12 @@ function projectCompareObjects(context) {
     { family: "package-graph", entries: projectPackageGraph(context) }
   ];
 }
-var TD105, TE60, CONTENT_TYPES_PART_URI15 = "/[Content_Types].xml", PACKAGE_ROOT_OWNER = "/";
+var TD105, TE61, CONTENT_TYPES_PART_URI15 = "/[Content_Types].xml", PACKAGE_ROOT_OWNER = "/";
 var init_objects = __esm(() => {
   init_src2();
   init_sd_document_session_internal();
   TD105 = new TextDecoder("utf-8", { fatal: false });
-  TE60 = new TextEncoder;
+  TE61 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/compare/run-signature.js
@@ -368189,12 +369102,12 @@ function paragraphContext(rawXml, inherited) {
   const paragraph4 = /^<(([A-Za-z_][\w.-]*)(?::([A-Za-z_][\w.-]*))?)/.exec(openTag);
   const paragraphPrefix = paragraph4?.[3] === undefined ? "" : paragraph4[2];
   if (paragraph4 && context[paragraphPrefix] === undefined)
-    context[paragraphPrefix] = W_NS6;
+    context[paragraphPrefix] = W_NS7;
   return context;
 }
 function isWordprocessingElement4(element, context) {
   const local = namespaceDeclarations3(element.openTag);
-  return (local[element.prefix] ?? context[element.prefix]) === W_NS6;
+  return (local[element.prefix] ?? context[element.prefix]) === W_NS7;
 }
 function makeTopLevelElementsSelfContained2(xml, context) {
   let result = xml;
@@ -368255,7 +369168,7 @@ function computeParagraphPropertiesSignature2(paragraphPropertiesXml) {
   }
   return `v2-ppr-${hash2.toString(16).padStart(8, "0")}`;
 }
-var REVISION_ATTR_RE2, W_NS6 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", XML_TAG_RE3, XML_ATTRIBUTE_RE2;
+var REVISION_ATTR_RE2, W_NS7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", XML_TAG_RE3, XML_ATTRIBUTE_RE2;
 var init_run_signature2 = __esm(() => {
   init_src2();
   init_src2();
@@ -369188,70 +370101,6 @@ var init_compare = __esm(() => {
   init_src2();
 });
 
-// ../../../v2/document-api-v2-adapter/dist/core/text-coordinate-space.js
-function projectVisibleOffsetToTracked(map3, offset, bias) {
-  if (!Number.isInteger(offset) || offset < 0 || offset > map3.visibleLength)
-    return null;
-  const candidates = new Set;
-  if (offset === 0)
-    candidates.add(0);
-  if (offset === map3.visibleLength)
-    candidates.add(map3.trackedLength);
-  for (const piece of map3.leaves()) {
-    const visibleWidth2 = piece.visibleEnd - piece.visibleStart;
-    const trackedWidth2 = piece.trackedEnd - piece.trackedStart;
-    if (visibleWidth2 > 0 && trackedWidth2 === visibleWidth2) {
-      if (offset >= piece.visibleStart && offset <= piece.visibleEnd) {
-        candidates.add(piece.trackedStart + offset - piece.visibleStart);
-      }
-      continue;
-    }
-    if (offset === piece.visibleStart)
-      candidates.add(piece.trackedStart);
-    if (offset === piece.visibleEnd)
-      candidates.add(piece.trackedEnd);
-  }
-  if (candidates.size === 0)
-    return null;
-  const values2 = [...candidates];
-  return bias === "upstream" ? Math.min(...values2) : Math.max(...values2);
-}
-function projectTrackedOffsetToVisible(map3, offset) {
-  if (!Number.isInteger(offset) || offset < 0 || offset > map3.trackedLength)
-    return null;
-  if (offset === map3.trackedLength)
-    return map3.visibleLength;
-  for (const piece of map3.leaves()) {
-    if (offset < piece.trackedStart || offset > piece.trackedEnd)
-      continue;
-    if (offset === piece.trackedStart)
-      return piece.visibleStart;
-    if (offset === piece.trackedEnd)
-      return piece.visibleEnd;
-    const trackedWidth2 = piece.trackedEnd - piece.trackedStart;
-    const visibleWidth2 = piece.visibleEnd - piece.visibleStart;
-    if (trackedWidth2 === 0 || visibleWidth2 === 0)
-      return piece.visibleStart;
-    if (trackedWidth2 !== visibleWidth2)
-      return null;
-    return piece.visibleStart + offset - piece.trackedStart;
-  }
-  return null;
-}
-function projectVisibleRangeToTracked(map3, start, end) {
-  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start)
-    return null;
-  if (start === end) {
-    const offset = projectVisibleOffsetToTracked(map3, start, "upstream");
-    return offset == null ? null : { start: offset, end: offset };
-  }
-  const trackedStart = projectVisibleOffsetToTracked(map3, start, "downstream");
-  const trackedEnd = projectVisibleOffsetToTracked(map3, end, "upstream");
-  if (trackedStart == null || trackedEnd == null || trackedEnd < trackedStart)
-    return null;
-  return { start: trackedStart, end: trackedEnd };
-}
-
 // ../../../v2/document-api-v2-adapter/dist/tracked-changes/range-resolver.js
 function scanParagraphFragments(paragraph4, partBytes, catalogFragments) {
   const paragraphXml = TD107.decode(partBytes.subarray(paragraph4.byteStart, paragraph4.byteEnd));
@@ -369291,7 +370140,7 @@ function scanParagraphFragments(paragraph4, partBytes, catalogFragments) {
         });
       }
     } else if (m[7]) {
-      const decoded = decodeXmlText12(m[9] ?? "");
+      const decoded = decodeXmlText13(m[9] ?? "");
       trackedTextLength += decoded.length;
     }
   }
@@ -369304,7 +370153,7 @@ function findLastStackIndex2(stack, kind) {
   }
   return -1;
 }
-function decodeXmlText12(escaped) {
+function decodeXmlText13(escaped) {
   return escaped.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
 function resolveTextRangeToFragmentOverlaps(input) {
@@ -371773,7 +372622,7 @@ function extractImageRelationshipId(xml) {
 }
 function extractImagePreviewAlt(xml) {
   const docPr = /<[^>]*(?:[\w.-]+:)?docPr\b[^>]*>/i.exec(xml)?.[0] ?? "";
-  const raw = readXmlAttribute4(docPr, "descr") ?? readXmlAttribute4(docPr, "title") ?? readXmlAttribute4(docPr, "name");
+  const raw = readXmlAttribute5(docPr, "descr") ?? readXmlAttribute5(docPr, "title") ?? readXmlAttribute5(docPr, "name");
   const normalized = raw ? decodeXmlAttribute3(raw).trim() : "";
   return normalized.length > 0 ? normalized : null;
 }
@@ -371790,7 +372639,7 @@ function extractImagePreviewExtent(xml) {
     height: Math.max(1, Math.round(cy / EMUS_PER_CSS_PIXEL))
   };
 }
-function readXmlAttribute4(tagXml, localName2) {
+function readXmlAttribute5(tagXml, localName2) {
   const match = new RegExp(`\\b(?:[\\w.-]+:)?${localName2}=["']([^"']*)["']`).exec(tagXml);
   return match?.[1] ?? null;
 }
@@ -372401,7 +373250,7 @@ function buildHeaderFooterLifecyclePlan(base3, target) {
       family: "header-footer-parts",
       partUri: DOCUMENT_RELS_URI2,
       kind: "create",
-      nextBytes: TE61.encode(nextRels),
+      nextBytes: TE62.encode(nextRels),
       contentType: "application/vnd.openxmlformats-package.relationships+xml"
     });
   } else if (nextRels !== baseRels) {
@@ -372409,7 +373258,7 @@ function buildHeaderFooterLifecyclePlan(base3, target) {
       family: "header-footer-parts",
       partUri: DOCUMENT_RELS_URI2,
       kind: "modify",
-      nextBytes: TE61.encode(nextRels)
+      nextBytes: TE62.encode(nextRels)
     });
   }
   const baseContentTypes = TD108.decode(Uint8Array.from(base3.contentTypesBytes));
@@ -372422,7 +373271,7 @@ function buildHeaderFooterLifecyclePlan(base3, target) {
       family: "header-footer-parts",
       partUri: CONTENT_TYPES_URI2,
       kind: "modify",
-      nextBytes: TE61.encode(nextContentTypes)
+      nextBytes: TE62.encode(nextContentTypes)
     });
   }
   return {
@@ -372571,8 +373420,8 @@ function coveredGraphKeys(baseRels, targetRels, baseContentTypes, targetContentT
     }
   }
   const partUris = new Set([
-    ...headerFooterPartsFromDocumentRelationships(TE61.encode(baseRels)).keys(),
-    ...headerFooterPartsFromDocumentRelationships(TE61.encode(targetRels)).keys()
+    ...headerFooterPartsFromDocumentRelationships(TE62.encode(baseRels)).keys(),
+    ...headerFooterPartsFromDocumentRelationships(TE62.encode(targetRels)).keys()
   ]);
   const baseOverrides = headerFooterOverrideRecords(baseContentTypes, partUris);
   const targetOverrides = headerFooterOverrideRecords(targetContentTypes, partUris);
@@ -372595,14 +373444,14 @@ function headerFooterOverrideRecords(xml, partUris) {
 function relationshipSemanticKey(relationship) {
   return JSON.stringify([relationship.id, relationship.type, relationship.target, relationship.targetMode ?? "Internal"]);
 }
-var TD108, TE61, DOCUMENT_RELS_URI2 = "/word/_rels/document.xml.rels", CONTENT_TYPES_URI2 = "/[Content_Types].xml", EMPTY_RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>', HEADER_REL_SUFFIX2 = "/relationships/header", FOOTER_REL_SUFFIX2 = "/relationships/footer", OFFICE_RELATIONSHIPS_NAMESPACES, RELATIONSHIP_REFERENCE_ATTRIBUTES;
+var TD108, TE62, DOCUMENT_RELS_URI2 = "/word/_rels/document.xml.rels", CONTENT_TYPES_URI2 = "/[Content_Types].xml", EMPTY_RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>', HEADER_REL_SUFFIX2 = "/relationships/header", FOOTER_REL_SUFFIX2 = "/relationships/footer", OFFICE_RELATIONSHIPS_NAMESPACES, RELATIONSHIP_REFERENCE_ATTRIBUTES;
 var init_header_footer_lifecycle = __esm(() => {
   init_sd_document_session_internal();
   init_part_fingerprint();
   init_header_footer_parts();
   init_opc_xml();
   TD108 = new TextDecoder;
-  TE61 = new TextEncoder;
+  TE62 = new TextEncoder;
   OFFICE_RELATIONSHIPS_NAMESPACES = new Set([
     "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
     "http://purl.oclc.org/ooxml/officeDocument/relationships"
@@ -372770,8 +373619,8 @@ function buildTrackedTableRowReplayPlan(input) {
   if (input.base.xml === input.target.xml) {
     return { steps: [], bodyOperations: input.bodyOperations, unsafeReasons: [] };
   }
-  const baseBytes = TE62.encode(input.base.xml);
-  const targetBytes = TE62.encode(input.target.xml);
+  const baseBytes = TE63.encode(input.base.xml);
+  const targetBytes = TE63.encode(input.target.xml);
   const baseCatalog = buildTableCatalog({ bytes: baseBytes, storyId: STORY_ID2 });
   const targetCatalog = buildTableCatalog({ bytes: targetBytes, storyId: STORY_ID2 });
   const baseRoot = documentRootContext(input.base.xml);
@@ -373444,10 +374293,10 @@ function escapeRegExp18(value2) {
 function escapeXmlAttribute5(value2) {
   return value2.replaceAll("&", "&amp;").replaceAll('"', "&quot;");
 }
-var TE62, STORY_ID2 = "body:/word/document.xml", WORDPROCESSINGML_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NS = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NS2 = "http://schemas.openxmlformats.org/markup-compatibility/2006", MC_PREFIX_LIST_ATTRIBUTES, MC_QNAME_LIST_ATTRIBUTES, EXACT_ROW_UNSAFE_REVISION_LOCAL_NAMES2, EXACT_ROW_UNSAFE_W14_REVISION_LOCAL_NAMES2;
+var TE63, STORY_ID2 = "body:/word/document.xml", WORDPROCESSINGML_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NS = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NS2 = "http://schemas.openxmlformats.org/markup-compatibility/2006", MC_PREFIX_LIST_ATTRIBUTES, MC_QNAME_LIST_ATTRIBUTES, EXACT_ROW_UNSAFE_REVISION_LOCAL_NAMES2, EXACT_ROW_UNSAFE_W14_REVISION_LOCAL_NAMES2;
 var init_tracked_table_row_replay = __esm(() => {
   init_sd_document_session_internal();
-  TE62 = new TextEncoder;
+  TE63 = new TextEncoder;
   MC_PREFIX_LIST_ATTRIBUTES = new Set(["Ignorable", "MustUnderstand"]);
   MC_QNAME_LIST_ATTRIBUTES = new Set(["PreserveElements", "PreserveAttributes", "ProcessContent"]);
   EXACT_ROW_UNSAFE_REVISION_LOCAL_NAMES2 = new Set([
@@ -373501,7 +374350,7 @@ function read(xml) {
     children2.push(range);
     cursor = range.end;
   }
-  const bytes = TE63.encode(xml);
+  const bytes = TE64.encode(xml);
   const byteOffsets = buildUtf8ByteOffsetTable(xml);
   const tables2 = buildTableCatalog({ bytes, storyId: STORY }).tables;
   if (tables2.some((table) => table.containsNestedTable || !table.isRectangular || table.hasVMerge || table.hasGridSpan))
@@ -373623,11 +374472,11 @@ function buildTrackedTableBlockReplayPlan(input) {
     bodyOperations: input.bodyOperations.filter((operation) => !ownedIds.has(operation.blockId))
   };
 }
-var W21 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", W146 = "http://schemas.microsoft.com/office/word/2010/wordml", STORY = "body:/word/document.xml", TE63, paragraphId2 = (range) => range.tag.attributes.find((attr3) => attr3.namespaceUri === W146 && attr3.localName === "paraId")?.value;
+var W21 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", W146 = "http://schemas.microsoft.com/office/word/2010/wordml", STORY = "body:/word/document.xml", TE64, paragraphId2 = (range) => range.tag.attributes.find((attr3) => attr3.namespaceUri === W146 && attr3.localName === "paraId")?.value;
 var init_tracked_table_block_replay = __esm(() => {
   init_sd_document_session_internal();
   init_tracked_table_row_replay();
-  TE63 = new TextEncoder;
+  TE64 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/comments-replay.js
@@ -373679,7 +374528,7 @@ function validateDiffCommentSource(source, snapshot2, label) {
   return problems;
 }
 function digest5(value2) {
-  return sha256HexSync(TE64.encode(value2));
+  return sha256HexSync(TE65.encode(value2));
 }
 function commentContentSignature(record3) {
   return digest5(`body:${record3.bodyText}#author:${record3.author}#parent:${record3.parentParaId ?? ""}` + `#done:${record3.doneState ? "1" : "0"}#date:${record3.date ?? ""}` + `#anchor:${commentAnchorSignature2(record3.anchor)}`);
@@ -374027,12 +374876,12 @@ function isResolutionSidecarAddition(key2, targetEntry) {
   if (!targetEntry)
     return false;
   if (key2 === "ct:override:/word/commentsExtended.xml") {
-    return targetEntry.semanticKey === key2 && targetEntry.contentSignature === sha256HexSync(TE64.encode("override:/word/commentsExtended.xml=" + "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"));
+    return targetEntry.semanticKey === key2 && targetEntry.contentSignature === sha256HexSync(TE65.encode("override:/word/commentsExtended.xml=" + "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"));
   }
   if (!key2.startsWith("rel:/word/document.xml|"))
     return false;
   const type = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
-  return targetEntry.semanticKey === `/word/document.xml|${type}` && targetEntry.contentSignature === sha256HexSync(TE64.encode(`type:${type}#mode:Internal#target:/word/commentsExtended.xml`));
+  return targetEntry.semanticKey === `/word/document.xml|${type}` && targetEntry.contentSignature === sha256HexSync(TE65.encode(`type:${type}#mode:Internal#target:/word/commentsExtended.xml`));
 }
 function isCommentScopedPackageKey(context, key2, presentInBase, hasCommentCreate, targetEntry) {
   if (key2.startsWith("ct:")) {
@@ -374150,14 +374999,14 @@ function validateAnchorResolvable(context, commentId, anchor) {
   });
   return page.hits.length > 0 ? null : `comment "${commentId}" target text was not found`;
 }
-var TE64;
+var TE65;
 var init_comments_replay = __esm(() => {
   init_sd_document_session_internal();
   init_read();
   init_collect_text_page();
   init_scope2();
   init_part_fingerprint();
-  TE64 = new TextEncoder;
+  TE65 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/styles-replay.js
@@ -374295,8 +375144,8 @@ function snapshotNumberingInventory(snapshot2) {
   return snapshot2.sourceInventory?.families.find((f) => f.family === "numbering") ?? null;
 }
 function capturedNumberingFingerprint(xml) {
-  const partHash = sha256HexSync(TE65.encode(xml));
-  return `fp:${sha256HexSync(TE65.encode(`${NUMBERING_PART_URI}:${partHash}`))}`;
+  const partHash = sha256HexSync(TE66.encode(xml));
+  return `fp:${sha256HexSync(TE66.encode(`${NUMBERING_PART_URI}:${partHash}`))}`;
 }
 function validateNumberingSourceAgainstSnapshot(source, snapshot2, label) {
   const problems = [];
@@ -374339,12 +375188,12 @@ function validateNumberingSourceAgainstSnapshot(source, snapshot2, label) {
   }
   return problems;
 }
-var TD110, TE65;
+var TD110, TE66;
 var init_numbering_replay = __esm(() => {
   init_sd_document_session_internal();
   init_definitions();
   TD110 = new TextDecoder("utf-8", { fatal: false });
-  TE65 = new TextEncoder;
+  TE66 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/settings-replay.js
@@ -374399,7 +375248,7 @@ function hasSettingsRoot(xml) {
   });
   parser.on("opentag", (tag) => {
     if (rootCount === 0) {
-      if (tag.namespaceUri !== W_NS7 && tag.namespaceUri !== STRICT_W_NS || tag.localName !== "settings")
+      if (tag.namespaceUri !== W_NS8 && tag.namespaceUri !== STRICT_W_NS || tag.localName !== "settings")
         valid = false;
       rootCount++;
     }
@@ -374412,7 +375261,7 @@ function hasSettingsRoot(xml) {
   }
   return valid && rootCount === 1;
 }
-var SETTINGS_PART_URI5 = "/word/settings.xml", W_NS7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", STRICT_W_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main", TD111;
+var SETTINGS_PART_URI5 = "/word/settings.xml", W_NS8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", STRICT_W_NS = "http://purl.oclc.org/ooxml/wordprocessingml/main", TD111;
 var init_settings_replay = __esm(() => {
   init_sd_document_session_internal();
   init_definitions();
@@ -374511,7 +375360,7 @@ function paragraphStyleOutlineLevelsFromStylesSource(stylesXml) {
   return stylesXml == null ? new Map : parseParagraphStyleOutlineLevels(stylesXml);
 }
 function projectMainDocumentBodyEntries(source, options = {}) {
-  const bytes = TE66.encode(source.xml);
+  const bytes = TE67.encode(source.xml);
   const paragraphStyleOutlineLevels = options.paragraphStyleOutlineLevels ?? paragraphStyleOutlineLevelMap(source.paragraphStyleOutlineLevels);
   const paragraphIndex = buildParagraphIndex({
     bytes,
@@ -374560,14 +375409,14 @@ function paragraphStyleOutlineLevelMap(record3) {
 function capturedMainDocumentFingerprint(xml) {
   return comparePartXmlFingerprint(MAIN_DOCUMENT_PART_URI, xml);
 }
-var TD112, TE66, MAIN_DOCUMENT_PART_URI = "/word/document.xml", MAIN_DOCUMENT_STORY_ID = "body:/word/document.xml", SNAPSHOT_REVISION = "snapshot";
+var TD112, TE67, MAIN_DOCUMENT_PART_URI = "/word/document.xml", MAIN_DOCUMENT_STORY_ID = "body:/word/document.xml", SNAPSHOT_REVISION = "snapshot";
 var init_main_document_source = __esm(() => {
   init_sd_document_session_internal();
   init_document_reader();
   init_run_signature2();
   init_part_fingerprint();
   TD112 = new TextDecoder("utf-8", { fatal: false });
-  TE66 = new TextEncoder;
+  TE67 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/payloads.js
@@ -377810,7 +378659,7 @@ class V2DiffAdapter {
       family: "tables",
       partUri: DOCUMENT_PART_URI6,
       kind: "modify",
-      nextBytes: TE67.encode(step3.nextXml)
+      nextBytes: TE68.encode(step3.nextXml)
     }));
     const packageRewrites = [
       ...slotPlan.rewrites,
@@ -378398,7 +379247,7 @@ function buildKernelPackageRewrites(styleSteps, numberingSteps, settingsSteps) {
       family: "styles",
       partUri: step3.partUri,
       kind: "modify",
-      nextBytes: TE67.encode(step3.nextXml)
+      nextBytes: TE68.encode(step3.nextXml)
     });
   }
   for (const step3 of numberingSteps) {
@@ -378408,7 +379257,7 @@ function buildKernelPackageRewrites(styleSteps, numberingSteps, settingsSteps) {
       family: "numbering",
       partUri: NUMBERING_PART_URI4,
       kind: "modify",
-      nextBytes: TE67.encode(step3.nextXml)
+      nextBytes: TE68.encode(step3.nextXml)
     });
   }
   for (const step3 of settingsSteps) {
@@ -378416,7 +379265,7 @@ function buildKernelPackageRewrites(styleSteps, numberingSteps, settingsSteps) {
       family: "settings",
       partUri: step3.partUri,
       kind: "modify",
-      nextBytes: TE67.encode(step3.nextXml)
+      nextBytes: TE68.encode(step3.nextXml)
     });
   }
   return rewrites;
@@ -379388,7 +380237,7 @@ function stripRootReplayNamespaceDeclarations(xml) {
   const openEnd = xml.indexOf(">") + 1;
   return stripReplayNamespaceDeclarations(xml.slice(0, openEnd)) + xml.slice(openEnd);
 }
-var FULL_DIFF_APPLY_SUPPORTED_FAMILIES, TE67, TD114, DOCUMENT_PART_URI6 = "/word/document.xml", NUMBERING_PART_URI4 = "/word/numbering.xml", EMPTY_MAIN_DOCUMENT_SOURCE, WORDPROCESSINGML_NS7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NS2 = "http://schemas.microsoft.com/office/word/2010/wordml", WORDPROCESSING_MATH_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math", MARKUP_COMPATIBILITY_NS3 = "http://schemas.openxmlformats.org/markup-compatibility/2006", VML_NS = "urn:schemas-microsoft-com:vml", STRUCTURAL_PARA_EDIT_DELETE_WML_NAMES, STRUCTURAL_PARA_EDIT_DELETE_MATH_NAMES, STRUCTURAL_PARA_FORMAT_EDIT_WML_NAMES;
+var FULL_DIFF_APPLY_SUPPORTED_FAMILIES, TE68, TD114, DOCUMENT_PART_URI6 = "/word/document.xml", NUMBERING_PART_URI4 = "/word/numbering.xml", EMPTY_MAIN_DOCUMENT_SOURCE, WORDPROCESSINGML_NS7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NS2 = "http://schemas.microsoft.com/office/word/2010/wordml", WORDPROCESSING_MATH_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math", MARKUP_COMPATIBILITY_NS3 = "http://schemas.openxmlformats.org/markup-compatibility/2006", VML_NS = "urn:schemas-microsoft-com:vml", STRUCTURAL_PARA_EDIT_DELETE_WML_NAMES, STRUCTURAL_PARA_EDIT_DELETE_MATH_NAMES, STRUCTURAL_PARA_FORMAT_EDIT_WML_NAMES;
 var init_adapter25 = __esm(() => {
   init_tracked_table_property_replay();
   init_src2();
@@ -379428,7 +380277,7 @@ var init_adapter25 = __esm(() => {
     "fields-references",
     "tracked-changes"
   ]);
-  TE67 = new TextEncoder;
+  TE68 = new TextEncoder;
   TD114 = new TextDecoder;
   EMPTY_MAIN_DOCUMENT_SOURCE = { xml: "" };
   STRUCTURAL_PARA_EDIT_DELETE_WML_NAMES = new Set([
@@ -381196,8 +382045,8 @@ function commitTrackedDefinitionMutation(runtime, abstractNumId, txIdPrefix, mut
       const id = reference.tag.attributes.find((attr3) => attr3.namespaceUri === WORDPROCESSINGML_NAMESPACE8 && attr3.localName === "val")?.value;
       if (!id || !numIds.has(id))
         continue;
-      const startByte = TE68.encode(xml.slice(0, reference.start)).length;
-      const endByte = TE68.encode(xml.slice(0, reference.end)).length;
+      const startByte = TE69.encode(xml.slice(0, reference.start)).length;
+      const endByte = TE69.encode(xml.slice(0, reference.end)).length;
       if (!owners.some((owner) => owner.runtime.partUri === partUri && owner.paragraph.byteStart < startByte && owner.paragraph.byteEnd > endByte)) {
         return { ok: false, code: "CAPABILITY_UNAVAILABLE", message: "Tracked shared numbering has an owner outside the editable paragraph stories." };
       }
@@ -381607,7 +382456,7 @@ function commitLocalizedRuntimeMutation(input) {
       paraId: edit.paraId,
       startByte: paragraph4.byteStart,
       endByte: paragraph4.byteEnd,
-      bytes: edit.replacementXml === null ? new Uint8Array : TE68.encode(edit.replacementXml)
+      bytes: edit.replacementXml === null ? new Uint8Array : TE69.encode(edit.replacementXml)
     };
   }).filter((row) => row !== null).sort((left, right) => left.startByte - right.startByte);
   if (patchRows.length !== input.documentEdits.length || patchRows.length === 0) {
@@ -381654,7 +382503,7 @@ function commitLocalizedRuntimeMutation(input) {
         order: 0,
         startByte: 0,
         endByte: currentBytes.length,
-        bytes: TE68.encode(serializeNumberingDocument(input.nextNumbering))
+        bytes: TE69.encode(serializeNumberingDocument(input.nextNumbering))
       }]
     };
   }
@@ -381706,7 +382555,7 @@ function applyParagraphEdits(currentBytes, paragraphs, edits) {
     return {
       startByte: paragraph4.byteStart,
       endByte: paragraph4.byteEnd,
-      bytes: edit.replacementXml === null ? new Uint8Array : TE68.encode(edit.replacementXml)
+      bytes: edit.replacementXml === null ? new Uint8Array : TE69.encode(edit.replacementXml)
     };
   }).filter((entry) => entry !== null).sort((left, right) => left.startByte - right.startByte);
   const chunks = [];
@@ -382263,7 +383112,7 @@ function escapeForRegex2(value2) {
 function createEmptyLevelXml(level, prefix = "w") {
   return `<${prefix}:lvl w:ilvl="${level}"></${prefix}:lvl>`;
 }
-var NUMBERING_PART_URI5 = "/word/numbering.xml", WORDPROCESSINGML_NAMESPACE8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", TE68, TD115;
+var NUMBERING_PART_URI5 = "/word/numbering.xml", WORDPROCESSINGML_NAMESPACE8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", TE69, TD115;
 var init_runtime3 = __esm(() => {
   init_src3();
   init_sd_document_session_internal();
@@ -382273,7 +383122,7 @@ var init_runtime3 = __esm(() => {
   init_xml();
   init_xml_rewrite();
   init_tracked_sequence_edits();
-  TE68 = new TextEncoder;
+  TE69 = new TextEncoder;
   TD115 = new TextDecoder;
 });
 
@@ -384328,7 +385177,7 @@ function resolveStoryIdForParagraphInStory(context, paraId, story) {
   const storyId = resolveStoryIdForListRange(context, story);
   if (!storyId)
     return null;
-  const entry = paragraphIndexForStory2(context, storyId)?.byParaId(paraId) ?? null;
+  const entry = paragraphIndexForStory3(context, storyId)?.byParaId(paraId) ?? null;
   return entry?.storyId === storyId ? storyId : null;
 }
 function resolveStoryIdForListRange(context, story) {
@@ -384402,7 +385251,7 @@ function resolveParagraphIdsForTarget(context, target) {
   const toEntry = findParagraphEntry(context, toId);
   if (!fromEntry || !toEntry || fromEntry.storyId !== toEntry.storyId)
     return [];
-  const index2 = paragraphIndexForStory2(context, fromEntry.storyId);
+  const index2 = paragraphIndexForStory3(context, fromEntry.storyId);
   if (!index2)
     return [];
   const start = index2.entries.findIndex((entry) => entry.blockId === fromId);
@@ -384807,7 +385656,7 @@ function findPreviousListItemId(context, paraId) {
   const storyId = resolveStoryIdForParagraph(context, paraId);
   if (!storyId)
     return null;
-  const index2 = paragraphIndexForStory2(context, storyId);
+  const index2 = paragraphIndexForStory3(context, storyId);
   if (!index2)
     return null;
   const targetIndex = index2.entries.findIndex((entry) => entry.blockId === paraId && entry.storyId === storyId);
@@ -384841,7 +385690,7 @@ function compatibleMergeParaIds(context, storyId, paraIds, options) {
   const authorName = tracked ? readTrackedAuthor(context).name : "";
   if (tracked && authorName.length === 0)
     return [];
-  const index2 = paragraphIndexForStory2(context, storyId);
+  const index2 = paragraphIndexForStory3(context, storyId);
   if (!index2)
     return [];
   for (const paraId of paraIds) {
@@ -384862,7 +385711,7 @@ function compatibleMergeParaIds(context, storyId, paraIds, options) {
   return paraIds;
 }
 function findImmediatelyAdjacentCompatibleListReuse(context, storyId, paraIds, seed, ilvl, requestedPreset) {
-  const index2 = paragraphIndexForStory2(context, storyId);
+  const index2 = paragraphIndexForStory3(context, storyId);
   if (!index2 || paraIds.length === 0)
     return;
   const targetIndexes = paraIds.map((paraId) => index2.entries.findIndex((entry) => entry.blockId === paraId && entry.storyId === storyId));
@@ -384995,7 +385844,7 @@ function canReuseAdjacentListDefinition(context, definitionNumId, abstractNumId,
   }
   return Array.from(abstract.levels.values()).every((level) => !level.isLgl && !/\blgl\b/i.test(level.numFmt));
 }
-function paragraphIndexForStory2(context, storyId) {
+function paragraphIndexForStory3(context, storyId) {
   return getSDDocumentSessionInternalStoryParagraphIndex(context.session, storyId);
 }
 function findParagraphEntry(context, paraId) {
@@ -386491,7 +387340,7 @@ function detectTargetConflicts(context, steps, failures) {
       const key2 = `${storyKeyForTarget(target)}::${target.blockId}`;
       const { from, to } = conflictRangeForResolution(context, step3, resolution);
       for (const prior of claimedByKey.get(key2) ?? []) {
-        if (rangesOverlap10(from, to, prior.from, prior.to)) {
+        if (rangesOverlap11(from, to, prior.from, prior.to)) {
           failures.push({
             code: "PLAN_CONFLICT_OVERLAP",
             stepId: step3.stepId,
@@ -387487,7 +388336,7 @@ function paragraphOrdinalForTarget(context, target) {
   const index2 = isMainStoryId(story.storyId) ? getSDDocumentSessionInternalParagraphIndex(context.session) : getSDDocumentSessionInternalStoryParagraphIndex(context.session, story.storyId);
   return index2?.byParaId(target.blockId)?.ordinal ?? -1;
 }
-function rangesOverlap10(start, end, otherStart, otherEnd) {
+function rangesOverlap11(start, end, otherStart, otherEnd) {
   return start < otherEnd && end > otherStart;
 }
 function elapsed(startedAt) {
@@ -389156,7 +390005,7 @@ class V2HyperlinksAdapter {
     if (!paragraph4) {
       return mutationFailure4("TARGET_NOT_FOUND", `Block "${resolved.startBlockId}" was not found.`);
     }
-    const existingOverlap = readBodyHyperlinkEntries(this.context).some((entry) => entry.address.anchor.start.blockId === paragraph4.blockId && rangesOverlap11(entry.address.anchor.start.offset, entry.address.anchor.end.offset, resolved.startOffset, resolved.endOffset));
+    const existingOverlap = readBodyHyperlinkEntries(this.context).some((entry) => entry.address.anchor.start.blockId === paragraph4.blockId && rangesOverlap12(entry.address.anchor.start.offset, entry.address.anchor.end.offset, resolved.startOffset, resolved.endOffset));
     if (existingOverlap) {
       return mutationFailure4("INVALID_TARGET", "hyperlinks.wrap does not support ranges that overlap an existing hyperlink.");
     }
@@ -389485,7 +390334,7 @@ class V2HyperlinksAdapter {
         after: {
           partUri: entry.partUri,
           startByte: entry.descriptor.byteStart,
-          endByte: entry.descriptor.byteEnd + TE69.encode(nextHyperlinkXml).length - TE69.encode(hyperlinkXml).length
+          endByte: entry.descriptor.byteEnd + TE70.encode(nextHyperlinkXml).length - TE70.encode(hyperlinkXml).length
         },
         ...input.patch.rel !== undefined ? { rel: input.patch.rel } : {}
       }],
@@ -389767,7 +390616,7 @@ function hyperlinkSessionAnchor(partUri, descriptor) {
 }
 function createdHyperlinkAnchor(paragraph4, nextParagraphXml, nextDocumentXml, start, end) {
   const catalog = buildHyperlinkCatalog({
-    bytes: TE69.encode(nextDocumentXml),
+    bytes: TE70.encode(nextDocumentXml),
     storyId: paragraph4.storyId,
     partUri: paragraph4.partUri,
     relsBytes: null
@@ -389988,7 +390837,7 @@ function operationError12(code2, message, operationId) {
   error48.details = { operationId };
   return error48;
 }
-function rangesOverlap11(startA, endA, startB, endB) {
+function rangesOverlap12(startA, endA, startB, endB) {
   return startA < endB && startB < endA;
 }
 function relsPartUriForPart2(partUri) {
@@ -390092,7 +390941,7 @@ function escapeRegex15(value2) {
 function defaultRelationshipsXml3() {
   return '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
 }
-var HYPERLINK_REL_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", TD120, TE69;
+var HYPERLINK_REL_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", TD120, TE70;
 var init_adapter34 = __esm(() => {
   init_sd_document_session_internal();
   init_inline();
@@ -390103,7 +390952,7 @@ var init_adapter34 = __esm(() => {
   init_stories();
   init_registry3();
   TD120 = new TextDecoder;
-  TE69 = new TextEncoder;
+  TE70 = new TextEncoder;
 });
 
 // ../../../v2/document-api-v2-adapter/dist/watermarks/serialization.js
@@ -394298,75 +395147,6 @@ var init_parse5 = __esm(() => {
   init_plan3();
 });
 
-// ../../../v2/document-api-v2-adapter/dist/selection/footnote-range.js
-function resolveFootnoteRangeIndex(session, index2, start, end) {
-  if (start.story.storyType !== "footnote" || end.story.storyType !== "footnote")
-    return null;
-  const main = getSDDocumentSessionInternalSourceSignalsSnapshot(session)?.stories.find((story) => story.storyKind === "main");
-  const bytes = getSDDocumentSessionInternalPartBytes(session, FOOTNOTES_PART_URI3);
-  if (!main || main.completeness.noteAnchorRefs !== "complete" || !bytes)
-    return null;
-  const xml = new TextDecoder().decode(bytes);
-  const parsed = collectXmlElementRanges(xml);
-  if (parsed.errors.length)
-    return null;
-  const notes = parsed.ranges.filter(({ tag }) => tag.namespaceUri === W_NS8 && tag.localName === "footnote").sort((a, b) => a.start - b.start);
-  const sourceEntries = [...index2.entries].sort((a, b) => a.byteStart - b.byteStart);
-  const groups = new Map;
-  let charCursor = 0;
-  let byteCursor = bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? 3 : 0;
-  let entryCursor = 0;
-  for (const note of notes) {
-    const id = readXmlAttributes(note.tag, W_NS8, "id")[0]?.value;
-    if (!id || groups.has(id))
-      return null;
-    byteCursor += TE70.encode(xml.slice(charCursor, note.start)).byteLength;
-    const byteStart = byteCursor;
-    byteCursor += TE70.encode(xml.slice(note.start, note.end)).byteLength;
-    charCursor = note.end;
-    const group = [];
-    while (entryCursor < sourceEntries.length && sourceEntries[entryCursor].byteStart < byteCursor) {
-      const entry = sourceEntries[entryCursor++];
-      if (entry.byteStart >= byteStart && entry.byteEnd <= byteCursor)
-        group.push(entry);
-    }
-    groups.set(id, group);
-  }
-  const entries = [];
-  const seen = new Set;
-  let startOwned = false;
-  let endOwned = false;
-  const references = [...main.noteAnchorRefs].sort((a, b) => (a.bodyChildOrdinal ?? 0) - (b.bodyChildOrdinal ?? 0) || (a.sourceAnchor.stability === "byte-span" ? a.sourceAnchor.byteSpan[0] : 0) - (b.sourceAnchor.stability === "byte-span" ? b.sourceAnchor.byteSpan[0] : 0));
-  for (const ref5 of references) {
-    if (ref5.kind !== "footnote" || !ref5.nativeId || ref5.trackedChangeState === "deleted" || ref5.trackedChangeState === "move-from" || seen.has(ref5.nativeId))
-      continue;
-    seen.add(ref5.nativeId);
-    const group = groups.get(ref5.nativeId);
-    if (!group)
-      return null;
-    for (const entry of group) {
-      startOwned || (startOwned = ref5.nativeId === start.story.noteId && entry.blockId === start.blockId);
-      endOwned || (endOwned = ref5.nativeId === end.story.noteId && entry.blockId === end.blockId);
-      entries.push({ ...entry, ordinal: entries.length });
-    }
-  }
-  if (!startOwned || !endOwned)
-    return null;
-  const byBlockId = new Map(entries.map((entry) => [entry.blockId, entry]));
-  return {
-    entries,
-    duplicateParaIds: index2.duplicateParaIds,
-    entriesByBlockId: byBlockId,
-    byParaId: (blockId) => byBlockId.get(blockId) ?? null
-  };
-}
-var W_NS8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", TE70;
-var init_footnote_range = __esm(() => {
-  init_sd_document_session_internal();
-  init_note_story();
-  TE70 = new TextEncoder;
-});
-
 // ../../../v2/document-api-v2-adapter/dist/clipboard/serialize.js
 class SelectionHyperlinkDescriptorResolver {
   constructor(context, storyId) {
@@ -394855,7 +395635,7 @@ function serializeSelectedDrawing(input) {
     return fail6("inline-object", "Inline objects (drawings, pictures, embedded objects) are not preserved by copy.");
   if (/<[\w.-]+:srcRect\b/.test(xml))
     return fail6("cropped-image", "Cropped images are not preserved by copy.");
-  const rId = readXmlAttribute5(xml, "blip", "embed", "r");
+  const rId = readXmlAttribute6(xml, "blip", "embed", "r");
   if (!rId)
     return fail6("inline-object", "Inline objects (drawings, pictures, embedded objects) are not preserved by copy.");
   const mediaPartUri = resolveImageRelationship(input.context, input.storyPartUri, rId);
@@ -394946,9 +395726,9 @@ function clampImageDimension(value2) {
   return Math.max(1, Math.min(1e4, Number.isFinite(value2) ? value2 : 1));
 }
 function boundedAttribute(xml, tag, attribute2) {
-  return readXmlAttribute5(xml, tag, attribute2)?.slice(0, MAX_IMAGE_METADATA_CHARS) || undefined;
+  return readXmlAttribute6(xml, tag, attribute2)?.slice(0, MAX_IMAGE_METADATA_CHARS) || undefined;
 }
-function readXmlAttribute5(xml, tag, attribute2, prefix) {
+function readXmlAttribute6(xml, tag, attribute2, prefix) {
   const open2 = new RegExp(`<[\\w.-]+:${tag}\\b[^>]*>`).exec(xml)?.[0];
   return open2 ? readBareAttribute(open2, prefix ? `${prefix}:${attribute2}` : attribute2) : null;
 }
@@ -401166,538 +401946,6 @@ var init_prepared_mutation2 = __esm(() => {
   ]);
 });
 
-// ../../../v2/document-api-v2-adapter/dist/selection/live-selection.js
-function distinctFootnotes(start, end) {
-  return start.storyType === "footnote" && end.storyType === "footnote" && start.noteId !== end.noteId;
-}
-function buildVisibleSelectionTarget(story, start, end) {
-  return {
-    kind: "selection",
-    start: { kind: "text", blockId: start.blockId, offset: start.offset, story: start.story ?? story },
-    end: { kind: "text", blockId: end.blockId, offset: end.offset, story: end.story ?? story },
-    ...distinctFootnotes(start.story ?? story, end.story ?? story) ? {} : { story }
-  };
-}
-function buildSelectionTarget(session, story, start, end, entries) {
-  const hasTrackedEndpoint = start.trackedOffset != null || end.trackedOffset != null;
-  if (!hasTrackedEndpoint)
-    return buildVisibleSelectionTarget(story, start, end);
-  const startEntry = entries[0];
-  const endEntry = entries[entries.length - 1];
-  if (!startEntry || !endEntry)
-    return null;
-  const startMap = readParagraphInlineMap(session, startEntry);
-  const endMap = startEntry === endEntry ? startMap : readParagraphInlineMap(session, endEntry);
-  if (!startMap || !endMap)
-    return null;
-  const resolvedStart = resolveTrackedSelectionEndpoint(startMap, start, "upstream");
-  const resolvedEnd = resolveTrackedSelectionEndpoint(endMap, end, "downstream");
-  if (resolvedStart == null || resolvedEnd == null) {
-    return null;
-  }
-  const [orderedStart2, orderedEnd] = start.blockId === end.blockId && resolvedEnd < resolvedStart ? [resolvedEnd, resolvedStart] : [resolvedStart, resolvedEnd];
-  return {
-    kind: "selection",
-    start: { kind: "text", blockId: start.blockId, offset: orderedStart2, story: start.story ?? story },
-    end: { kind: "text", blockId: end.blockId, offset: orderedEnd, story: end.story ?? story },
-    ...distinctFootnotes(start.story ?? story, end.story ?? story) ? {} : { story },
-    coordinateSpace: "tracked"
-  };
-}
-function readParagraphInlineMap(session, entry) {
-  const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
-  if (!bytes)
-    return null;
-  return parseParagraphInlineMap(TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
-}
-function resolveTrackedSelectionEndpoint(map3, point3, bias) {
-  if (point3.trackedOffset != null) {
-    return Number.isInteger(point3.trackedOffset) && point3.trackedOffset >= 0 && point3.trackedOffset <= map3.trackedLength ? point3.trackedOffset : null;
-  }
-  return projectVisibleOffsetToTracked(map3, clampOffset(point3.offset, map3.visibleLength), bias);
-}
-function resolveBrowserLiveSelectionParagraphIndex(session, story, startBlockId, endBlockId) {
-  const mainIndex = getSDDocumentSessionInternalParagraphIndex(session);
-  const stories = listSDDocumentSessionInternalStories(session);
-  if (!story || story.storyType === "body") {
-    return hasSelectionBlocks(mainIndex, startBlockId, endBlockId) ? mainIndex : null;
-  }
-  if (story.storyType === "headerFooterPart") {
-    const resolved = getSDDocumentSessionInternalHeaderFooterPartUriForRefId(session, story.refId);
-    if (!resolved)
-      return null;
-    const match = stories.find((candidate2) => candidate2.partUri === resolved.partUri);
-    if (!match)
-      return null;
-    return paragraphIndexForStory3(session, match.storyId, mainIndex);
-  }
-  const candidates = stories.filter((candidate2) => storyCandidateMatches(candidate2, story));
-  for (const candidate2 of candidates) {
-    const index2 = paragraphIndexForStory3(session, candidate2.storyId, mainIndex);
-    if (hasSelectionBlocks(index2, startBlockId, endBlockId))
-      return index2;
-  }
-  return null;
-}
-function paragraphIndexForStory3(session, storyId, mainIndex) {
-  if (mainIndex?.entries[0]?.storyId === storyId)
-    return mainIndex;
-  return getSDDocumentSessionInternalStoryParagraphIndex(session, storyId);
-}
-function storyCandidateMatches(candidate2, story) {
-  switch (story.storyType) {
-    case "headerFooterSlot":
-      return candidate2.storyKind === story.headerFooterKind;
-    case "footnote":
-      return candidate2.storyKind === "footnotes";
-    case "endnote":
-      return candidate2.storyKind === "endnotes";
-    case "textbox":
-      return candidate2.storyKind === "textbox" && candidate2.textboxId === story.textboxId;
-    default:
-      return false;
-  }
-}
-function hasSelectionBlocks(index2, startBlockId, endBlockId) {
-  return Boolean(index2?.byParaId(startBlockId) && index2.byParaId(endBlockId));
-}
-function clampOffset(offset, textLength) {
-  return Math.max(0, Math.min(textLength, offset));
-}
-function resolveEntries(session, input) {
-  let index2 = resolveBrowserLiveSelectionParagraphIndex(session, input.story, input.start.blockId, input.end.blockId);
-  if (!index2)
-    return null;
-  const startStory = input.start.story ?? input.story;
-  const endStory = input.end.story ?? input.story;
-  if (distinctFootnotes(startStory, endStory)) {
-    index2 = resolveFootnoteRangeIndex(session, index2, { blockId: input.start.blockId, story: startStory }, { blockId: input.end.blockId, story: endStory });
-    if (!index2)
-      return null;
-  }
-  if (index2.duplicateParaIds.has(input.start.blockId) || index2.duplicateParaIds.has(input.end.blockId))
-    return null;
-  let startEntry = index2.byParaId(input.start.blockId);
-  let endEntry = index2.byParaId(input.end.blockId);
-  if (!startEntry || !endEntry || startEntry.storyId !== endEntry.storyId)
-    return null;
-  let startPoint = input.start;
-  let endPoint = input.end;
-  if (startEntry.ordinal > endEntry.ordinal) {
-    [startEntry, endEntry] = [endEntry, startEntry];
-    [startPoint, endPoint] = [endPoint, startPoint];
-  }
-  const entries = index2.entries.slice(startEntry.ordinal, endEntry.ordinal + 1);
-  if (entries.length === 0)
-    return null;
-  const visibleStart = resolveVisibleSelectionOffset(session, startEntry, startPoint);
-  const visibleEnd = resolveVisibleSelectionOffset(session, endEntry, endPoint);
-  if (visibleStart == null || visibleEnd == null)
-    return null;
-  const segments = entries.map((entry, idx) => {
-    const start = idx === 0 ? visibleStart : 0;
-    const end = idx === entries.length - 1 ? visibleEnd : entry.textLength;
-    return {
-      blockId: entry.blockId,
-      range: { start, end: Math.max(start, end) }
-    };
-  });
-  return {
-    target: {
-      kind: "text",
-      segments,
-      ...input.story ? { story: input.story } : {}
-    },
-    entries,
-    start: startPoint,
-    end: endPoint
-  };
-}
-function resolveVisibleSelectionOffset(session, entry, point3) {
-  if (point3.trackedOffset == null)
-    return clampOffset(point3.offset, entry.textLength);
-  const map3 = readParagraphInlineMap(session, entry);
-  return map3 ? projectTrackedOffsetToVisible(map3, point3.trackedOffset) : null;
-}
-function resolveBrowserLiveSelectionForSession(session, input, options = {}) {
-  const resolved = resolveEntries(session, input);
-  if (!resolved)
-    return null;
-  const selectionTarget = buildSelectionTarget(session, input.story, resolved.start, resolved.end, resolved.entries);
-  if (!selectionTarget)
-    return null;
-  const reviewIds = readActiveReviewIds(session, resolved.entries, resolved.target.segments, options);
-  return {
-    target: distinctFootnotes(resolved.start.story ?? input.story, resolved.end.story ?? input.story) ? null : resolved.target,
-    selectionTarget,
-    text: input.includeText === true ? readSelectionText(session, resolved.entries, resolved.target.segments) : "",
-    activeMarks: readActiveMarks(session, resolved.entries, resolved.target.segments),
-    activeCommentIds: reviewIds.activeCommentIds,
-    activeChangeIds: reviewIds.activeChangeIds
-  };
-}
-function readSelectionText(session, entries, segments) {
-  const slices = [];
-  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
-    const entry = entries[i2];
-    const segment = segments[i2];
-    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
-    if (!bytes)
-      return "";
-    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
-    const paragraphText3 = visibleParagraphTextFromXml(xml);
-    const start = clampOffset(segment.range.start, paragraphText3.length);
-    const end = clampOffset(segment.range.end, paragraphText3.length);
-    slices.push(paragraphText3.slice(start, Math.max(start, end)));
-  }
-  return slices.join(" ");
-}
-function readActiveMarks(session, entries, segments) {
-  let common = null;
-  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
-    const entry = entries[i2];
-    const segment = segments[i2];
-    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
-    if (!bytes)
-      return [];
-    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
-    const paragraphText3 = visibleParagraphTextFromXml(xml);
-    const start = clampOffset(segment.range.start, paragraphText3.length);
-    const end = clampOffset(segment.range.end, paragraphText3.length);
-    const marks = new Set(activeMarksForParagraphXmlRange(xml, start, Math.max(start, end)));
-    common = common == null ? marks : intersectStringSets(common, marks);
-  }
-  if (!common)
-    return [];
-  return ACTIVE_MARK_ORDER.filter((mark) => common.has(mark));
-}
-function readActiveReviewIds(session, entries, segments, options) {
-  return {
-    activeCommentIds: readActiveCommentIds(session, segments),
-    activeChangeIds: readActiveChangeIds(session, entries, segments, options)
-  };
-}
-function readActiveCommentIds(session, segments) {
-  const catalog = getSDDocumentSessionInternalCommentsCatalog(session);
-  if (!catalog)
-    return [];
-  const anchorIndex = getSDDocumentSessionInternalCommentAnchorIndex(session);
-  const ids = [];
-  for (const [sourceWId, hits] of anchorIndex.hitsBySourceWId) {
-    const catalogEntries = catalog.commentsBySourceWId.get(sourceWId);
-    if (!catalogEntries || catalogEntries.length === 0)
-      continue;
-    let overlaps2 = false;
-    for (const hit of hits) {
-      for (const hitSegment of hit.segments) {
-        if (!hitSegment.blockId)
-          continue;
-        const selectionSegment = segments.find((segment) => segment.blockId === hitSegment.blockId);
-        if (!selectionSegment)
-          continue;
-        if (rangesOverlap12(hitSegment.start, hitSegment.end, selectionSegment.range.start, selectionSegment.range.end)) {
-          overlaps2 = true;
-          break;
-        }
-      }
-      if (overlaps2)
-        break;
-    }
-    if (!overlaps2)
-      continue;
-    for (const entry of catalogEntries)
-      pushUnique(ids, entry.commentId);
-  }
-  return ids;
-}
-function readActiveChangeIds(session, entries, segments, options) {
-  const activeSourceIds = new Set;
-  for (let i2 = 0;i2 < entries.length && i2 < segments.length; i2 += 1) {
-    const entry = entries[i2];
-    const segment = segments[i2];
-    const bytes = getSDDocumentSessionInternalPartBytes(session, entry.partUri);
-    if (!bytes)
-      return [];
-    const xml = TEXT_DECODER7.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
-    const paragraphText3 = visibleParagraphTextFromXml(xml);
-    const start = clampOffset(segment.range.start, paragraphText3.length);
-    const end = clampOffset(segment.range.end, paragraphText3.length);
-    for (const sourceId of activeTrackedChangeSourceIdsForParagraphXmlRange(xml, start, Math.max(start, end))) {
-      activeSourceIds.add(sourceId);
-    }
-  }
-  if (activeSourceIds.size === 0)
-    return [];
-  const resolved = options.resolveTrackChangeIds?.(activeSourceIds);
-  if (resolved)
-    return [...new Set(resolved)];
-  const sourceIdToChangeIds = buildTrackedChangeSourceMap(options.trackChangesList?.()?.items ?? []);
-  if (sourceIdToChangeIds.size === 0)
-    return [];
-  const out = [];
-  for (const sourceId of activeSourceIds) {
-    const changeIds = sourceIdToChangeIds.get(sourceId);
-    if (!changeIds)
-      continue;
-    for (const changeId of changeIds)
-      pushUnique(out, changeId);
-  }
-  return out;
-}
-function buildTrackedChangeSourceMap(items) {
-  const map3 = new Map;
-  for (const item of items) {
-    if (!item || typeof item !== "object")
-      continue;
-    const record3 = item;
-    const id = typeof record3.id === "string" ? record3.id : null;
-    if (!id)
-      continue;
-    const sourceIds = record3.sourceIds && typeof record3.sourceIds === "object" ? record3.sourceIds : {};
-    const wordRevisionIds = record3.wordRevisionIds && typeof record3.wordRevisionIds === "object" ? record3.wordRevisionIds : {};
-    pushTrackedSourceMap(map3, sourceIds.wordIdInsert, id);
-    pushTrackedSourceMap(map3, sourceIds.wordIdDelete, id);
-    for (const sourceId of Array.isArray(sourceIds.wordIdOther) ? sourceIds.wordIdOther : []) {
-      pushTrackedSourceMap(map3, sourceId, id);
-    }
-    pushTrackedSourceMap(map3, wordRevisionIds.insert, id);
-    pushTrackedSourceMap(map3, wordRevisionIds.delete, id);
-    pushTrackedSourceMap(map3, wordRevisionIds.format, id);
-  }
-  return map3;
-}
-function pushTrackedSourceMap(map3, sourceId, changeId) {
-  if (typeof sourceId !== "string" || sourceId.length === 0)
-    return;
-  const ids = map3.get(sourceId) ?? [];
-  pushUnique(ids, changeId);
-  map3.set(sourceId, ids);
-}
-function visibleParagraphTextFromXml(xml) {
-  const stripped = stripTextboxContent2(stripParagraphProperties3(stripDeletedRevisions(xml)));
-  let out = "";
-  for (const token of stripped.matchAll(/<[\w.-]+:t\b[^>]*>([\s\S]*?)<\/[\w.-]+:t>|<[\w.-]+:(tab|br|cr)\b[^>]*\/>/g)) {
-    if (token[1] != null) {
-      out += decodeXmlText13(token[1]);
-      continue;
-    }
-    out += token[2] === "tab" ? "\t" : `
-`;
-  }
-  return out;
-}
-function visibleRunMarkSlicesFromXml(xml) {
-  const stripped = stripTextboxContent2(stripParagraphProperties3(stripDeletedRevisions(xml)));
-  const slices = [];
-  let cursor = 0;
-  for (const match of stripped.matchAll(/<(?:[\w.-]+:)?r\b[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?r>/g)) {
-    const runXml = match[0];
-    const textLength = visibleParagraphTextFromXml(runXml).length;
-    if (textLength > 0) {
-      slices.push({ start: cursor, end: cursor + textLength, marks: activeMarksForRunXml(runXml) });
-    }
-    cursor += textLength;
-  }
-  return slices;
-}
-function activeMarksForRunXml(runXml) {
-  const rPr = findFirstElement(runXml, "rPr")?.xml ?? "";
-  if (!rPr)
-    return [];
-  const marks = [];
-  if (hasOnOffRunProperty(rPr, "b"))
-    marks.push("bold");
-  if (hasOnOffRunProperty(rPr, "i"))
-    marks.push("italic");
-  if (hasOnOffRunProperty(rPr, "u"))
-    marks.push("underline");
-  if (hasOnOffRunProperty(rPr, "strike"))
-    marks.push("strikethrough");
-  return marks;
-}
-function hasOnOffRunProperty(rPrXml, localName2) {
-  const match = rPrXml.match(new RegExp(`<(?:[\\w.-]+:)?${localName2}\\b([^>]*)\\/?>`, "i"));
-  if (!match)
-    return false;
-  const attrs = match[1] ?? "";
-  const val = attrs.match(/(?:^|\s)(?:[\w.-]+:)?val=(["'])(.*?)\1/i)?.[2]?.toLowerCase();
-  return val !== "0" && val !== "false" && val !== "off" && val !== "none";
-}
-function activeMarksForParagraphXmlRange(xml, start, end) {
-  const slices = visibleRunMarkSlicesFromXml(xml);
-  if (slices.length === 0)
-    return [];
-  if (start === end) {
-    const containing = slices.find((slice) => start > slice.start && start < slice.end);
-    if (containing)
-      return containing.marks;
-    let previous3 = null;
-    for (const slice of slices) {
-      if (slice.end <= start)
-        previous3 = slice;
-    }
-    if (previous3)
-      return previous3.marks;
-    return slices[0]?.marks ?? [];
-  }
-  let common = null;
-  for (const slice of slices) {
-    if (Math.max(start, slice.start) >= Math.min(end, slice.end))
-      continue;
-    const marks = new Set(slice.marks);
-    common = common == null ? marks : intersectStringSets(common, marks);
-  }
-  if (!common)
-    return [];
-  return ACTIVE_MARK_ORDER.filter((mark) => common.has(mark));
-}
-function activeTrackedChangeSourceIdsForParagraphXmlRange(xml, start, end) {
-  const slices = visibleTrackedChangeSourceSlicesFromXml(xml);
-  if (slices.length === 0)
-    return [];
-  const out = [];
-  for (const slice of slices) {
-    if (!rangesOverlap12(slice.start, slice.end, start, end))
-      continue;
-    for (const sourceId of slice.sourceIds)
-      pushUnique(out, sourceId);
-  }
-  return out;
-}
-function visibleTrackedChangeSourceSlicesFromXml(xml) {
-  const stripped = stripTextboxContent2(stripParagraphProperties3(xml));
-  const slices = [];
-  const activeSourceIdStack = [];
-  const elementStack = [];
-  let delDepth = 0;
-  let cursor = 0;
-  const tokenRe = /<\/(?:[\w.-]+:)?(ins|del|moveFrom|moveTo)>|<(?:[\w.-]+:)?t\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?t>|<(?:[\w.-]+:)?delText\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?delText>|<(?:[\w.-]+:)?(ins|del|moveFrom|moveTo|tab|br|cr)\b([^>]*)\/?>/g;
-  for (const match of stripped.matchAll(tokenRe)) {
-    const closingName = match[1];
-    const tText = match[2];
-    const delText = match[3];
-    const openingName = match[4];
-    const attrs = match[5] ?? "";
-    if (closingName) {
-      const frame = elementStack.pop();
-      if (frame?.hadId)
-        activeSourceIdStack.pop();
-      if (closingName === "del")
-        delDepth = Math.max(0, delDepth - 1);
-      continue;
-    }
-    if (tText != null) {
-      if (delDepth > 0) {
-        pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
-      } else {
-        cursor = pushTrackedSourceSlice(slices, cursor, decodeXmlText13(tText).length, activeSourceIdStack);
-      }
-      continue;
-    }
-    if (delText != null) {
-      pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
-      continue;
-    }
-    if (!openingName)
-      continue;
-    if (openingName === "tab" || openingName === "br" || openingName === "cr") {
-      if (delDepth > 0) {
-        pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIdStack);
-      } else {
-        cursor = pushTrackedSourceSlice(slices, cursor, 1, activeSourceIdStack);
-      }
-      continue;
-    }
-    const sourceId = readXmlAttribute6(attrs, "id");
-    const selfClosing = match[0].endsWith("/>");
-    if (!selfClosing) {
-      elementStack.push({ name: openingName, hadId: Boolean(sourceId) });
-      if (sourceId)
-        activeSourceIdStack.push(sourceId);
-      if (openingName === "del")
-        delDepth += 1;
-    }
-  }
-  return slices;
-}
-function pushTrackedSourceSlice(slices, cursor, textLength, activeSourceIds) {
-  if (textLength <= 0)
-    return cursor;
-  if (activeSourceIds.length > 0) {
-    slices.push({ start: cursor, end: cursor + textLength, sourceIds: [...new Set(activeSourceIds)] });
-  }
-  return cursor + textLength;
-}
-function pushZeroWidthTrackedSourceSlice(slices, cursor, activeSourceIds) {
-  if (activeSourceIds.length === 0)
-    return;
-  slices.push({ start: cursor, end: cursor, sourceIds: [...new Set(activeSourceIds)] });
-}
-function readXmlAttribute6(attrs, localName2) {
-  const match = attrs.match(new RegExp(`(?:^|\\s)(?:[\\w.-]+:)?${localName2}=(["'])(.*?)\\1`, "i"));
-  return match?.[2] ?? null;
-}
-function rangesOverlap12(aStart, aEnd, bStart, bEnd) {
-  const leftStart = Math.min(aStart, aEnd);
-  const leftEnd = Math.max(aStart, aEnd);
-  const rightStart = Math.min(bStart, bEnd);
-  const rightEnd = Math.max(bStart, bEnd);
-  if (rightStart === rightEnd)
-    return rightStart >= leftStart && rightStart <= leftEnd;
-  if (leftStart === leftEnd)
-    return leftStart >= rightStart && leftStart <= rightEnd;
-  return Math.max(leftStart, rightStart) < Math.min(leftEnd, rightEnd);
-}
-function intersectStringSets(left, right) {
-  const out = new Set;
-  for (const value2 of left) {
-    if (right.has(value2))
-      out.add(value2);
-  }
-  return out;
-}
-function stripParagraphProperties3(xml) {
-  return stripElements(xml, "pPr");
-}
-function stripDeletedRevisions(xml) {
-  return xml.replace(/<[\w.-]+:del\b(?![^>]*\/>)[^>]*>[\s\S]*?<\/[\w.-]+:del>/g, "");
-}
-function stripTextboxContent2(xml) {
-  return xml.replace(/<(?:[\w.-]+:)?txbxContent\b[^>]*>[\s\S]*?<\/(?:[\w.-]+:)?txbxContent>/g, "").replace(/<(?:[\w.-]+:)?txbxContent\b[^>]*>[\s\S]*$/g, "");
-}
-function decodeXmlText13(escaped) {
-  return escaped.replace(/&(lt|gt|amp|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (_, entity) => {
-    switch (entity) {
-      case "lt":
-        return "<";
-      case "gt":
-        return ">";
-      case "amp":
-        return "&";
-      case "quot":
-        return '"';
-      case "apos":
-        return "'";
-      default: {
-        const cp = entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
-        return Number.isFinite(cp) ? String.fromCodePoint(cp) : `&${entity};`;
-      }
-    }
-  });
-}
-function pushUnique(out, id) {
-  if (typeof id === "string" && id.length > 0 && !out.includes(id))
-    out.push(id);
-}
-var TEXT_DECODER7, ACTIVE_MARK_ORDER;
-var init_live_selection = __esm(() => {
-  init_sd_document_session_internal();
-  init_sd_document_session_internal();
-  init_footnote_range();
-  TEXT_DECODER7 = new TextDecoder;
-  ACTIVE_MARK_ORDER = ["bold", "italic", "underline", "strikethrough"];
-});
-
 // ../../../v2/document-api-v2-adapter/dist/selection/story-text-extent.js
 async function resolveBrowserStoryTextExtentForSession(session, input, options) {
   try {