@superdoc/mcp 1.4.0-next.7 → 1.4.0-next.9

package/dist/index.js

@@ -31330,10 +31330,10 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.17.0-next.7";
+var SDK_VERSION = "2.17.0-next.9";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
-import { chmodSync, existsSync } from "node:fs";
+import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -31387,7 +31387,15 @@ function ensureEmbeddedExecutable(binaryPath) {
   if (process.platform === "win32")
     return;
   try {
-    chmodSync(binaryPath, 493);
+    accessSync(binaryPath, constants.X_OK);
+    return;
+  } catch {}
+  let mode = 493;
+  try {
+    mode = statSync(binaryPath).mode & 4095 | 73;
+  } catch {}
+  try {
+    chmodSync(binaryPath, mode);
   } catch {}
 }
 var require2, TARGET_TO_PACKAGE, TARGET_TO_DIR;
@@ -135271,7 +135279,28 @@ function control(xml, element) {
   const locks = children.filter((child) => is(child, "lock"));
   const deletable = locks.every((lock) => attr(lock, "val") === "unlocked" || attr(lock, "val") === "contentLocked");
   const supportedProperties = children.every((child) => child.tag.uri === W3 ? ["id", "tag", "alias", "text", "richText", "lock", "rPr", "placeholder", "showingPlcHdr", "temporary"].includes(child.tag.local) : child.tag.uri === "http://schemas.microsoft.com/office/word/2012/wordml" && child.tag.local === "appearance");
-  return { id, key: `sdt:${attr(key2, "val")}`, xml: fragment2(xml, element), deletable: deletable && supportedProperties };
+  const contentXml = xml.slice(content[0].start, content[0].end);
+  const contentOpenEnd = contentXml.indexOf(">") + 1;
+  const contentCloseStart = contentXml.lastIndexOf("</");
+  const contentRuns = contentCloseStart < contentOpenEnd ? "" : contentXml.slice(contentOpenEnd, contentCloseStart);
+  const offset = content[0].start - element.start;
+  const itemXml = fragment2(xml, element);
+  const head = itemXml.slice(0, offset + contentOpenEnd);
+  const tail = itemXml.slice(offset + Math.max(contentOpenEnd, contentCloseStart));
+  const unlocked = locks.every((lock) => attr(lock, "val") === "unlocked");
+  const editable = locks.every((lock) => attr(lock, "val") === "unlocked" || attr(lock, "val") === "sdtLocked");
+  return {
+    id,
+    key: `sdt:${attr(key2, "val")}`,
+    xml: itemXml,
+    contentXml: contentRuns,
+    head,
+    tail,
+    deletable: deletable && supportedProperties,
+    insertable: unlocked && supportedProperties,
+    editable: editable && supportedProperties,
+    supportedProperties
+  };
 }
 function inspectInlineControlRemoval(beforeXml, afterXml, namespaces = {}) {
   const before = elements(beforeXml, namespaces);
@@ -135358,6 +135387,137 @@ function bodyOperationsCoverInlineControlRemoval(base2, target, operations, matc
   }
   return removed.size === changes.length && changes.every((entry) => entry.baseId !== null && removed.has(entry.baseId));
 }
+function inspectInlineControlReplay(beforeXml, afterXml, namespaces = {}) {
+  const before = elements(beforeXml, namespaces);
+  const after = elements(afterXml, namespaces);
+  if (!before || !after)
+    return null;
+  const xmlns = "http://www.w3.org/2000/xmlns/";
+  const attributes = (root, allowed) => Object.values(root.tag.attributes).every((attribute) => attribute.uri === xmlns || allowed(attribute.uri, attribute.local));
+  const runProperties = (root) => is(root, "rPr") && attributes(root, () => false) && root.children.every((child) => child.tag.uri === W3 && RUN_PROPERTIES.has(child.tag.local) && !child.children.length && attributes(child, (uri) => uri === W3));
+  const simpleRun = (root) => safeRun(root) && attributes(root, (uri, local) => uri === W3 && ["rsidR", "rsidRPr", "rsidDel"].includes(local)) && root.children.filter((child) => is(child, "t")).length === 1 && root.children.every((child) => runProperties(child) || is(child, "t") && !child.tag.isSelfClosing && attributes(child, (uri, local) => uri === "http://www.w3.org/XML/1998/namespace" && local === "space"));
+  const safeControlProperties = (root) => {
+    if (!attributes(root, (uri, local) => uri === W3 && ["rsidR", "rsidRPr", "rsidDel"].includes(local)))
+      return false;
+    const properties = root.children.find((child) => is(child, "sdtPr"));
+    const content = root.children.find((child) => is(child, "sdtContent"));
+    if (!attributes(properties, () => false) || !attributes(content, () => false) || content.tag.isSelfClosing)
+      return false;
+    if (properties.children.filter((child) => is(child, "text") || is(child, "richText")).length > 1)
+      return false;
+    const seen = new Set;
+    for (const child of properties.children) {
+      if (seen.has(child.tag.name))
+        return false;
+      seen.add(child.tag.name);
+      if (!attributes(child, (uri) => uri === W3 || uri === child.tag.uri))
+        return false;
+      if (is(child, "rPr")) {
+        if (!runProperties(child))
+          return false;
+      } else if (is(child, "placeholder")) {
+        if (child.children.some((item) => !is(item, "docPart") || item.children.length || !attributes(item, (uri) => uri === W3)))
+          return false;
+      } else if (child.children.length)
+        return false;
+    }
+    return root.children.filter((child) => is(child, "sdtEndPr")).every((child) => attributes(child, () => false) && child.children.every(runProperties));
+  };
+  const inspect = (xml, roots) => {
+    const result = [];
+    for (const [index, root] of roots.entries()) {
+      if (simpleRun(root))
+        continue;
+      const item = control(xml, root);
+      if (!item || !item.supportedProperties || !safeControlProperties(root) || !root.children.find((child) => is(child, "sdtContent"))?.children.every(simpleRun) || result.some((other) => other.id === item.id || other.key === item.key))
+        return null;
+      result.push({ ...item, index });
+    }
+    return result;
+  };
+  const previous = inspect(beforeXml, before);
+  const next = inspect(afterXml, after);
+  if (!previous || !next || !previous.length && !next.length)
+    return null;
+  const normalized = (xml) => signature(`<scope ${Object.entries(namespaces).filter(([prefix]) => prefix && prefix !== "xml").map(([prefix, uri]) => `xmlns:${prefix}=${JSON.stringify(uri)}`).join(" ")}>${xml}</scope>`);
+  const anchors = [];
+  for (const old of previous) {
+    const current = next.find((item) => item.id === old.id);
+    if (!current || old.key !== current.key || normalized(old.head + old.tail) !== normalized(current.head + current.tail))
+      return null;
+    const changed = normalized(old.xml) !== normalized(current.xml);
+    if (changed && !old.editable)
+      return null;
+    anchors.push({ beforeIndex: old.index, afterIndex: current.index, before: old, after: current, changed });
+  }
+  if (anchors.some((anchor, index) => index > 0 && anchor.afterIndex <= anchors[index - 1].afterIndex))
+    return null;
+  const inserted = next.filter((item) => !previous.some((old) => old.id === item.id));
+  if (inserted.some((item) => !item.insertable))
+    return null;
+  return {
+    anchors,
+    inserted,
+    updated: anchors.filter((anchor) => anchor.changed),
+    beforeRoots: before.map((root) => fragment2(beforeXml, root)),
+    afterRoots: after.map((root) => fragment2(afterXml, root))
+  };
+}
+function bodyOperationsCoverInlineControlReplay(base2, target, operations, match) {
+  const family = match.families.find((item) => item.family === "content-controls");
+  const changes = family?.entityMatch?.entries.filter((entry) => entry.disposition !== "matched" || entry.changed || entry.moved);
+  if (!changes?.length || family?.hasAmbiguity || changes.some((entry) => entry.disposition !== "inserted" && entry.disposition !== "matched" || entry.moved))
+    return false;
+  const counts = (snapshot2) => {
+    const result = new Map;
+    const visit = (root) => {
+      if (is(root, "sdtPr"))
+        for (const child of root.children.filter((item) => is(item, "id"))) {
+          const id = numericIdentity(attr(child, "val"));
+          if (id !== null)
+            result.set(id, (result.get(id) ?? 0) + 1);
+        }
+      root.children.forEach(visit);
+    };
+    for (const entry of [...snapshot2.body, ...(snapshot2.stories ?? []).flatMap((story) => story.entries)]) {
+      const roots = elements(entry.runXml ?? "", {}, true);
+      if (!roots)
+        return null;
+      roots.forEach(visit);
+    }
+    return result;
+  };
+  const oldCounts = counts(base2), newCounts = counts(target);
+  if (!oldCounts || !newCounts)
+    return false;
+  const covered = new Map;
+  for (const operation of operations) {
+    if (operation.kind !== "edit" && operation.kind !== "formatEdit")
+      continue;
+    const previous = base2.body.filter((entry) => entry.blockId === operation.blockId);
+    const next = target.body.filter((entry) => entry.blockId === operation.blockId);
+    if (previous.length !== 1 || next.length !== 1)
+      continue;
+    const before = previous[0], after = next[0];
+    const proof = inspectInlineControlReplay(before.runXml ?? "", after.runXml ?? "");
+    if (!proof)
+      continue;
+    if (!/^[0-9A-Fa-f]{8}$/.test(before.blockId) || (before.structuralScope ?? "body") !== "body" || (after.structuralScope ?? "body") !== "body" || before.trackedChangeAnnotationKeys?.length || before.structuralChangeAnnotationKeys?.length || after.trackedChangeAnnotationKeys?.length || after.structuralChangeAnnotationKeys?.length || operation.targetRunXml !== after.runXml)
+      return false;
+    for (const item of proof.inserted) {
+      if (covered.has(item.key) || oldCounts.has(item.id) || newCounts.get(item.id) !== 1)
+        return false;
+      covered.set(item.key, "inserted");
+    }
+    for (const anchor of proof.updated) {
+      const item = anchor.after;
+      if (covered.has(item.key) || oldCounts.get(item.id) !== 1 || newCounts.get(item.id) !== 1)
+        return false;
+      covered.set(item.key, "matched");
+    }
+  }
+  return covered.size === changes.length && changes.every((entry) => entry.targetId !== null && covered.get(entry.targetId) === entry.disposition);
+}
 var import_saxes3, W3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", attr = (element, name) => Object.values(element.tag.attributes).find((attribute) => attribute.uri === W3 && attribute.local === name)?.value, is = (element, name) => element.tag.uri === W3 && element.tag.local === name, fragment2 = (xml, element) => xml.slice(element.start, element.end), signature = (xml) => canonicalizeXmlForSignature(xml), RUN_PROPERTIES;
 var init_inline_control_removal = __esm(() => {
   init_run_signature();
@@ -136233,7 +136393,7 @@ function parseXmlStartTag(rawTag) {
   return null;
 }
 function validateRunContents(xml, options) {
-  if (options.baseRunXml !== undefined && inspectInlineControlRemoval(options.baseRunXml, xml)) {
+  if (options.baseRunXml !== undefined && (inspectInlineControlRemoval(options.baseRunXml, xml) || inspectInlineControlReplay(options.baseRunXml, xml))) {
     return { ok: true };
   }
   const baseHasNoteMarker = options.baseRunXml !== undefined && /<(?:[A-Za-z_][\w.-]*:)?(?:footnoteRef|endnoteRef)\b/.test(options.baseRunXml);
@@ -140064,7 +140224,7 @@ function planCompare(base2, target) {
   const trackedRevisionSetChanged = semanticAnalysis.familyDeltas.find((delta) => delta.family === "tracked-changes")?.detectedChange === true;
   const revisionReplay = deriveCompareBodyOperationsWithRevisionReplay(base2, target, matchResult);
   const bodyOperations = revisionReplay.operations;
-  if (bodyOperationsCoverInlineControlRemoval(base2, target, bodyOperations, matchResult)) {
+  if (bodyOperationsCoverInlineControlRemoval(base2, target, bodyOperations, matchResult) || bodyOperationsCoverInlineControlReplay(base2, target, bodyOperations, matchResult)) {
     semanticAnalysis = markFamilySupported(semanticAnalysis, "content-controls");
   }
   const computedStoryOperations = buildStoryOperations(base2, target, semanticAnalysis);
@@ -164385,6 +164545,9 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
       ...enclosingSdts.length > 0 ? { requiresCollaborationSessionSync: true } : {}
     };
   }
+  const sdtProtection = validateSelectedSdtProtection(model.pieces, startOffset, endOffset);
+  if (sdtProtection)
+    return { ok: false, reason: sdtProtection };
   const tocPlan = planTocEntryEdit(paragraphBytes, xml, model, leaves, startOffset, endOffset, newText, inlineContext, authoredTocEntry);
   if (tocPlan)
     return tocPlan;
@@ -164437,7 +164600,13 @@ function planDirectInlineEdits(paragraphBytes, edits, inheritedNamespaceBindings
       return { ok: false, reason: "invalid-range" };
     }
   }
-  const batchLeaves = parseParagraphInlineMap(TD22.decode(paragraphBytes), inheritedNamespaceBindings).leaves();
+  const batchModel = parseParagraphInlineMap(TD22.decode(paragraphBytes), inheritedNamespaceBindings);
+  for (const edit of ordered) {
+    const blocked = validateSelectedSdtProtection(batchModel.pieces, edit.startOffset, edit.endOffset);
+    if (blocked)
+      return { ok: false, reason: blocked };
+  }
+  const batchLeaves = batchModel.leaves();
   if (batchLeaves.some((piece) => piece.kind === "noteReference" && !piece.deleted && ordered.some((edit) => edit.startOffset < piece.visibleEnd && edit.endOffset > piece.visibleStart))) {
     return { ok: false, reason: "unsupported-context" };
   }
@@ -165014,6 +165183,27 @@ function hasNonWordMarkerAtCollapsedMoveBoundary(pieces, at, coordinateSpace = "
 function firstNonFieldRangeStartMarker(markers) {
   return markers.find((piece) => piece.role === "range-start" && !isFieldMarker(piece.markerKind)) ?? null;
 }
+function validateSelectedSdtProtection(pieces, start, end) {
+  if (start === end)
+    return null;
+  for (const piece of pieces) {
+    if (piece.kind !== "container" && piece.kind !== "tracked")
+      continue;
+    if (piece.kind === "container" && piece.containerKind === "sdt" && rangeCrossesContainer(piece, start, end)) {
+      const policy = classifySdtMutationPolicyInternal(piece, true);
+      if (!policy.ok)
+        return policy.reason;
+      const contentOnly = containerContainsRange(piece, start, end);
+      const wholeWrapper = start <= piece.visibleStart && piece.visibleEnd <= end;
+      if (contentOnly && !policy.contentEditable || !contentOnly && !policy.wrapperDeletable || !contentOnly && !wholeWrapper && !policy.contentEditable)
+        return "text-range-in-sdt";
+    }
+    const blocked = validateSelectedSdtProtection(piece.children, start, end);
+    if (blocked)
+      return blocked;
+  }
+  return null;
+}
 function resolveEditScope(pieces, start, end, collapsedInlineAffinity, collapsedOutsideContentControl = false) {
   let current = pieces;
   let descended = false;
@@ -165068,11 +165258,11 @@ function planCrossBoundarySdts(pieces, start, end) {
     const policy = classifySdtMutationPolicy(piece);
     if (!policy.ok)
       return policy;
+    if (!policy.wrapperDeletable)
+      return { ok: false, reason: "text-range-in-sdt" };
     requiresCollaborationSessionSync = true;
     const wholeWrapper = start <= piece.visibleStart && piece.visibleEnd <= end;
     if (wholeWrapper) {
-      if (!policy.wrapperDeletable)
-        return { ok: false, reason: "text-range-in-sdt" };
       const blocked = findBlockingSdtChild(piece.children);
       if (blocked)
         return { ok: false, reason: blocked };
@@ -192926,7 +193116,7 @@ function tryRangeReplacementAcrossTokens(input, allTokens, touched) {
   if (!firstSelected)
     return null;
   const touchedInsertions = touched.filter((entry) => entry.token.kind === "ins");
-  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 || token.nestedDeletions && token.nestedDeletions.length > 0)) {
+  if (touchedInsertions.some(({ token }) => token.innerRuns && token.innerRuns.length > 1 && (token !== firstSelected.token || token.commentedBoundary != null) || token.nestedDeletions && token.nestedDeletions.length > 0)) {
     return null;
   }
   const result = input.changeMode === "tracked" ? authorTrackedPureDelete(input, allTokens, touched) : authorDirectPureDelete(input, allTokens, touched);
@@ -193030,7 +193220,7 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         continue;
       }
       const head2 = token.text.slice(0, localStart2);
-      const removed2 = token.text.slice(localStart2, localEnd2);
+      const removed = token.text.slice(localStart2, localEnd2);
       const tail2 = token.text.slice(localEnd2);
       const headXml = head2.length > 0 ? renderPlainRun(head2, token.runOpen, token.runClose, token.rPr) : "";
       const delXml = buildDelWrapperXml({
@@ -193039,7 +193229,7 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         author: currentAuthor,
         date: input.txTimestamp,
         rsidDel: input.rsid,
-        inner: { runOpen: token.runOpen, runClose: token.runClose, rPr: token.rPr, text: removed2 }
+        inner: { runOpen: token.runOpen, runClose: token.runClose, rPr: token.rPr, text: removed }
       });
       const insertXml = !replacementInserted && input.newText.length > 0 ? buildInsWrapperXml({
         nsPrefix,
@@ -193072,7 +193262,6 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       continue;
     }
     const head = token.inner.text.slice(0, localStart);
-    const removed = token.inner.text.slice(localStart, localEnd);
     const tail = token.inner.text.slice(localEnd);
     const classification = token._classification;
     removedAnything = true;
@@ -193101,8 +193290,13 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         updatedRsids.push(rsid);
       continue;
     }
-    const nestedHead = renderPlainRun(head, token.inner.runOpen, token.inner.runClose, token.inner.rPr);
-    const nestedTail = renderPlainRun(tail, token.inner.runOpen, token.inner.runClose, token.inner.rPr);
+    const runs = token.innerRuns ?? [token.inner];
+    const headRuns = sliceWrappedRuns(runs, 0, localStart);
+    const removedRuns = sliceWrappedRuns(runs, localStart, localEnd);
+    const tailRuns = sliceWrappedRuns(runs, localEnd, token.inner.text.length);
+    const nestedHead = buildInsInnerXmlFromRuns(headRuns);
+    const nestedTail = buildInsInnerXmlFromRuns(tailRuns);
+    const insertMeta = runMetaAtInsertionPoint(token, localStart, true);
     const childIns = !replacementInserted && input.newText.length > 0 && input.rangeStart >= token.visibleStart && input.rangeStart < token.visibleEnd && input.rangeEnd > token.visibleEnd ? buildInsWrapperXml({
       namespaceReferenceOpenTag: token.openTag,
       nsPrefix: token.nsPrefix,
@@ -193111,9 +193305,9 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       date: input.txTimestamp,
       rsidR: input.insRsid,
       inner: {
-        runOpen: token.inner.runOpen,
-        runClose: token.inner.runClose,
-        rPr: token.inner.rPr,
+        runOpen: insertMeta.runOpen,
+        runClose: insertMeta.runClose,
+        rPr: rPrAtInsertionPoint(token, localStart, true),
         text: input.newText
       }
     }) : "";
@@ -193124,10 +193318,8 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
       author: currentAuthor,
       date: input.txTimestamp,
       rsidDel: input.rsid,
-      inner: { runOpen: token.inner.runOpen, runClose: token.inner.runClose, rPr: token.inner.rPr, text: removed },
-      ...token.commentedBoundary ? {
-        innerXml: renderDelRun(removed, token.inner.runOpen, token.inner.runClose, token.inner.rPr) + token.commentedBoundary.endXml + token.commentedBoundary.referenceRunXml
-      } : {}
+      inner: removedRuns[0],
+      innerXml: buildDelInnerXmlFromRuns(removedRuns) + (token.commentedBoundary?.endXml ?? "") + (token.commentedBoundary?.referenceRunXml ?? "")
     });
     if (token.commentedBoundary) {
       if (!childIns || tail.length > 0)
@@ -193148,7 +193340,8 @@ function authorTrackedPureDelete(input, allTokens, touched, touchedBreaks = [])
         author: token.author,
         date: token.date,
         rsidR: token.rsidR,
-        inner: { ...token.inner, text: head }
+        inner: headRuns[0],
+        innerXml: nestedHead
       }) : "";
       const tailIns = buildInsWrapperXml({
         openTag: token.openTag,
@@ -193515,6 +193708,20 @@ function foldInsideOwnInsertion(input, allTokens, parent) {
   const rebuilt = rebuildParagraph(allTokens, parent, newInsXml);
   return rebuilt.ok ? markTextInsertionRefined(markExistingRevisionUpdated(rebuilt, input, parent), input, parent, false) : rebuilt;
 }
+function sliceWrappedRuns(runs, start, end) {
+  const result = [];
+  let offset = 0;
+  for (const run of runs) {
+    const runEnd = offset + run.text.length;
+    if (start < runEnd && end > offset) {
+      result.push({ ...run, text: run.text.slice(Math.max(0, start - offset), Math.min(run.text.length, end - offset)) });
+    }
+    offset = runEnd;
+    if (offset >= end)
+      break;
+  }
+  return result;
+}
 function flattenWrappedRuns(runs) {
   const out = [];
   for (const run of runs) {
@@ -193735,8 +193942,10 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
       detail: "overlap compiler: edit range straddles an existing nested tracked deletion."
     };
   }
-  const headOwnedNested = parent.nestedDeletions?.filter((n) => n.localOffset <= localStart) ?? [];
-  const tailOwnedNested = parent.nestedDeletions?.filter((n) => n.localOffset > localStart) ?? [];
+  const precedesBoundaryDeletion = input.changeMode === "tracked" && input.newText.length > 0 && input.rangeStart === input.rangeEnd && (input.coordinateSpace ?? "visible") === "visible" && input.collapsedInlineAffinity === "upstream";
+  const belongsToHead = (n) => n.localOffset < localStart || n.localOffset === localStart && !precedesBoundaryDeletion;
+  const headOwnedNested = nestedDeletions.filter(belongsToHead);
+  const tailOwnedNested = nestedDeletions.filter((n) => !belongsToHead(n));
   const flat = flattenWrappedRuns(parent.innerRuns ?? [parent.inner]);
   const headRuns = coalesceWrappedRuns(flat.slice(0, localStart));
   const removedRuns = coalesceWrappedRuns(flat.slice(localStart, localEnd));
@@ -193866,7 +194075,7 @@ function splitInsertionAroundChildChange(input, allTokens, parent) {
     ok: true,
     xml,
     emittedRsids,
-    ...removedText.length > 0 || tailParentWId !== parent.wId || liftComment ? { requiresCollaborationSessionSync: true } : {}
+    ...removedText.length > 0 || tailParentWId !== parent.wId || liftComment || precedesBoundaryDeletion && tailOwnedNested.some((n) => n.localOffset === localStart) ? { requiresCollaborationSessionSync: true } : {}
   };
 }
 function insertAtForeignDeletion(input, allTokens, parent, sameUser, side = "after") {
@@ -198950,6 +199159,15 @@ function rewriteTrackedPartialSdtSelection(paragraphXml, startOffset, endOffset,
   const sdts = [...intersectingSdts].sort((left, right) => left.visibleStart - right.visibleStart);
   if (sdts.some((sdt, index) => index > 0 && sdt.visibleStart < sdts[index - 1].visibleEnd))
     return null;
+  for (const sdt of sdts) {
+    if (sdt.visibleStart <= startOffset && endOffset <= sdt.visibleEnd)
+      continue;
+    const policy = classifySdtMutationPolicy(sdt);
+    if (!policy.ok)
+      return policy;
+    if (!policy.wrapperDeletable)
+      return { ok: false, reason: "text-range-in-sdt" };
+  }
   const segments = [];
   let cursor = startOffset;
   for (const sdt of sdts) {
@@ -203111,6 +203329,101 @@ var init_paragraph_property_history = __esm(() => {
   init_paragraph_property_namespaces();
 });
 
+// ../../../v2/editor-core/dist/document/transactions/tracked-paragraph-properties.js
+function readParagraphProperties(xml, namespaceBindings) {
+  const prefix = [...namespaceBindings].find(([key2, uri]) => key2 && uri === NS_W)?.[0] ?? "w";
+  const source = xml || `<${prefix}:pPr/>`;
+  const parsed = collectXmlElementRanges(source, {
+    fragment: true,
+    additionalNamespaces: Object.fromEntries(namespaceBindings)
+  });
+  const ranges = parsed.ranges.sort((a, b) => a.start - b.start || b.end - a.end);
+  const root = ranges[0];
+  if (parsed.errors.length || !root || root.start !== 0 || root.end !== source.length || root.tag.namespaceUri !== NS_W || root.tag.localName !== "pPr")
+    return null;
+  if (ranges.some((range) => range.tag.namespaceUri === NS_W && ["ins", "del", "moveFrom", "moveTo", "pPrChange", "rPrChange", "sectPr"].includes(range.tag.localName)))
+    return null;
+  const children = [];
+  let cursor = root.openEnd;
+  for (const range of ranges.slice(1)) {
+    if (range.start < cursor)
+      continue;
+    if (source.slice(cursor, range.start).trim())
+      return null;
+    children.push(range);
+    cursor = range.end;
+  }
+  const marks = children.filter((child) => child.tag.namespaceUri === NS_W && child.tag.localName === "rPr");
+  if (marks.length > 1)
+    return null;
+  const mark = marks[0];
+  const baseChildren = children.filter((child) => child !== mark).map((child) => source.slice(child.start, child.end)).join("");
+  return {
+    source,
+    root,
+    mark,
+    markXml: mark ? source.slice(mark.start, mark.end) : "",
+    baseChildren
+  };
+}
+function isSafeTrackedParagraphProperties(xml, namespaceBindings) {
+  return readParagraphProperties(xml, namespaceBindings) !== null;
+}
+function prepareTrackedParagraphProperties(input) {
+  const prefix = [...input.namespaceBindings].find(([key2, uri]) => key2 && uri === NS_W)?.[0] ?? "w";
+  const before = readParagraphProperties(input.beforeXml, input.namespaceBindings);
+  const after = readParagraphProperties(input.afterXml, input.namespaceBindings);
+  if (!before || !after)
+    return null;
+  const wordIds = [];
+  const markBindings = after.mark?.namespaceBindings ?? after.root.namespaceBindings;
+  const wrapperBindings = (kind) => ({
+    ...kind === "rPr" ? markBindings : after.root.namespaceBindings,
+    [prefix]: NS_W
+  });
+  const wrapper = (kind, old) => {
+    const id = input.stamp.revisionIds?.[wordIds.length] ?? input.stamp.revisionId + wordIds.length;
+    if (input.stamp.revisionIds && wordIds.length >= input.stamp.revisionIds.length)
+      return null;
+    wordIds.push(String(id));
+    const namespace = (kind === "rPr" ? markBindings : after.root.namespaceBindings)[prefix] === NS_W ? "" : ` xmlns:${prefix}="${NS_W}"`;
+    return `<${prefix}:${kind}Change${namespace} ${prefix}:id="${id}" ${prefix}:author="${escapeXmlAttribute(input.stamp.author.name)}" ${prefix}:date="${escapeXmlAttribute(input.stamp.date)}">${old}</${prefix}:${kind}Change>`;
+  };
+  let mark = after.markXml;
+  if (before.markXml !== after.markXml) {
+    const oldMark = before.mark ? copyParagraphPropertyChild(before.source, before.mark, wrapperBindings("rPr")) : `<${prefix}:rPr/>`;
+    const change = wrapper("rPr", oldMark);
+    if (!change)
+      return null;
+    if (!after.mark || after.mark.tag.isSelfClosing) {
+      const open = after.mark ? after.markXml.replace(/\/>$/, ">") : `<${prefix}:rPr>`;
+      mark = open + change + `</${after.mark?.tag.name ?? `${prefix}:rPr`}>`;
+    } else {
+      const at = after.mark.closeStart - after.mark.start;
+      mark = after.markXml.slice(0, at) + change + after.markXml.slice(at);
+    }
+  }
+  let paragraphChange = "";
+  if (before.baseChildren !== after.baseChildren) {
+    const oldProperties = paragraphPropertyOpeningWithNamespaces(before.source, before.root, wrapperBindings("pPr")).replace(/\/>$/, ">") + before.baseChildren + `</${before.root.tag.name}>`;
+    const change = wrapper("pPr", oldProperties);
+    if (!change)
+      return null;
+    paragraphChange = change;
+  }
+  if (wordIds.length === 0)
+    return { xml: input.afterXml, wordIds };
+  return {
+    xml: after.source.slice(0, after.root.openEnd).replace(/\/>$/, ">") + after.baseChildren + mark + paragraphChange + `</${after.root.tag.name}>`,
+    wordIds
+  };
+}
+var init_tracked_paragraph_properties = __esm(() => {
+  init_xml_sax();
+  init_xml_text();
+  init_paragraph_property_namespaces();
+});
+
 // ../../../v2/editor-core/dist/document/transactions/tracked-changes/review-decision-semantics.js
 function structuralDecisionBehavior(kind, decision) {
   if (kind === "paragraph-mark-deletion" && decision === "accept" || kind === "paragraph-mark-insertion" && decision === "reject" || kind === "section-break-deletion" && decision === "accept")
@@ -203680,7 +203993,7 @@ function mergeParagraphMarkedBoundary(lookupContext, xml, fragment3, namespaceBi
     return { ok: false, reason: "unsupported-context" };
   }
   const pendingInsertionTerminalDeletion = fragment3.structuralKind === "paragraph-mark-deletion" && isPendingFullParagraphInsertion(currentWithoutMarker, fragment3.tagPrefix);
-  const merged = fragment3.structuralKind === "paragraph-mark-insertion" ? mergeParagraphXmlKeepingFirstForDecision(currentWithoutMarker, next.xml) : pendingInsertionTerminalDeletion ? mergeParagraphXmlKeepingPendingInsertion(currentWithoutMarker, next.xml) : next.wrapper ? mergeParagraphXmlForDecisionWithWrappedSuccessor(currentWithoutMarker, next.xml, next.wrapper) : mergeParagraphXmlForDecision(currentWithoutMarker, next.xml);
+  const merged = fragment3.structuralKind === "paragraph-mark-insertion" ? mergeParagraphXmlKeepingFirstForDecision(currentWithoutMarker, next.xml) : pendingInsertionTerminalDeletion ? mergeParagraphXmlKeepingPendingInsertion(currentWithoutMarker, next.xml, effectiveNamespaceBindings) : next.wrapper ? mergeParagraphXmlForDecisionWithWrappedSuccessor(currentWithoutMarker, next.xml, next.wrapper) : mergeParagraphXmlForDecision(currentWithoutMarker, next.xml);
   if (!merged)
     return { ok: false, reason: "invalid-input" };
   return {
@@ -203893,7 +204206,7 @@ function mergeParagraphXmlForDecisionWithWrappedSuccessor(firstXml, secondXml, w
     return null;
   return secondOpenMatch[0] + secondPPr + firstRuns + wrapper.openTag + secondRuns + wrapper.closeTag + secondCloseMatch[0];
 }
-function mergeParagraphXmlKeepingPendingInsertion(firstXml, secondXml) {
+function mergeParagraphXmlKeepingPendingInsertion(firstXml, secondXml, namespaceBindings) {
   firstXml = expandEmptyParagraphForMerge(firstXml);
   secondXml = expandEmptyParagraphForMerge(secondXml);
   const firstOpenMatch = firstXml.match(/^<[\w.-]+:p\b[^>]*>/);
@@ -203906,9 +204219,14 @@ function mergeParagraphXmlKeepingPendingInsertion(firstXml, secondXml) {
   const secondInner = secondXml.slice(secondOpenMatch[0].length, secondXml.length - secondCloseMatch[0].length);
   const firstPPr = matchLeadingElement(firstInner, "pPr");
   const secondPPr = matchLeadingElement(secondInner, "pPr");
-  if (!firstPPr || secondPPr)
+  const parsedSecond = collectXmlElementRanges(secondXml, {
+    fragment: true,
+    additionalNamespaces: xmlFragmentAdditionalNamespaces(secondXml, new Map(Object.entries(namespaceBindings)))
+  });
+  const secondRoot = parsedSecond.ranges.find((range) => range.start === 0 && range.end === secondXml.length);
+  if (!firstPPr || parsedSecond.errors.length || !secondRoot || !isSafeTrackedParagraphProperties(secondPPr, new Map(Object.entries(secondRoot.namespaceBindings))))
     return null;
-  return firstOpenMatch[0] + firstPPr + firstInner.slice(firstPPr.length) + secondInner + firstCloseMatch[0];
+  return firstOpenMatch[0] + firstPPr + firstInner.slice(firstPPr.length) + secondInner.slice(secondPPr.length) + firstCloseMatch[0];
 }
 function isPendingFullParagraphInsertion(paragraphXml, prefix) {
   const parsed = collectXmlElementRanges(paragraphXml, {
@@ -205043,6 +205361,7 @@ var init_decide_engine = __esm(() => {
   init_paragraph_mark_format_history();
   init_paragraph_property_history();
   init_paragraph_property_namespaces();
+  init_tracked_paragraph_properties();
   init_structural_groups();
   init_paragraph_property_block();
   init_block_deletion_text();
@@ -213039,97 +213358,6 @@ var init_tracked_block_replacement = __esm(() => {
   init_tracked_table_replacement();
 });
 
-// ../../../v2/editor-core/dist/document/transactions/tracked-paragraph-properties.js
-function prepareTrackedParagraphProperties(input) {
-  const prefix = [...input.namespaceBindings].find(([key2, uri]) => key2 && uri === NS_W)?.[0] ?? "w";
-  const read = (xml) => {
-    const source = xml || `<${prefix}:pPr/>`;
-    const parsed = collectXmlElementRanges(source, {
-      fragment: true,
-      additionalNamespaces: Object.fromEntries(input.namespaceBindings)
-    });
-    const ranges = parsed.ranges.sort((a, b) => a.start - b.start || b.end - a.end);
-    const root = ranges[0];
-    if (parsed.errors.length || !root || root.start !== 0 || root.end !== source.length || root.tag.namespaceUri !== NS_W || root.tag.localName !== "pPr")
-      return null;
-    if (ranges.some((range) => range.tag.namespaceUri === NS_W && ["ins", "del", "moveFrom", "moveTo", "pPrChange", "rPrChange", "sectPr"].includes(range.tag.localName)))
-      return null;
-    const children = [];
-    let cursor = root.openEnd;
-    for (const range of ranges.slice(1)) {
-      if (range.start < cursor)
-        continue;
-      if (source.slice(cursor, range.start).trim())
-        return null;
-      children.push(range);
-      cursor = range.end;
-    }
-    const marks = children.filter((child) => child.tag.namespaceUri === NS_W && child.tag.localName === "rPr");
-    if (marks.length > 1)
-      return null;
-    const mark2 = marks[0];
-    const baseChildren = children.filter((child) => child !== mark2).map((child) => source.slice(child.start, child.end)).join("");
-    return {
-      source,
-      root,
-      mark: mark2,
-      markXml: mark2 ? source.slice(mark2.start, mark2.end) : "",
-      baseChildren
-    };
-  };
-  const before = read(input.beforeXml);
-  const after = read(input.afterXml);
-  if (!before || !after)
-    return null;
-  const wordIds = [];
-  const markBindings = after.mark?.namespaceBindings ?? after.root.namespaceBindings;
-  const wrapperBindings = (kind) => ({
-    ...kind === "rPr" ? markBindings : after.root.namespaceBindings,
-    [prefix]: NS_W
-  });
-  const wrapper = (kind, old) => {
-    const id = input.stamp.revisionIds?.[wordIds.length] ?? input.stamp.revisionId + wordIds.length;
-    if (input.stamp.revisionIds && wordIds.length >= input.stamp.revisionIds.length)
-      return null;
-    wordIds.push(String(id));
-    const namespace = (kind === "rPr" ? markBindings : after.root.namespaceBindings)[prefix] === NS_W ? "" : ` xmlns:${prefix}="${NS_W}"`;
-    return `<${prefix}:${kind}Change${namespace} ${prefix}:id="${id}" ${prefix}:author="${escapeXmlAttribute(input.stamp.author.name)}" ${prefix}:date="${escapeXmlAttribute(input.stamp.date)}">${old}</${prefix}:${kind}Change>`;
-  };
-  let mark = after.markXml;
-  if (before.markXml !== after.markXml) {
-    const oldMark = before.mark ? copyParagraphPropertyChild(before.source, before.mark, wrapperBindings("rPr")) : `<${prefix}:rPr/>`;
-    const change = wrapper("rPr", oldMark);
-    if (!change)
-      return null;
-    if (!after.mark || after.mark.tag.isSelfClosing) {
-      const open = after.mark ? after.markXml.replace(/\/>$/, ">") : `<${prefix}:rPr>`;
-      mark = open + change + `</${after.mark?.tag.name ?? `${prefix}:rPr`}>`;
-    } else {
-      const at = after.mark.closeStart - after.mark.start;
-      mark = after.markXml.slice(0, at) + change + after.markXml.slice(at);
-    }
-  }
-  let paragraphChange = "";
-  if (before.baseChildren !== after.baseChildren) {
-    const oldProperties = paragraphPropertyOpeningWithNamespaces(before.source, before.root, wrapperBindings("pPr")).replace(/\/>$/, ">") + before.baseChildren + `</${before.root.tag.name}>`;
-    const change = wrapper("pPr", oldProperties);
-    if (!change)
-      return null;
-    paragraphChange = change;
-  }
-  if (wordIds.length === 0)
-    return { xml: input.afterXml, wordIds };
-  return {
-    xml: after.source.slice(0, after.root.openEnd).replace(/\/>$/, ">") + after.baseChildren + mark + paragraphChange + `</${after.root.tag.name}>`,
-    wordIds
-  };
-}
-var init_tracked_paragraph_properties = __esm(() => {
-  init_xml_sax();
-  init_xml_text();
-  init_paragraph_property_namespaces();
-});
-
 // ../../../v2/editor-core/dist/document/transactions/tracked-terminal-paragraph-delete.js
 function prepareTrackedTerminalParagraphDeletion(input) {
   const read = (xml, namespaces) => {
@@ -213159,7 +213387,7 @@ function prepareTrackedTerminalParagraphDeletion(input) {
   if (!previous || !current)
     return null;
   const pendingInsertion = (() => {
-    if (!previous.properties || current.propertiesXml || !previous.runs.trim())
+    if (!previous.properties || !previous.runs.trim())
       return false;
     const properties2 = collectXmlElementRanges(previous.propertiesXml, {
       fragment: true,
@@ -213186,6 +213414,8 @@ function prepareTrackedTerminalParagraphDeletion(input) {
     return parsedContent.errors.length === 0 && contentRanges.length > 0 && contentRoot?.start === 0 && contentRoot.end === content.length && contentRoot.tag.namespaceUri === NS_W && contentRoot.tag.localName === "ins";
   })();
   if (pendingInsertion) {
+    if (!isSafeTrackedParagraphProperties(current.propertiesXml, new Map(Object.entries(current.root.namespaceBindings))))
+      return null;
     const ids2 = input.stamp.revisionIds ?? [input.stamp.revisionId, input.stamp.revisionId + 1];
     if (ids2.length < 2)
       return null;
@@ -213209,7 +213439,7 @@ function prepareTrackedTerminalParagraphDeletion(input) {
       return null;
     return {
       previousXml: previous.opening + previousProperties + previous.runs + previous.closing,
-      currentXml: current.opening + deleted2.xml + current.closing,
+      currentXml: current.opening + current.propertiesXml + deleted2.xml + current.closing,
       wordIds: [String(ids2[0]), ...deleted2.wordIds]
     };
   }
@@ -216115,7 +216345,10 @@ function runParagraphRangeCollapseCommit(input) {
   if (startOffsetMap.charToByte(op.on.startOffset) !== op.on.startByte || endOffsetMap.charToByte(op.on.endOffset) !== op.on.endByte) {
     return rejected8(input.txId, "base-revision-drift");
   }
-  const structuralFailure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, op.startObjectBoundary, op.endObjectBoundary, { allowSectionBoundary: changeMode === "direct" && op.replacementText === undefined && !deleteFullBlocks });
+  const structuralFailure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, op.startObjectBoundary, op.endObjectBoundary, {
+    allowSectionBoundary: changeMode === "direct" && op.replacementText === undefined && !deleteFullBlocks,
+    inlineRange: { startOffset: op.on.startOffset, endOffset: op.on.endOffset, deleteFullBlocks: op.deleteFinalParagraphMark === true }
+  });
   if (structuralFailure)
     return rejected8(input.txId, structuralFailure);
   let replacementBlockId;
@@ -216172,7 +216405,7 @@ function runParagraphRangeCollapseCommit(input) {
       op = expanded.op;
       start = expanded.start;
       end = expanded.end;
-      const expandedStructure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, undefined, undefined, { allowSectionBoundary: true });
+      const expandedStructure = validateRangeCollapseStructure(bytes, index.entries, start, end, changeMode, undefined, undefined, { allowSectionBoundary: true, inlineRange: { startOffset: op.on.startOffset, endOffset: op.on.endOffset } });
       if (expandedStructure)
         return rejected8(input.txId, expandedStructure);
       rangeIntegrity = validateParagraphRangeIntegrity({
@@ -217922,6 +218155,11 @@ function validateRangeCollapseStructure(bytes, entries, start, end, changeMode,
   if (!options.structuralMap && directBodyRangeIsStructurallyPlain(bytes, entries, start, end, changeMode)) {
     return null;
   }
+  if (options.inlineRange) {
+    const failure2 = validateRangeInlineSdtProtection(bytes, entries, start, end, options.inlineRange);
+    if (failure2)
+      return failure2;
+  }
   if (!options.structuralMap)
     recordSDTxPerf("rangeCollapseStructuralFullScans", 1);
   const map3 = options.structuralMap ?? buildStructuralBoundaryMap(bytes);
@@ -217993,6 +218231,46 @@ function validateRangeCollapseStructure(bytes, entries, start, end, changeMode,
   }
   return null;
 }
+function validateRangeInlineSdtProtection(bytes, entries, start, end, range) {
+  for (const entry of entries) {
+    if (entry.ordinal < start.ordinal || entry.ordinal > end.ordinal)
+      continue;
+    const xml = decodeByteRange(bytes, entry.byteStart, entry.byteEnd);
+    if (!/<\s*(?:[\w.-]+:)?sdt\b/.test(xml))
+      continue;
+    const namespaces = namespaceBindingsAtPosition(bytes, entry.byteStart, matchParagraphOpenTag(xml) ?? "");
+    const selectedStart = entry.blockId === start.blockId ? range.startOffset : 0;
+    const selectedEnd = entry.blockId === end.blockId ? range.endOffset : entry.textLength;
+    const wholeParagraph = range.deleteFullBlocks === true || entry.ordinal > start.ordinal && entry.ordinal < end.ordinal;
+    const visit = (pieces) => {
+      for (const piece of pieces) {
+        if (piece.kind !== "container" && piece.kind !== "tracked")
+          continue;
+        if (piece.kind === "container" && piece.containerKind === "sdt") {
+          const touched = wholeParagraph || (piece.visibleStart === piece.visibleEnd ? (entry.blockId !== start.blockId || selectedStart < piece.visibleStart) && piece.visibleEnd <= selectedEnd : selectedStart < piece.visibleEnd && piece.visibleStart < selectedEnd);
+          if (!touched)
+            continue;
+          const policy = classifySdtMutationPolicy(piece);
+          if (!policy.ok)
+            return policy.reason;
+          if (!policy.wrapperDeletable)
+            return "text-range-in-sdt";
+          const wholeWrapper = wholeParagraph || selectedStart <= piece.visibleStart && piece.visibleEnd <= selectedEnd;
+          if (!wholeWrapper && !policy.contentEditable)
+            return "text-range-in-sdt";
+        }
+        const failure3 = visit(piece.children);
+        if (failure3)
+          return failure3;
+      }
+      return null;
+    };
+    const failure2 = visit(parseParagraphInlineMap(xml, namespaces).pieces);
+    if (failure2)
+      return failure2;
+  }
+  return null;
+}
 function directBodyRangeIsStructurallyPlain(bytes, entries, start, end, changeMode) {
   if (!Number.isSafeInteger(start.ordinal) || !Number.isSafeInteger(end.ordinal) || start.ordinal < 0 || end.ordinal <= start.ordinal || end.ordinal >= entries.length || entries[start.ordinal]?.blockId !== start.blockId || entries[start.ordinal]?.byteStart !== start.byteStart || entries[start.ordinal]?.byteEnd !== start.byteEnd || entries[end.ordinal]?.blockId !== end.blockId || entries[end.ordinal]?.byteStart !== end.byteStart || entries[end.ordinal]?.byteEnd !== end.byteEnd || !Number.isSafeInteger(start.byteStart) || !Number.isSafeInteger(end.byteEnd) || start.byteStart < 0 || end.byteEnd <= start.byteStart || end.byteEnd > bytes.byteLength)
     return false;
@@ -224310,7 +224588,7 @@ function runBodyStep(input, storyId, noteId, step2, changeMode, options, pushHis
   if ((step2.kind === "edit" || step2.kind === "formatEdit") && step2.targetRunXml !== undefined) {
     const before = liveCompareBodyRunXml(state, storyId, step2.blockId);
     const partBytes = state.packageBytes.get(storyPartUriFromStoryId2(storyId));
-    if (before !== undefined && partBytes && inspectInlineControlRemoval(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes))) {
+    if (before !== undefined && partBytes && (inspectInlineControlRemoval(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes)) || inspectInlineControlReplay(before, step2.targetRunXml, textboxNamespaceBindingsFromPartBytes(partBytes)))) {
       return runInlineControlRemovalCommit(input, storyId, step2, changeMode, options, pushHistory);
     }
   }
@@ -225071,6 +225349,134 @@ function retainedNoteMarkerRuns(oldRuns, targetRuns, storyId) {
     targetRuns: targetMarker.remainingRunXml
   };
 }
+function equivalentSimpleRunContent(before, after) {
+  const previous = parseSimpleRunTokens(before), next = parseSimpleRunTokens(after);
+  if (!previous || !next)
+    return false;
+  const spans = (tokens) => tokens.flatMap((token) => Array.from(token.text, (char) => `${canonicalizeXmlForSignature(token.openTag)}:${char}`));
+  const old = spans(previous), target = spans(next);
+  return old.length === target.length && old.every((value, index) => value === target[index]);
+}
+function inlineComparePieces(proof) {
+  const pieces = [];
+  const gap = (before, roots, rootOffset) => {
+    const tokens = parseSimpleRunTokens(before);
+    if (!tokens)
+      return false;
+    const oldText = tokens.map((token) => token.text).join("");
+    const targets = roots.map((xml, index) => {
+      const control2 = proof.inserted.find((item) => item.index === index + rootOffset);
+      const text = projectCompareReplayCurrentText(control2?.contentXml ?? xml);
+      return text === null ? null : { xml, control: control2, text };
+    });
+    if (targets.some((item) => item === null))
+      return false;
+    const nextText = targets.map((item) => item.text).join("");
+    const operations = getWordChanges(oldText, nextText);
+    const mapOffset = (offset) => {
+      let oldCursor3 = 0, nextCursor3 = 0;
+      for (const op of operations) {
+        const start = op.type === "insert" ? op.insertAt : op.oldFrom;
+        const equalEnd = nextCursor3 + start - oldCursor3;
+        if (offset < equalEnd)
+          return oldCursor3 + offset - nextCursor3;
+        const oldEnd = op.type === "insert" ? start : op.oldTo;
+        const nextEnd = equalEnd + (op.type === "delete" ? 0 : op.newText.length);
+        if (offset < nextEnd)
+          return start;
+        oldCursor3 = oldEnd;
+        nextCursor3 = nextEnd;
+      }
+      return oldCursor3 + offset - nextCursor3;
+    };
+    let oldCursor2 = 0, nextCursor2 = 0;
+    let ordinaryTarget = "";
+    const appendOrdinary = (end) => {
+      pieces.push({
+        beforeXml: renderCompareRunRange(tokens, oldCursor2, end, "passthrough"),
+        afterXml: ordinaryTarget,
+        ordinary: true
+      });
+      ordinaryTarget = "";
+      oldCursor2 = end;
+    };
+    for (const target of targets) {
+      if (!target)
+        return false;
+      if (!target.control) {
+        ordinaryTarget += target.xml;
+        nextCursor2 += target.text.length;
+        continue;
+      }
+      const start = mapOffset(nextCursor2), end = mapOffset(nextCursor2 + target.text.length);
+      if (start < oldCursor2 || end < start || end > oldText.length)
+        return false;
+      appendOrdinary(start);
+      const selected = renderCompareRunRange(tokens, start, end, "passthrough");
+      if (equivalentSimpleRunContent(selected, target.control.contentXml)) {
+        pieces.push({ beforeXml: target.control.contentXml, afterXml: target.xml });
+      } else {
+        pieces.push({ beforeXml: selected, afterXml: "", ordinary: true });
+        pieces.push({ beforeXml: "", afterXml: target.xml });
+      }
+      oldCursor2 = end;
+      nextCursor2 += target.text.length;
+    }
+    appendOrdinary(oldText.length);
+    return true;
+  };
+  let oldCursor = 0, nextCursor = 0;
+  for (const anchor of proof.anchors) {
+    if (!gap(proof.beforeRoots.slice(oldCursor, anchor.beforeIndex).join(""), proof.afterRoots.slice(nextCursor, anchor.afterIndex), nextCursor))
+      return null;
+    if (anchor.changed) {
+      pieces.push({ beforeXml: anchor.before.xml, afterXml: anchor.after.xml });
+    } else
+      pieces.push({ beforeXml: anchor.before.xml, afterXml: anchor.before.xml });
+    oldCursor = anchor.beforeIndex + 1;
+    nextCursor = anchor.afterIndex + 1;
+  }
+  if (!gap(proof.beforeRoots.slice(oldCursor).join(""), proof.afterRoots.slice(nextCursor), nextCursor))
+    return null;
+  return pieces;
+}
+function inspectInlineControlCompareBodyReplay(bytes, startByte, endByte, targetRunXml) {
+  const xml = TD60.decode(bytes);
+  const start = TD60.decode(bytes.subarray(0, startByte)).length;
+  const end = start + TD60.decode(bytes.subarray(startByte, endByte)).length;
+  const parsed = collectXmlElementRanges(xml);
+  if (parsed.errors.length)
+    return null;
+  const body = parsed.ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "body");
+  if (!body || !directXmlChildRanges(parsed.ranges, body).some((range) => range.start === start && range.end === end && range.tag.namespaceUri === NS_W && range.tag.localName === "p"))
+    return null;
+  const proof = inspectInlineControlReplay(extractCompareParagraphRunXml(xml.slice(start, end)), targetRunXml, textboxNamespaceBindingsFromPartBytes(bytes));
+  if (!proof)
+    return null;
+  const counts = new Map;
+  for (const range of parsed.ranges) {
+    if (range.tag.namespaceUri !== NS_W || range.tag.localName !== "sdtPr")
+      continue;
+    for (const id of directXmlChildRanges(parsed.ranges, range).filter((child) => child.tag.namespaceUri === NS_W && child.tag.localName === "id")) {
+      const raw = readXmlAttribute(id.tag, NS_W, "val")?.value;
+      if (raw !== undefined && /^-?\d+$/.test(raw) && Number.isSafeInteger(Number(raw))) {
+        const key2 = String(Number(raw));
+        counts.set(key2, (counts.get(key2) ?? 0) + 1);
+      }
+    }
+  }
+  if (proof.anchors.some((anchor) => counts.get(anchor.before.id) !== 1) || proof.inserted.some((control2) => counts.has(control2.id)))
+    return null;
+  return proof;
+}
+function directlyOwnedBodyParagraph(bytes, startByte, endByte) {
+  const xml = TD60.decode(bytes);
+  const start = TD60.decode(bytes.subarray(0, startByte)).length;
+  const end = start + TD60.decode(bytes.subarray(startByte, endByte)).length;
+  const parsed = collectXmlElementRanges(xml);
+  const body = parsed.ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "body");
+  return !parsed.errors.length && !!body && directXmlChildRanges(parsed.ranges, body).some((range) => range.start === start && range.end === end && range.tag.namespaceUri === NS_W && range.tag.localName === "p");
+}
 function runInlineControlRemovalCommit(input, storyId, step2, changeMode, options, pushHistory) {
   const { state, txId } = input;
   const partUri = storyPartUriFromStoryId2(storyId);
@@ -225086,7 +225492,10 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
   const before = extractCompareParagraphRunXml(paragraph);
   const namespaces = textboxNamespaceBindingsFromPartBytes(bytes);
   const proof = inspectInlineControlRemoval(before, step2.targetRunXml, namespaces);
-  if (!proof || /<(?:[\w.-]+:)?\w+Change\b/.test(properties))
+  const replay = inspectInlineControlCompareBodyReplay(bytes, entry.byteStart, entry.byteEnd, step2.targetRunXml);
+  if (replay && !/^[0-9A-Fa-f]{8}$/.test(step2.blockId))
+    return rejected14(txId, "unsupported-context");
+  if (!proof && !replay || !directlyOwnedBodyParagraph(bytes, entry.byteStart, entry.byteEnd) || /<(?:[\w.-]+:)?\w+Change\b/.test(properties))
     return rejected14(txId, "unsupported-context");
   const targetProperties = step2.targetParagraphPropertiesXml === undefined ? properties : rewriteCanonicalWordprocessingPrefix(step2.targetParagraphPropertiesXml, wrapper.wordprocessingPrefix);
   if (!equivalentParagraphProperties(properties, targetProperties))
@@ -225099,7 +225508,9 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
       return rejected14(txId, "no-author-configured");
     const namespaceBindings = new Map(Object.entries(namespaces));
     namespaceBindings.set(wrapper.wordprocessingPrefix, W_NS4);
-    const pieces = [];
+    const pieces = replay ? inlineComparePieces(replay) ?? [] : [];
+    if (replay && !pieces.length)
+      return rejected14(txId, "unsupported-context");
     const appendGap = (old, next) => {
       let head = 0;
       while (head < old.length && head < next.length && old[head] === next[head])
@@ -225116,7 +225527,7 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
     };
     let oldCursor = 0;
     let nextCursor = 0;
-    for (let index = 0;index < proof.afterRoots.length; index++) {
+    for (let index = 0;proof && !replay && index < proof.afterRoots.length; index++) {
       const root = proof.afterRoots[index];
       if (!/<(?:[\w.-]+:)?sdt\b/.test(root))
         continue;
@@ -225128,12 +225539,33 @@ function runInlineControlRemovalCommit(input, storyId, step2, changeMode, option
       oldCursor = oldIndex + 1;
       nextCursor = index + 1;
     }
-    appendGap(proof.beforeRoots.slice(oldCursor), proof.afterRoots.slice(nextCursor));
+    if (proof && !replay)
+      appendGap(proof.beforeRoots.slice(oldCursor), proof.afterRoots.slice(nextCursor));
     const stamp = { revisionId: 0, author: serializedSessionAuthor(sourceAuthor), date: input.txTimestamp };
     const prepare = (revisionIds) => {
       let xml = "";
       const wordIds = [];
       for (const piece of pieces) {
+        if (piece.beforeXml === piece.afterXml) {
+          xml += piece.beforeXml;
+          continue;
+        }
+        if (piece.ordinary && !/<(?:[\w.-]+:)?sdt\b/.test(piece.beforeXml + piece.afterXml)) {
+          const result2 = renderWordLevelTrackedRunSegment(piece.beforeXml, piece.afterXml, () => {
+            const delId = revisionIds?.[wordIds.length] ?? wordIds.length;
+            wordIds.push(String(delId));
+            const insId = revisionIds?.[wordIds.length] ?? wordIds.length;
+            wordIds.push(String(insId));
+            return {
+              del: { rsid: delId.toString(16).padStart(8, "0"), wId: delId, author: stamp.author, date: stamp.date },
+              ins: { rsid: delId.toString(16).padStart(8, "0"), wId: insId, author: stamp.author, date: stamp.date }
+            };
+          }, wrapper.wordprocessingPrefix);
+          if (result2) {
+            xml += result2.xml;
+            continue;
+          }
+        }
         const result = prepareTrackedSdtXmlReplacement({
           beforeXml: piece.beforeXml,
           afterXml: piece.afterXml,
@@ -236491,7 +236923,7 @@ function resolveFragmentApplyTarget(state, op) {
       const index2 = paragraphIndexForPasteStory(state, target.storyId);
       if (!index2)
         return { ok: false, reason: "unsupported-context" };
-      const structuralFailure = validateRangeCollapseStructure(bytes, index2.entries, anchor.entry, anchor.entry, op.changeMode ?? "direct", undefined, undefined, { allowWholeParagraphReplacement: true });
+      const structuralFailure = validateRangeCollapseStructure(bytes, index2.entries, anchor.entry, anchor.entry, op.changeMode ?? "direct", undefined, undefined, { allowWholeParagraphReplacement: true, inlineRange: { startOffset: 0, endOffset: anchor.entry.textLength, deleteFullBlocks: true } });
       if (structuralFailure)
         return { ok: false, reason: structuralFailure };
       const integrityFailure = validateFragmentRangeIntegrity({
@@ -236567,7 +236999,7 @@ function resolveFragmentApplyTarget(state, op) {
   const crossParagraph = startAnchor.ordinal !== endAnchor.ordinal;
   const replacesContent = crossParagraph || target.charOffset !== explicitEnd.charOffset;
   if (crossParagraph) {
-    const structuralFailure = validateRangeCollapseStructure(residentBytes, index.entries, startAnchor.entry, endAnchor.entry, op.changeMode ?? "direct", target.collapsedObjectBoundary, explicitEnd.objectBoundary, { allowTrackedSdtContent: true });
+    const structuralFailure = validateRangeCollapseStructure(residentBytes, index.entries, startAnchor.entry, endAnchor.entry, op.changeMode ?? "direct", target.collapsedObjectBoundary, explicitEnd.objectBoundary, { allowTrackedSdtContent: true, inlineRange: { startOffset: target.charOffset, endOffset: explicitEnd.charOffset } });
     if (structuralFailure)
       return { ok: false, reason: structuralFailure };
   } else if (replacesContent && residentBytes) {
@@ -255950,6 +256382,7 @@ var init_sd_document_session_internal = __esm(() => {
   init_section_property_references();
   init_bibliography_style();
   init_bibliography_review_resources();
+  init_compile_compare_apply();
 });
 
 // ../../../v2/document-api-v2-adapter/dist/address/story-identity.js
@@ -316552,9 +316985,9 @@ var init_codes = __esm(() => {
 });
 
 // ../../../v2/node_modules/.pnpm/micromark-util-symbol@2.0.1/node_modules/micromark-util-symbol/lib/constants.js
-var constants;
+var constants2;
 var init_constants = __esm(() => {
-  constants = {
+  constants2 = {
     attentionSideAfter: 2,
     attentionSideBefore: 1,
     atxHeadingOpeningFenceSizeMax: 6,
@@ -316828,7 +317261,7 @@ function splice(list, start, remove, items) {
     start = start > end ? end : start;
   }
   remove = remove > 0 ? remove : 0;
-  if (items.length < constants.v8MaxSafeChunkSize) {
+  if (items.length < constants2.v8MaxSafeChunkSize) {
     parameters = Array.from(items);
     parameters.unshift(start, remove);
     list.splice(...parameters);
@@ -316836,11 +317269,11 @@ function splice(list, start, remove, items) {
     if (remove)
       list.splice(start, remove);
     while (chunkStart < items.length) {
-      parameters = items.slice(chunkStart, chunkStart + constants.v8MaxSafeChunkSize);
+      parameters = items.slice(chunkStart, chunkStart + constants2.v8MaxSafeChunkSize);
       parameters.unshift(start, 0);
       list.splice(...parameters);
-      chunkStart += constants.v8MaxSafeChunkSize;
-      start += constants.v8MaxSafeChunkSize;
+      chunkStart += constants2.v8MaxSafeChunkSize;
+      start += constants2.v8MaxSafeChunkSize;
     }
   }
 }
@@ -316995,7 +317428,7 @@ function initializeContent(effects2) {
   }
   function lineStart(code) {
     const token = effects2.enter(types9.chunkText, {
-      contentType: constants.contentTypeText,
+      contentType: constants2.contentTypeText,
       previous
     });
     if (previous) {
@@ -317123,7 +317556,7 @@ function initializeDocument(effects2) {
     childFlow = childFlow || self.parser.flow(self.now());
     effects2.enter(types9.chunkFlow, {
       _tokenizer: childFlow,
-      contentType: constants.contentTypeFlow,
+      contentType: constants2.contentTypeFlow,
       previous: childToken
     });
     return flowContinue(code);
@@ -317208,7 +317641,7 @@ function initializeDocument(effects2) {
 }
 function tokenizeContainer(effects2, ok3, nok) {
   ok2(this.parser.constructs.disable.null, "expected `disable.null` to be populated");
-  return factorySpace(effects2, effects2.attempt(this.parser.constructs.document, ok3, nok), types9.linePrefix, this.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize);
+  return factorySpace(effects2, effects2.attempt(this.parser.constructs.document, ok3, nok), types9.linePrefix, this.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize);
 }
 var document3, containerConstruct;
 var init_document2 = __esm(() => {
@@ -317224,10 +317657,10 @@ var init_document2 = __esm(() => {
 // ../../../v2/node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/dev/index.js
 function classifyCharacter(code) {
   if (code === codes.eof || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
-    return constants.characterGroupWhitespace;
+    return constants2.characterGroupWhitespace;
   }
   if (unicodePunctuation(code)) {
-    return constants.characterGroupPunctuation;
+    return constants2.characterGroupPunctuation;
   }
 }
 var init_dev6 = __esm(() => {
@@ -317360,8 +317793,8 @@ function tokenizeAttention(effects2, ok3) {
     const token = effects2.exit("attentionSequence");
     const after = classifyCharacter(code);
     ok2(attentionMarkers, "expected `attentionMarkers` to be populated");
-    const open = !after || after === constants.characterGroupPunctuation && before || attentionMarkers.includes(code);
-    const close = !before || before === constants.characterGroupPunctuation && after || attentionMarkers.includes(previous);
+    const open = !after || after === constants2.characterGroupPunctuation && before || attentionMarkers.includes(code);
+    const close = !before || before === constants2.characterGroupPunctuation && after || attentionMarkers.includes(previous);
     token._open = Boolean(marker === codes.asterisk ? open : open && (before || !close));
     token._close = Boolean(marker === codes.asterisk ? close : close && (after || !open));
     return ok3(code);
@@ -317421,7 +317854,7 @@ function tokenizeAutolink(effects2, ok3, nok) {
       size = 0;
       return urlInside;
     }
-    if ((code === codes.plusSign || code === codes.dash || code === codes.dot || asciiAlphanumeric(code)) && size++ < constants.autolinkSchemeSizeMax) {
+    if ((code === codes.plusSign || code === codes.dash || code === codes.dot || asciiAlphanumeric(code)) && size++ < constants2.autolinkSchemeSizeMax) {
       effects2.consume(code);
       return schemeInsideOrEmailAtext;
     }
@@ -317474,7 +317907,7 @@ function tokenizeAutolink(effects2, ok3, nok) {
     return emailValue(code);
   }
   function emailValue(code) {
-    if ((code === codes.dash || asciiAlphanumeric(code)) && size++ < constants.autolinkDomainSizeMax) {
+    if ((code === codes.dash || asciiAlphanumeric(code)) && size++ < constants2.autolinkDomainSizeMax) {
       const next = code === codes.dash ? emailValue : emailLabel;
       effects2.consume(code);
       return next;
@@ -317546,7 +317979,7 @@ function tokenizeBlockQuoteContinuation(effects2, ok3, nok) {
   function contStart(code) {
     if (markdownSpace(code)) {
       ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-      return factorySpace(effects2, contBefore, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize)(code);
+      return factorySpace(effects2, contBefore, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code);
     }
     return contBefore(code);
   }
@@ -317627,7 +318060,7 @@ function tokenizeCharacterReference(effects2, ok3, nok) {
       return numeric;
     }
     effects2.enter(types9.characterReferenceValue);
-    max2 = constants.characterReferenceNamedSizeMax;
+    max2 = constants2.characterReferenceNamedSizeMax;
     test = asciiAlphanumeric;
     return value2(code);
   }
@@ -317637,12 +318070,12 @@ function tokenizeCharacterReference(effects2, ok3, nok) {
       effects2.consume(code);
       effects2.exit(types9.characterReferenceMarkerHexadecimal);
       effects2.enter(types9.characterReferenceValue);
-      max2 = constants.characterReferenceHexadecimalSizeMax;
+      max2 = constants2.characterReferenceHexadecimalSizeMax;
       test = asciiHexDigit;
       return value2;
     }
     effects2.enter(types9.characterReferenceValue);
-    max2 = constants.characterReferenceDecimalSizeMax;
+    max2 = constants2.characterReferenceDecimalSizeMax;
     test = asciiDigit;
     return value2(code);
   }
@@ -317704,7 +318137,7 @@ function tokenizeCodeFenced(effects2, ok3, nok) {
       effects2.consume(code);
       return sequenceOpen;
     }
-    if (sizeOpen < constants.codeFencedSequenceSizeMin) {
+    if (sizeOpen < constants2.codeFencedSequenceSizeMin) {
       return nok(code);
     }
     effects2.exit(types9.codeFencedFenceSequence);
@@ -317716,7 +318149,7 @@ function tokenizeCodeFenced(effects2, ok3, nok) {
       return self.interrupt ? ok3(code) : effects2.check(nonLazyContinuation, atNonLazyBreak, after)(code);
     }
     effects2.enter(types9.codeFencedFenceInfo);
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return info(code);
   }
   function info(code) {
@@ -317741,7 +318174,7 @@ function tokenizeCodeFenced(effects2, ok3, nok) {
       return infoBefore(code);
     }
     effects2.enter(types9.codeFencedFenceMeta);
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return meta3(code);
   }
   function meta3(code) {
@@ -317802,7 +318235,7 @@ function tokenizeCodeFenced(effects2, ok3, nok) {
     function start2(code) {
       ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
       effects3.enter(types9.codeFencedFence);
-      return markdownSpace(code) ? factorySpace(effects3, beforeSequenceClose, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize)(code) : beforeSequenceClose(code);
+      return markdownSpace(code) ? factorySpace(effects3, beforeSequenceClose, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code) : beforeSequenceClose(code);
     }
     function beforeSequenceClose(code) {
       if (code === marker) {
@@ -317873,11 +318306,11 @@ function tokenizeCodeIndented(effects2, ok3, nok) {
   function start(code) {
     ok2(markdownSpace(code));
     effects2.enter(types9.codeIndented);
-    return factorySpace(effects2, afterPrefix, types9.linePrefix, constants.tabSize + 1)(code);
+    return factorySpace(effects2, afterPrefix, types9.linePrefix, constants2.tabSize + 1)(code);
   }
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize ? atBreak(code) : nok(code);
+    return tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize ? atBreak(code) : nok(code);
   }
   function atBreak(code) {
     if (code === codes.eof) {
@@ -317915,11 +318348,11 @@ function tokenizeFurtherStart(effects2, ok3, nok) {
       effects2.exit(types9.lineEnding);
       return furtherStart2;
     }
-    return factorySpace(effects2, afterPrefix, types9.linePrefix, constants.tabSize + 1)(code);
+    return factorySpace(effects2, afterPrefix, types9.linePrefix, constants2.tabSize + 1)(code);
   }
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize ? ok3(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code);
+    return tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize ? ok3(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code);
   }
 }
 var codeIndented, furtherStart;
@@ -318131,12 +318564,12 @@ class SpliceBuffer {
 }
 function chunkedPush(list, right) {
   let chunkStart = 0;
-  if (right.length < constants.v8MaxSafeChunkSize) {
+  if (right.length < constants2.v8MaxSafeChunkSize) {
     list.push(...right);
   } else {
     while (chunkStart < right.length) {
-      list.push(...right.slice(chunkStart, chunkStart + constants.v8MaxSafeChunkSize));
-      chunkStart += constants.v8MaxSafeChunkSize;
+      list.push(...right.slice(chunkStart, chunkStart + constants2.v8MaxSafeChunkSize));
+      chunkStart += constants2.v8MaxSafeChunkSize;
     }
   }
 }
@@ -318315,7 +318748,7 @@ function tokenizeContent(effects2, ok3) {
     ok2(code !== codes.eof && !markdownLineEnding(code), "expected no eof or eol");
     effects2.enter(types9.content);
     previous2 = effects2.enter(types9.chunkContent, {
-      contentType: constants.contentTypeContent
+      contentType: constants2.contentTypeContent
     });
     return chunkInside(code);
   }
@@ -318340,7 +318773,7 @@ function tokenizeContent(effects2, ok3) {
     effects2.exit(types9.chunkContent);
     ok2(previous2, "expected previous token");
     previous2.next = effects2.enter(types9.chunkContent, {
-      contentType: constants.contentTypeContent,
+      contentType: constants2.contentTypeContent,
       previous: previous2
     });
     previous2 = previous2.next;
@@ -318364,7 +318797,7 @@ function tokenizeContinuation(effects2, ok3, nok) {
     }
     ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
     const tail = self.events[self.events.length - 1];
-    if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize) {
+    if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === types9.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize) {
       return ok3(code);
     }
     return effects2.interrupt(self.parser.constructs.flow, nok, ok3)(code);
@@ -318401,7 +318834,7 @@ function factoryDestination(effects2, ok3, nok, type, literalType2, literalMarke
     effects2.enter(type);
     effects2.enter(rawType);
     effects2.enter(stringType2);
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return raw(code);
   }
   function enclosedBefore(code) {
@@ -318414,7 +318847,7 @@ function factoryDestination(effects2, ok3, nok, type, literalType2, literalMarke
       return ok3;
     }
     effects2.enter(stringType2);
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return enclosed(code);
   }
   function enclosed(code) {
@@ -318489,7 +318922,7 @@ function factoryLabel(effects2, ok3, nok, type, markerType, stringType2) {
     return atBreak;
   }
   function atBreak(code) {
-    if (size > constants.linkReferenceSizeMax || code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket && !seen || code === codes.caret && !size && "_hiddenFootnoteSupport" in self.parser.constructs) {
+    if (size > constants2.linkReferenceSizeMax || code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket && !seen || code === codes.caret && !size && "_hiddenFootnoteSupport" in self.parser.constructs) {
       return nok(code);
     }
     if (code === codes.rightSquareBracket) {
@@ -318506,11 +318939,11 @@ function factoryLabel(effects2, ok3, nok, type, markerType, stringType2) {
       effects2.exit(types9.lineEnding);
       return atBreak;
     }
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return labelInside(code);
   }
   function labelInside(code) {
-    if (code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket || markdownLineEnding(code) || size++ > constants.linkReferenceSizeMax) {
+    if (code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket || markdownLineEnding(code) || size++ > constants2.linkReferenceSizeMax) {
       effects2.exit(types9.chunkString);
       return atBreak(code);
     }
@@ -318574,7 +319007,7 @@ function factoryTitle(effects2, ok3, nok, type, markerType, stringType2) {
       effects2.exit(types9.lineEnding);
       return factorySpace(effects2, atBreak, types9.linePrefix);
     }
-    effects2.enter(types9.chunkString, { contentType: constants.contentTypeString });
+    effects2.enter(types9.chunkString, { contentType: constants2.contentTypeString });
     return inside(code);
   }
   function inside(code) {
@@ -318750,7 +319183,7 @@ function resolveHeadingAtx(events, context) {
       type: types9.chunkText,
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end,
-      contentType: constants.contentTypeText
+      contentType: constants2.contentTypeText
     };
     splice(events, contentStart, contentEnd - contentStart + 1, [
       ["enter", content3, context],
@@ -318774,7 +319207,7 @@ function tokenizeHeadingAtx(effects2, ok3, nok) {
     return sequenceOpen(code);
   }
   function sequenceOpen(code) {
-    if (code === codes.numberSign && size++ < constants.atxHeadingOpeningFenceSizeMax) {
+    if (code === codes.numberSign && size++ < constants2.atxHeadingOpeningFenceSizeMax) {
       effects2.consume(code);
       return sequenceOpen;
     }
@@ -318945,7 +319378,7 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
     }
     if (code === codes.questionMark) {
       effects2.consume(code);
-      marker = constants.htmlInstruction;
+      marker = constants2.htmlInstruction;
       return self.interrupt ? ok3 : continuationDeclarationInside;
     }
     if (asciiAlpha(code)) {
@@ -318959,18 +319392,18 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
   function declarationOpen(code) {
     if (code === codes.dash) {
       effects2.consume(code);
-      marker = constants.htmlComment;
+      marker = constants2.htmlComment;
       return commentOpenInside;
     }
     if (code === codes.leftSquareBracket) {
       effects2.consume(code);
-      marker = constants.htmlCdata;
+      marker = constants2.htmlCdata;
       index = 0;
       return cdataOpenInside;
     }
     if (asciiAlpha(code)) {
       effects2.consume(code);
-      marker = constants.htmlDeclaration;
+      marker = constants2.htmlDeclaration;
       return self.interrupt ? ok3 : continuationDeclarationInside;
     }
     return nok(code);
@@ -318983,7 +319416,7 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
     return nok(code);
   }
   function cdataOpenInside(code) {
-    const value2 = constants.cdataOpeningString;
+    const value2 = constants2.cdataOpeningString;
     if (code === value2.charCodeAt(index++)) {
       effects2.consume(code);
       if (index === value2.length) {
@@ -319007,18 +319440,18 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
       const slash = code === codes.slash;
       const name = buffer.toLowerCase();
       if (!slash && !closingTag && htmlRawNames.includes(name)) {
-        marker = constants.htmlRaw;
+        marker = constants2.htmlRaw;
         return self.interrupt ? ok3(code) : continuation(code);
       }
       if (htmlBlockNames.includes(buffer.toLowerCase())) {
-        marker = constants.htmlBasic;
+        marker = constants2.htmlBasic;
         if (slash) {
           effects2.consume(code);
           return basicSelfClosing;
         }
         return self.interrupt ? ok3(code) : continuation(code);
       }
-      marker = constants.htmlComplete;
+      marker = constants2.htmlComplete;
       return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);
     }
     if (code === codes.dash || asciiAlphanumeric(code)) {
@@ -319133,27 +319566,27 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
     return nok(code);
   }
   function continuation(code) {
-    if (code === codes.dash && marker === constants.htmlComment) {
+    if (code === codes.dash && marker === constants2.htmlComment) {
       effects2.consume(code);
       return continuationCommentInside;
     }
-    if (code === codes.lessThan && marker === constants.htmlRaw) {
+    if (code === codes.lessThan && marker === constants2.htmlRaw) {
       effects2.consume(code);
       return continuationRawTagOpen;
     }
-    if (code === codes.greaterThan && marker === constants.htmlDeclaration) {
+    if (code === codes.greaterThan && marker === constants2.htmlDeclaration) {
       effects2.consume(code);
       return continuationClose;
     }
-    if (code === codes.questionMark && marker === constants.htmlInstruction) {
+    if (code === codes.questionMark && marker === constants2.htmlInstruction) {
       effects2.consume(code);
       return continuationDeclarationInside;
     }
-    if (code === codes.rightSquareBracket && marker === constants.htmlCdata) {
+    if (code === codes.rightSquareBracket && marker === constants2.htmlCdata) {
       effects2.consume(code);
       return continuationCdataInside;
     }
-    if (markdownLineEnding(code) && (marker === constants.htmlBasic || marker === constants.htmlComplete)) {
+    if (markdownLineEnding(code) && (marker === constants2.htmlBasic || marker === constants2.htmlComplete)) {
       effects2.exit(types9.htmlFlowData);
       return effects2.check(blankLineBefore, continuationAfter, continuationStart)(code);
     }
@@ -319205,7 +319638,7 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
       }
       return continuation(code);
     }
-    if (asciiAlpha(code) && buffer.length < constants.htmlRawSizeMax) {
+    if (asciiAlpha(code) && buffer.length < constants2.htmlRawSizeMax) {
       ok2(code !== null);
       effects2.consume(code);
       buffer += String.fromCharCode(code);
@@ -319225,7 +319658,7 @@ function tokenizeHtmlFlow(effects2, ok3, nok) {
       effects2.consume(code);
       return continuationClose;
     }
-    if (code === codes.dash && marker === constants.htmlComment) {
+    if (code === codes.dash && marker === constants2.htmlComment) {
       effects2.consume(code);
       return continuationDeclarationInside;
     }
@@ -319372,7 +319805,7 @@ function tokenizeHtmlText(effects2, ok3, nok) {
     return code === codes.greaterThan ? end(code) : code === codes.dash ? commentClose(code) : comment(code);
   }
   function cdataOpenInside(code) {
-    const value2 = constants.cdataOpeningString;
+    const value2 = constants2.cdataOpeningString;
     if (code === value2.charCodeAt(index++)) {
       effects2.consume(code);
       return index === value2.length ? cdata : cdataOpenInside;
@@ -319588,7 +320021,7 @@ function tokenizeHtmlText(effects2, ok3, nok) {
   }
   function lineEndingAfter(code) {
     ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-    return markdownSpace(code) ? factorySpace(effects2, lineEndingAfterPrefix, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize)(code) : lineEndingAfterPrefix(code);
+    return markdownSpace(code) ? factorySpace(effects2, lineEndingAfterPrefix, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code) : lineEndingAfterPrefix(code);
   }
   function lineEndingAfterPrefix(code) {
     effects2.enter(types9.htmlTextData);
@@ -319751,7 +320184,7 @@ function tokenizeResource(effects2, ok3, nok) {
     if (code === codes.rightParenthesis) {
       return resourceEnd(code);
     }
-    return factoryDestination(effects2, resourceDestinationAfter, resourceDestinationMissing, types9.resourceDestination, types9.resourceDestinationLiteral, types9.resourceDestinationLiteralMarker, types9.resourceDestinationRaw, types9.resourceDestinationString, constants.linkResourceDestinationBalanceMax)(code);
+    return factoryDestination(effects2, resourceDestinationAfter, resourceDestinationMissing, types9.resourceDestination, types9.resourceDestinationLiteral, types9.resourceDestinationLiteralMarker, types9.resourceDestinationRaw, types9.resourceDestinationString, constants2.linkResourceDestinationBalanceMax)(code);
   }
   function resourceDestinationAfter(code) {
     return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects2, resourceBetween)(code) : resourceEnd(code);
@@ -319942,7 +320375,7 @@ function tokenizeThematicBreak(effects2, ok3, nok) {
       effects2.enter(types9.thematicBreakSequence);
       return sequence(code);
     }
-    if (size >= constants.thematicBreakMarkerCountMin && (code === codes.eof || markdownLineEnding(code))) {
+    if (size >= constants2.thematicBreakMarkerCountMin && (code === codes.eof || markdownLineEnding(code))) {
       effects2.exit(types9.thematicBreak);
       return ok3(code);
     }
@@ -319999,7 +320432,7 @@ function tokenizeListStart(effects2, ok3, nok) {
   }
   function inside(code) {
     ok2(self.containerState, "expected state");
-    if (asciiDigit(code) && ++size < constants.listItemValueSizeMax) {
+    if (asciiDigit(code) && ++size < constants2.listItemValueSizeMax) {
       effects2.consume(code);
       return inside;
     }
@@ -320066,7 +320499,7 @@ function tokenizeListContinuation(effects2, ok3, nok) {
     self.containerState._closeFlow = true;
     self.interrupt = undefined;
     ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-    return factorySpace(effects2, effects2.attempt(list, ok3, nok), types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize)(code);
+    return factorySpace(effects2, effects2.attempt(list, ok3, nok), types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code);
   }
 }
 function tokenizeIndent(effects2, ok3, nok) {
@@ -320088,7 +320521,7 @@ function tokenizeListEnd(effects2) {
 function tokenizeListItemPrefixWhitespace(effects2, ok3, nok) {
   const self = this;
   ok2(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-  return factorySpace(effects2, afterPrefix, types9.listItemPrefixWhitespace, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize + 1);
+  return factorySpace(effects2, afterPrefix, types9.listItemPrefixWhitespace, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize + 1);
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
     return !markdownSpace(code) && tail && tail[1].type === types9.listItemPrefixWhitespace ? ok3(code) : nok(code);
@@ -320386,7 +320819,7 @@ function resolveAllLineSuffixes(events, context) {
       }
       if (size) {
         const token = {
-          type: eventIndex === events.length || tabs2 || size < constants.hardBreakPrefixSizeMin ? types9.lineSuffix : types9.hardBreakTrailing,
+          type: eventIndex === events.length || tabs2 || size < constants2.hardBreakPrefixSizeMin ? types9.lineSuffix : types9.hardBreakTrailing,
           start: {
             _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,
             _index: data.start._index + index,
@@ -321642,7 +322075,7 @@ function preprocess2() {
             break;
           }
           case codes.ht: {
-            next = Math.ceil(column / constants.tabSize) * constants.tabSize;
+            next = Math.ceil(column / constants2.tabSize) * constants2.tabSize;
             chunks.push(codes.horizontalTab);
             while (column++ < next)
               chunks.push(codes.virtualSpace);
@@ -321696,7 +322129,7 @@ function decode4($0, $1, $2) {
   if (head === codes.numberSign) {
     const head2 = $2.charCodeAt(1);
     const hex3 = head2 === codes.lowercaseX || head2 === codes.uppercaseX;
-    return decodeNumericCharacterReference($2.slice(hex3 ? 2 : 1), hex3 ? constants.numericBaseHexadecimal : constants.numericBaseDecimal);
+    return decodeNumericCharacterReference($2.slice(hex3 ? 2 : 1), hex3 ? constants2.numericBaseHexadecimal : constants2.numericBaseDecimal);
   }
   return decodeNamedCharacterReference($2) || $0;
 }
@@ -322043,7 +322476,7 @@ function compiler(options) {
       const ancestor = this.stack[this.stack.length - 2];
       ok2(ancestor, "expected nodes on stack");
       ok2(ancestor.type === "list", "expected list on stack");
-      ancestor.start = Number.parseInt(this.sliceSerialize(token), constants.numericBaseDecimal);
+      ancestor.start = Number.parseInt(this.sliceSerialize(token), constants2.numericBaseDecimal);
       this.data.expectingFirstListItemValue = undefined;
     }
   }
@@ -322284,7 +322717,7 @@ function compiler(options) {
     const type = this.data.characterReferenceType;
     let value2;
     if (type) {
-      value2 = decodeNumericCharacterReference(data2, type === types9.characterReferenceMarkerNumeric ? constants.numericBaseDecimal : constants.numericBaseHexadecimal);
+      value2 = decodeNumericCharacterReference(data2, type === types9.characterReferenceMarkerNumeric ? constants2.numericBaseDecimal : constants2.numericBaseHexadecimal);
       this.data.characterReferenceType = undefined;
     } else {
       const result = decodeNamedCharacterReference(data2);
@@ -323584,7 +324017,7 @@ function tokenizeGfmFootnoteCall(effects2, ok4, nok) {
     return callData;
   }
   function callData(code2) {
-    if (size > constants.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
+    if (size > constants2.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
       return nok(code2);
     }
     if (code2 === codes.rightSquareBracket) {
@@ -323643,7 +324076,7 @@ function tokenizeDefinitionStart(effects2, ok4, nok) {
     return nok(code2);
   }
   function labelInside(code2) {
-    if (size > constants.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
+    if (size > constants2.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
       return nok(code2);
     }
     if (code2 === codes.rightSquareBracket) {
@@ -323695,10 +324128,10 @@ function gfmFootnoteDefinitionEnd(effects2) {
 }
 function tokenizeIndent2(effects2, ok4, nok) {
   const self = this;
-  return factorySpace(effects2, afterPrefix, "gfmFootnoteDefinitionIndent", constants.tabSize + 1);
+  return factorySpace(effects2, afterPrefix, "gfmFootnoteDefinitionIndent", constants2.tabSize + 1);
   function afterPrefix(code2) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === constants.tabSize ? ok4(code2) : nok(code2);
+    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === constants2.tabSize ? ok4(code2) : nok(code2);
   }
 }
 var indent;
@@ -323810,8 +324243,8 @@ function gfmStrikethrough(options) {
         return nok(code2);
       const token = effects2.exit("strikethroughSequenceTemporary");
       const after = classifyCharacter(code2);
-      token._open = !after || after === constants.attentionSideAfter && Boolean(before);
-      token._close = !before || before === constants.attentionSideAfter && Boolean(after);
+      token._open = !after || after === constants2.attentionSideAfter && Boolean(before);
+      token._close = !before || before === constants2.attentionSideAfter && Boolean(after);
       return ok4(code2);
     }
   }
@@ -324010,7 +324443,7 @@ function tokenizeTable(effects2, ok4, nok) {
     seen = false;
     if (markdownSpace(code2)) {
       ok2(self.parser.constructs.disable.null, "expected `disabled.null`");
-      return factorySpace(effects2, headDelimiterBefore, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants.tabSize)(code2);
+      return factorySpace(effects2, headDelimiterBefore, types9.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code2);
     }
     return headDelimiterBefore(code2);
   }
@@ -324261,7 +324694,7 @@ function flushCell(map3, context, range, rowKind, rowEnd, previousCell) {
       const end = context.events[range[3]];
       start[1].end = Object.assign({}, end[1].end);
       start[1].type = types9.chunkText;
-      start[1].contentType = constants.contentTypeText;
+      start[1].contentType = constants2.contentTypeText;
       if (range[3] > range[2] + 1) {
         const a = range[2] + 1;
         const b = range[3] - range[2] - 1;
@@ -388597,7 +389030,7 @@ function serializeSelectionRange(context, target, includeHtml, options) {
     };
     const tableCellPath = boundaryMap.byBlockId(entry.blockId)?.tableCellPath ?? [];
     const blockSdtPath = boundaryMap.byBlockId(entry.blockId)?.blockSdtPath ?? [];
-    const properties = readParagraphProperties(paragraphXml);
+    const properties = readParagraphProperties2(paragraphXml);
     const selectedInlineControl = options?.wholeParagraphs !== true && startEntry.ordinal === endEntry.ordinal && map3.pieces.some((piece) => piece.kind === "container" && piece.containerKind === "sdt" && piece.visibleStart === from && piece.visibleEnd === to);
     const fullyCovered = !selectedInlineControl && from === 0 && to === map3.visibleLength && (options?.wholeParagraphs === true || startEntry.ordinal !== endEntry.ordinal || properties.styleRef !== undefined || properties.numbering !== undefined || hasParagraphProperties(paragraphXml));
     const styleModel = copyStyleModel ?? (copyStyleModel = compileCopyStyleModel(context));
@@ -389630,7 +390063,7 @@ function capturePPrXml(paragraphXml, notes) {
     return null;
   return pPr;
 }
-function readParagraphProperties(paragraphXml) {
+function readParagraphProperties2(paragraphXml) {
   const pPr = /<w:pPr\b(?:[^>]*\/>|[^>]*>[\s\S]*?<\/w:pPr\s*>)/.exec(paragraphXml)?.[0] ?? "";
   const styleRef = /<w:pStyle\b[^>]*w:val="([^"]+)"/.exec(pPr)?.[1];
   const numPr = /<w:numPr\b[\s\S]*?<\/w:numPr>/.exec(pPr)?.[0];
@@ -429198,6 +429631,7 @@ function emissionContext(owner, xml) {
   return cached2.context;
 }
 function materializeProjection(input) {
+  const readStorySnapshot = input.readStorySnapshot ?? snapshotStoryShard;
   const previousById = new Map;
   const previousByPartUri = new Map;
   if (input.previousRecord) {
@@ -429290,6 +429724,7 @@ function materializeProjection(input) {
   let fullStoryRebuilds = 0;
   const storyHandles = input.shardRegistry.listStories();
   const stories = [];
+  const contentControlTopologies = new Map;
   const sourceBootstrapDigests = new Map;
   for (const handle of storyHandles) {
     const readTarget = shardReadTarget(handle);
@@ -429307,7 +429742,7 @@ function materializeProjection(input) {
     }
     const namespaces = previous3 ? emissionContext(previous3, previous3.xml) : bootstrap?.sourceXml ? emissionContext(bootstrap, bootstrap.sourceXml) : new XmlEmissionContext("");
     const sourceNamespaces = bootstrap?.sourceXml ? emissionContext(bootstrap, bootstrap.sourceXml) : namespaces;
-    let useBootstrapSourceXml = !previous3 && (bootstrap?.sourceStoryDigest ? canonicalDigest(snapshotStoryShard(readTarget)) === bootstrap.sourceStoryDigest : !explicitDirtyStoryShardIds.has(handle.shardId)) && typeof bootstrap?.sourceXml === "string" && bootstrap.sourceXml.length > 0;
+    let useBootstrapSourceXml = !previous3 && (bootstrap?.sourceStoryDigest ? canonicalDigest(readStorySnapshot(readTarget)) === bootstrap.sourceStoryDigest : !explicitDirtyStoryShardIds.has(handle.shardId)) && typeof bootstrap?.sourceXml === "string" && bootstrap.sourceXml.length > 0;
     const syntheticAtoms = buildSyntheticCommentAtomsForStory({
       storyDoc: readTarget,
       storyShardId: handle.shardId,
@@ -429315,7 +429750,7 @@ function materializeProjection(input) {
     });
     if (syntheticAtoms.size > 0)
       useBootstrapSourceXml = false;
-    if (previous3 && sourceBootstrapDigest && bootstrap?.sourceStoryDigest && previous3.xml === bootstrap.sourceXml && syntheticAtoms.size === 0 && canonicalDigest(snapshotStoryShard(readTarget)) === bootstrap.sourceStoryDigest) {
+    if (previous3 && sourceBootstrapDigest && bootstrap?.sourceStoryDigest && previous3.xml === bootstrap.sourceXml && syntheticAtoms.size === 0 && canonicalDigest(readStorySnapshot(readTarget)) === bootstrap.sourceStoryDigest) {
       stories.push(previous3);
       continue;
     }
@@ -429327,12 +429762,30 @@ function materializeProjection(input) {
     const tableReplacements = readTableStructuralReplacements(readTarget);
     const previousBlockIndex = previous3 ? blockDigestIndex(previous3.blockDigests) : null;
     const insertedBlockHint = previousBlockIndex && [...dirtyStoryBlocks.get(handle.shardId) ?? []].some((blockId) => !previousBlockIndex.has(blockId));
-    const structuralSnapshot = previous3 && (wholeStoryDirtyShardIds.has(handle.shardId) || insertedBlockHint) ? snapshotStoryShard(readTarget) : null;
+    const structuralSnapshot = previous3 && (wholeStoryDirtyShardIds.has(handle.shardId) || insertedBlockHint) ? readStorySnapshot(readTarget) : null;
     const overlaidTableIds = structuralSnapshot ? new Set(tableReplacements.map((table) => table.tableNodeId)) : null;
     const restoredTableBoundary = structuralSnapshot && previousBlockIndex ? structuralSnapshot.blocks.some((block) => block.structuralRefs.tableNodeId != null && !previousBlockIndex.has(block.blockId) && !overlaidTableIds.has(block.structuralRefs.tableNodeId)) : false;
     const removedTableBoundary = structuralSnapshot && previous3 ? hasRemovedTableBoundary(previous3, structuralSnapshot.blocks, new Set(tableReplacements.filter((table) => table.deltaKind === "table.rewrite" && table.xml === "").flatMap((table) => table.affectedBlockIds))) : false;
-    if (hasContentControlGroups(resolveStoryShardScope(readTarget)) || restoredTableBoundary || removedTableBoundary) {
-      const snapshot4 = structuralSnapshot ?? snapshotStoryShard(readTarget);
+    const controlledSnapshot = hasContentControlGroups(resolveStoryShardScope(readTarget)) ? structuralSnapshot ?? readStorySnapshot(readTarget) : null;
+    let controlledTextOnly = false;
+    if (controlledSnapshot) {
+      const envelope = storyEnvelope(controlledSnapshot.meta.storyKind, bootstrap);
+      const prior = previous3 ? CONTENT_CONTROL_TOPOLOGIES.get(previous3) : undefined;
+      const stable = prior && prior.prefix === envelope.prefix && prior.suffix === envelope.suffix && prior.sourceXml === bootstrap?.sourceXml && prior.trailingXml === controlledSnapshot.meta.trailingXml && prior.blocks.length === controlledSnapshot.blocks.length && controlledSnapshot.blocks.every((block, index2) => {
+        const old = prior.blocks[index2];
+        return block.blockId === old.blockId && block.leadingXml === old.leadingXml && block.trailingXml === old.trailingXml && block.splitFromBlockId === old.splitFromBlockId;
+      });
+      controlledTextOnly = !!stable && !fullPackageRebuild && !insertedBlockHint && !wholeStoryDirtyShardIds.has(handle.shardId) && tableReplacements.length === 0 && input.dirty.length > 0 && input.dirty.every((dirty) => dirty.kind === PROJECTION_DIRTY_KIND.storyText && dirty.shardId === handle.shardId && !!dirty.blockId);
+      contentControlTopologies.set(partUriHint, stable ? prior : {
+        prefix: envelope.prefix,
+        suffix: envelope.suffix,
+        sourceXml: bootstrap?.sourceXml,
+        trailingXml: controlledSnapshot.meta.trailingXml,
+        blocks: controlledSnapshot.blocks.map(({ blockId, leadingXml, trailingXml, splitFromBlockId }) => ({ blockId, leadingXml, trailingXml, splitFromBlockId }))
+      });
+    }
+    if (controlledSnapshot && !controlledTextOnly || restoredTableBoundary || removedTableBoundary) {
+      const snapshot4 = controlledSnapshot ?? structuralSnapshot ?? readStorySnapshot(readTarget);
       const placements2 = projectedNamespaceContexts(snapshot4, bootstrap, sourceNamespaces);
       const blocks = snapshot4.blocks.map((block) => ({
         blockId: block.blockId,
@@ -429346,6 +429799,7 @@ function materializeProjection(input) {
       const composed = composeStoryProjection(snapshot4.meta.storyKind, blocks, bootstrap, snapshot4.meta.trailingXml);
       const base3 = { ...composed, partUri: partUriHint, storyId: storyIdHint, storyKind: snapshot4.meta.storyKind };
       const projected = composeTableStructuralProjection({
+        readStorySnapshot,
         handle,
         previous: base3,
         bootstrap,
@@ -429380,7 +429834,7 @@ function materializeProjection(input) {
         blockHints.add(blockId);
     }
     if (blockHints && blockHints.size > 0 && previous3) {
-      const currentSnapshot = structuralSnapshot ?? snapshotStoryShard(readTarget);
+      const currentSnapshot = structuralSnapshot ?? readStorySnapshot(readTarget);
       let placements2;
       const currentBlockIds = currentSnapshot.blocks.map((block) => block.blockId);
       if (wholeStoryDirtyShardIds.has(handle.shardId)) {
@@ -429520,6 +429974,7 @@ function materializeProjection(input) {
             };
           })();
           const projectedWithTables = composeTableStructuralProjection({
+            readStorySnapshot,
             handle,
             previous: blockPatchedStory,
             bootstrap,
@@ -429535,6 +429990,7 @@ function materializeProjection(input) {
           storiesRebuilt += 1;
         } else if (tableReplacements.length > 0) {
           const projectedWithTables = composeTableStructuralProjection({
+            readStorySnapshot,
             handle,
             previous: previous3,
             bootstrap,
@@ -429555,6 +430011,7 @@ function materializeProjection(input) {
       }
     }
     const tableStructuralProjection = composeTableStructuralProjection({
+      readStorySnapshot,
       handle,
       previous: previous3,
       bootstrap,
@@ -429570,7 +430027,7 @@ function materializeProjection(input) {
       storiesRebuilt += 1;
       continue;
     }
-    const snapshot3 = snapshotStoryShard(readTarget);
+    const snapshot3 = readStorySnapshot(readTarget);
     const placements = projectedNamespaceContexts(snapshot3, bootstrap, sourceNamespaces);
     const partUri = snapshot3.meta.sourcePartUri || `/word/story-${snapshot3.meta.storyId}.xml`;
     const blockDigests = [];
@@ -429628,6 +430085,11 @@ function materializeProjection(input) {
       stories[index2] = { ...story, sourceBootstrapDigest: digest6 };
   }
   stories.sort((a, b) => a.partUri < b.partUri ? -1 : a.partUri > b.partUri ? 1 : 0);
+  for (const story of stories) {
+    const topology = contentControlTopologies.get(story.partUri);
+    if (topology)
+      CONTENT_CONTROL_TOPOLOGIES.set(story, topology);
+  }
   let relationships = input.previousRecord?.relationships ? [...input.previousRecord.relationships] : [];
   let parts = input.previousRecord?.parts ? [...input.previousRecord.parts] : [];
   let contentTypes = input.previousRecord?.contentTypes ?? { defaults: [], overrides: [] };
@@ -429662,17 +430124,21 @@ function materializeProjection(input) {
     safety,
     digest: ""
   };
+  let projectionDigest;
   const withDigest = {
     ...record3,
-    digest: canonicalDigest({
-      stories: canonicalStoryDigestInputs(record3.stories),
-      parts: record3.parts,
-      relationships: record3.relationships,
-      contentTypes: record3.contentTypes,
-      media: record3.media,
-      safety: record3.safety,
-      snapshotToken: record3.snapshotToken.digest
-    })
+    get digest() {
+      projectionDigest ?? (projectionDigest = canonicalDigest({
+        stories: canonicalStoryDigestInputs(record3.stories),
+        parts: record3.parts,
+        relationships: record3.relationships,
+        contentTypes: record3.contentTypes,
+        media: record3.media,
+        safety: record3.safety,
+        snapshotToken: record3.snapshotToken.digest
+      }));
+      return projectionDigest;
+    }
   };
   return { record: withDigest, storiesRebuilt, fullStoryRebuilds, fullPackageRebuild };
 }
@@ -429790,6 +430256,12 @@ function blockProjection(block, extraAtoms = []) {
 }
 function projectedNamespaceContexts(snapshot3, bootstrap, source) {
   const envelope = storyEnvelope(snapshot3.meta.storyKind, bootstrap);
+  const cached2 = PROJECTED_NAMESPACE_CONTEXTS.get(source);
+  if (cached2 && cached2.prefix === envelope.prefix && cached2.suffix === envelope.suffix && cached2.trailingXml === snapshot3.meta.trailingXml && cached2.blocks.length === snapshot3.blocks.length && snapshot3.blocks.every((block, index2) => {
+    const prior = cached2.blocks[index2];
+    return block.blockId === prior.blockId && block.leadingXml === prior.leadingXml && block.trailingXml === prior.trailingXml && block.splitFromBlockId === prior.splitFromBlockId;
+  }))
+    return cached2.contexts;
   let wrappers = envelope.prefix;
   const positions = new Map;
   const blocksById = new Map(snapshot3.blocks.map((block) => [block.blockId, block]));
@@ -429799,9 +430271,6 @@ function projectedNamespaceContexts(snapshot3, bootstrap, source) {
     wrappers += `<projection-slot id="${xmlEscape(block.blockId)}" source="${xmlEscape(block.splitFromBlockId ?? "")}"/>${block.trailingXml ?? ""}`;
   }
   wrappers += snapshot3.meta.trailingXml + envelope.suffix;
-  const cached2 = PROJECTED_NAMESPACE_CONTEXTS.get(source);
-  if (cached2?.wrappers === wrappers)
-    return cached2.contexts;
   const placement3 = new XmlEmissionContext(wrappers);
   const contexts = new Map(snapshot3.blocks.map((block) => {
     const inherited = placement3.at(positions.get(block.blockId));
@@ -429815,7 +430284,13 @@ function projectedNamespaceContexts(snapshot3, bootstrap, source) {
     }
     return [block.blockId, { inherited, source: sourceBindings ?? inherited }];
   }));
-  PROJECTED_NAMESPACE_CONTEXTS.set(source, { wrappers, contexts });
+  PROJECTED_NAMESPACE_CONTEXTS.set(source, {
+    prefix: envelope.prefix,
+    suffix: envelope.suffix,
+    trailingXml: snapshot3.meta.trailingXml,
+    blocks: snapshot3.blocks.map(({ blockId, leadingXml, trailingXml, splitFromBlockId }) => ({ blockId, leadingXml, trailingXml, splitFromBlockId })),
+    contexts
+  });
   return contexts;
 }
 function hasRemovedTableBoundary(previous3, blocks, overlayDeletedBlockIds) {
@@ -429875,6 +430350,8 @@ function replaceProjectedTrailingXml(story, trailingXml, bootstrap) {
   if (start === null)
     throw new Error(`Story ${story.storyId} has no resolved trailing XML boundary.`);
   const suffix = trailingXml + envelope.suffix;
+  if (story.xml.slice(start) === suffix)
+    return story;
   const xml = story.xml.slice(0, start) + suffix;
   return { ...story, xml, byteLength: UTF8_ENCODER3.encode(xml).length };
 }
@@ -430450,9 +430927,12 @@ function removeRedundantSplitSeparators(projection, redundantBlockIds) {
   };
 }
 function composeTableStructuralProjection(input) {
-  const snapshotBlocks = snapshotStoryShard(shardReadTarget(input.handle)).blocks;
+  const replacements = input.tableReplacements ?? readTableStructuralReplacements(shardReadTarget(input.handle));
+  if (replacements.length === 0)
+    return null;
+  const snapshotBlocks = (input.readStorySnapshot ?? snapshotStoryShard)(shardReadTarget(input.handle)).blocks;
   const liveBlockIds = new Set(snapshotBlocks.map((block) => block.blockId));
-  const rawTableReplacements = (input.tableReplacements ?? readTableStructuralReplacements(shardReadTarget(input.handle))).map((replacement) => {
+  const rawTableReplacements = replacements.map((replacement) => {
     if (!replacement.creationPlacement && !replacement.relocation && !replacement.rowReordered && replacement.splitChildren.length === 0)
       return replacement;
     const liveTableBlockIds = snapshotBlocks.filter((block) => block.structuralRefs.tableNodeId === replacement.tableNodeId).map((block) => block.blockId);
@@ -432913,7 +433393,7 @@ function canonicalStoryDigestInputs(stories) {
     tableStructuralOverlays: [...story.tableStructuralOverlays ?? []].sort((left, right) => left.tableNodeId < right.tableNodeId ? -1 : left.tableNodeId > right.tableNodeId ? 1 : 0)
   }));
 }
-var WORD_ML_NS2 = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"', WORD_ML_2010_NS = 'xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"', STORY_ROOT_NS, TEXT_DECODER7, STORY_BLOCK_INDEX_CACHE, SYNTHETIC_PARAGRAPH_BLOCK_ID_PREFIX4 = "__sd:paragraph:", UTF8_ENCODER3, SOURCE_XML_BYTE_ALIGNED_CACHE, XML_EMISSION_CONTEXTS, PROJECTED_NAMESPACE_CONTEXTS, PARAGRAPH_PROPERTY_ORDER, RUN_PROPERTY_CONTENT_LOCAL_NAMES;
+var WORD_ML_NS2 = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"', WORD_ML_2010_NS = 'xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"', STORY_ROOT_NS, TEXT_DECODER7, STORY_BLOCK_INDEX_CACHE, SYNTHETIC_PARAGRAPH_BLOCK_ID_PREFIX4 = "__sd:paragraph:", UTF8_ENCODER3, SOURCE_XML_BYTE_ALIGNED_CACHE, XML_EMISSION_CONTEXTS, CONTENT_CONTROL_TOPOLOGIES, PROJECTED_NAMESPACE_CONTEXTS, PARAGRAPH_PROPERTY_ORDER, RUN_PROPERTY_CONTENT_LOCAL_NAMES;
 var init_materialize = __esm(() => {
   init_package_part();
   init_anchors();
@@ -432939,6 +433419,7 @@ var init_materialize = __esm(() => {
   UTF8_ENCODER3 = new TextEncoder;
   SOURCE_XML_BYTE_ALIGNED_CACHE = new WeakMap;
   XML_EMISSION_CONTEXTS = new WeakMap;
+  CONTENT_CONTROL_TOPOLOGIES = new WeakMap;
   PROJECTED_NAMESPACE_CONTEXTS = new WeakMap;
   PARAGRAPH_PROPERTY_ORDER = new Map([
     "pStyle",
@@ -433272,8 +433753,143 @@ var init_freshness = __esm(() => {
   }
 });
 
+// ../../../v2/collaboration-v2/dist/projection/story-snapshot-reader.js
+function createProjectionStorySnapshotReader() {
+  const stories = new Map;
+  function drop(state) {
+    state.dispose();
+    stories.delete(state.scope.blocks);
+  }
+  function create10(scope) {
+    const invalidate = () => {
+      state.snapshot = null;
+    };
+    const onBlocks = (events) => {
+      for (const event of events) {
+        if (event.target === scope.blocks) {
+          invalidate();
+          continue;
+        }
+        let owner = event.target;
+        while (owner && owner.parent !== scope.blocks) {
+          owner = owner.parent;
+        }
+        if (owner instanceof YMap)
+          state.dirty.add(owner);
+        else
+          invalidate();
+      }
+    };
+    const onMeta = (events) => {
+      if (events.some((event) => [...event.keysChanged ?? []].some((key2) => key2.startsWith("contentControlGroup:"))))
+        invalidate();
+    };
+    const onDestroy = () => drop(state);
+    const state = {
+      scope,
+      snapshot: null,
+      indices: new Map,
+      boundaries: new Map,
+      dirty: new Set,
+      dispose() {
+        scope.blocks.unobserveDeep(onBlocks);
+        scope.order.unobserveDeep(invalidate);
+        scope.meta.unobserveDeep(onMeta);
+        scope.doc.off("destroy", onDestroy);
+      }
+    };
+    scope.blocks.observeDeep(onBlocks);
+    scope.order.observeDeep(invalidate);
+    scope.meta.observeDeep(onMeta);
+    scope.doc.on("destroy", onDestroy);
+    return state;
+  }
+  function read2(target) {
+    const scope = resolveStoryShardScope(target);
+    if (scope.meta.get(STORY_META_KEY.storyKind) !== STORY_KIND.main)
+      return snapshotStoryShard(target);
+    if (scope.doc._transaction || scope.doc._transactionCleanups.length > 0)
+      return snapshotStoryShard(target);
+    let state = stories.get(scope.blocks);
+    if (state && (state.scope.meta !== scope.meta || state.scope.order !== scope.order || state.scope.tables !== scope.tables || state.scope.doc !== scope.doc)) {
+      drop(state);
+      state = undefined;
+    }
+    if (!state) {
+      state = create10(scope);
+      stories.set(scope.blocks, state);
+    }
+    if (state.snapshot && state.dirty.size) {
+      const blocks = [...state.snapshot.blocks];
+      for (const carrier of state.dirty) {
+        const index2 = state.indices.get(carrier);
+        const previous3 = index2 === undefined ? undefined : blocks[index2];
+        if (!previous3 || carrier.get(BLOCK_KEY.blockId) !== previous3.blockId || carrier.get(BLOCK_KEY.mergedIntoBlockId)) {
+          state.snapshot = null;
+          break;
+        }
+        const block = snapshotBlock(carrier);
+        const boundary = state.boundaries.get(carrier);
+        blocks[index2] = boundary.suffix === undefined && !boundary.prefix ? block : {
+          ...block,
+          leadingXml: block.leadingXml + boundary.prefix,
+          trailingXml: boundary.suffix
+        };
+      }
+      if (state.snapshot)
+        state.snapshot = { meta: readMeta(scope), blocks };
+    }
+    state.dirty.clear();
+    if (!state.snapshot) {
+      state.indices.clear();
+      state.boundaries.clear();
+      const snapshot3 = snapshotStoryShard(scope);
+      if (snapshot3.blocks.length !== scope.blocks.length || snapshot3.blocks.some((block) => block.mergedIntoBlockId || block.mergedTailBlockIds.length)) {
+        return snapshot3;
+      }
+      const indices = new Map;
+      for (const [index2, block] of snapshot3.blocks.entries()) {
+        const carrier = findBlockById(scope, block.blockId);
+        if (!carrier || indices.has(carrier))
+          return snapshot3;
+        const leading = String(carrier.get(BLOCK_KEY.leadingXml) ?? "");
+        if (!block.leadingXml.startsWith(leading))
+          return snapshot3;
+        state.boundaries.set(carrier, {
+          prefix: block.leadingXml.slice(leading.length),
+          suffix: block.trailingXml
+        });
+        indices.set(carrier, index2);
+      }
+      state.indices = indices;
+      state.snapshot = snapshot3;
+    }
+    return { meta: readMeta(scope), blocks: state.snapshot.blocks };
+  }
+  return {
+    read: read2,
+    retain(targets) {
+      const live = new Set(targets.map((target) => resolveStoryShardScope(target).blocks));
+      for (const state of stories.values())
+        if (!live.has(state.scope.blocks))
+          drop(state);
+    },
+    dispose() {
+      for (const state of stories.values())
+        drop(state);
+    }
+  };
+}
+var init_story_snapshot_reader = __esm(() => {
+  init_yjs();
+  init_constants4();
+  init_read_view();
+  init_scope3();
+});
+
 // ../../../v2/collaboration-v2/dist/projection/runtime.js
 function createCollabV2ProjectionRuntime(options) {
+  const storySnapshots = createProjectionStorySnapshotReader();
   let freshness = PROJECTION_FRESHNESS.dirty;
   let blockingReason = null;
   let lastCleanSnapshot = null;
@@ -433335,12 +433951,14 @@ function createCollabV2ProjectionRuntime(options) {
   function materialize(snapshotToken) {
     const currentImport = getPackagePartsMap(options.rootDoc);
     const replaced = currentImport !== projectedImport;
+    storySnapshots.retain(options.shardRegistry.listStories().map(shardReadTarget));
     const output = materializeProjection({
       snapshotToken,
       rootDoc: options.rootDoc,
       shardRegistry: options.shardRegistry,
       dirty: pendingDirty,
-      previousRecord: replaced ? null : lastCleanRecord
+      previousRecord: replaced ? null : lastCleanRecord,
+      readStorySnapshot: storySnapshots.read
     });
     projectedImport = currentImport;
     if (output.fullPackageRebuild)
@@ -433594,6 +434212,7 @@ function createCollabV2ProjectionRuntime(options) {
       hasCollabMutation = true;
     },
     reset() {
+      storySnapshots.dispose();
       pendingDirty = [];
       diagnostics = [];
       freshness = PROJECTION_FRESHNESS.dirty;
@@ -433621,6 +434240,7 @@ function createCollabV2ProjectionRuntime(options) {
       return freshness === PROJECTION_FRESHNESS.clean && pendingDirty.length === 0;
     },
     dispose() {
+      storySnapshots.dispose();
       disposed = true;
       freshness = PROJECTION_FRESHNESS.invalid;
       blockingReason = PROJECTION_BLOCKING_REASON.disposed;
@@ -433679,6 +434299,7 @@ var init_runtime5 = __esm(() => {
   init_checkpoint();
   init_reducer();
   init_schema3();
+  init_story_snapshot_reader();
   DEFAULT_BYTES_ENCODER = {
     encode: encodeProjectionAsBytes
   };
@@ -437065,8 +437686,8 @@ function applyPreflightedTrackedTextDecisionsToStory(input) {
       tx.meta.set(ACTOR_ATTRIBUTION_META_KEY, input.actorType);
       scope.meta.set(STORY_META_KEY.lastEditActorType, input.actorType);
       const { decision, doc: doc2, removedCommentCarrierIds, resolved, work } = input.plan;
-      for (const { target, span, block } of work) {
-        removeTrackedTextCarriers(block, span, decision === "reject" && target.carrierKind === "field-insertion");
+      for (const { span, block } of work) {
+        removeTrackedTextCarriers(block, span, decision === "reject" && span.trackedKind === "ins");
         removeCommentCarriersByIds(block, removedCommentCarrierIds);
       }
       const sorted = [...work].sort((left, right) => {
@@ -437083,12 +437704,12 @@ function applyPreflightedTrackedTextDecisionsToStory(input) {
         if (span.trackedKind === "ins" && decision === "reject") {
           const length3 = span.endOffset - span.startOffset;
           if (length3 > 0) {
-            deleteText2({
-              doc: doc2,
-              blockId: span.blockId,
+            deleteTextAtResolvedTarget({
+              target: resolveStoryTextMutationTarget(doc2, span.blockId),
               offset: span.startOffset,
               length: length3,
-              origin: STORY_SURFACE_BACKEND_ORIGIN
+              origin: STORY_SURFACE_BACKEND_ORIGIN,
+              preserveZeroLengthAtStart: true
             });
           }
         }
@@ -437456,8 +438077,19 @@ function validateCompareApplySessionSync(prepared, extension2, options) {
   if (!extension2.storyLocal || prepared.resolvedTargets.stories.length !== 1 || String(prepared.resolvedTargets.stories[0]) !== storyId || ownership.length !== 1 || String(ownership[0]?.storyId) !== storyId || prepared.resolvedTargets.partUris.length !== 1 || String(prepared.resolvedTargets.partUris[0]) !== String(ownership[0]?.partUri)) {
     return { ok: false, message: "compareApply collaboration requires one owned story part" };
   }
-  if (source.bodySteps.length === 0 || source.bodySteps.some((step3) => step3.kind !== "edit") || source.storyGroups?.length || source.storyPackageOperations?.length || source.commentSteps?.length || source.packageRewrites?.length || source.relationshipBackedBodyRewrites?.length || source.headerFooterLifecycle || source.headerFooterSlotSteps?.length || source.tableTopologySteps?.length || source.tableBlockSteps?.length || source.tablePropertySteps?.length || source.sectionReplaySteps?.length || source.referenceReplaySteps?.length) {
-    return { ok: false, message: "compareApply collaboration supports paragraph text edits only" };
+  if (source.bodySteps.length === 0 || source.bodySteps.some((step3) => {
+    if (step3.kind === "edit")
+      return false;
+    if (step3.kind !== "formatEdit" || step3.targetRunXml === undefined)
+      return true;
+    if (extension2.historyReplay)
+      return false;
+    const bytes = getSDDocumentSessionInternalPartBytes(options.session, String(ownership[0].partUri));
+    const entry = getSDDocumentSessionInternalStoryParagraphIndex(options.session, source.storyId)?.byParaId(step3.blockId);
+    const proof = bytes && entry && inspectInlineControlCompareBodyReplay(bytes, entry.byteStart, entry.byteEnd, step3.targetRunXml);
+    return !proof || proof.inserted.length === 0;
+  }) || source.storyGroups?.length || source.storyPackageOperations?.length || source.commentSteps?.length || source.packageRewrites?.length || source.relationshipBackedBodyRewrites?.length || source.headerFooterLifecycle || source.headerFooterSlotSteps?.length || source.tableTopologySteps?.length || source.tableBlockSteps?.length || source.tablePropertySteps?.length || source.sectionReplaySteps?.length || source.referenceReplaySteps?.length) {
+    return { ok: false, message: "compareApply collaboration supports paragraph text edits and proved inline control wrapping only" };
   }
   const targetBlockIds2 = [...new Set(source.bodySteps.map((step3) => step3.blockId))];
   if (targetBlockIds2.length !== extension2.targetBlockIds.length || targetBlockIds2.some((blockId) => !extension2.targetBlockIds.includes(blockId))) {
@@ -438769,6 +439401,7 @@ function atomOverlapsRange(atomOffset, atomLength, rangeStart, rangeEnd) {
 var STORY_SURFACE_TRACE, TRACKED_CHANGE_DECISIONS_LEDGER_KEY = "trackedChangeDecisions", CLEARED_RUN_ATTRIBUTES;
 var init_story_surface_execution_backend = __esm(() => {
   init_yjs();
+  init_sd_document_session_internal();
   init_scope3();
   init_content_control_groups();
   init_story_surface_session_sync();
@@ -439528,7 +440161,7 @@ function createCollabV2SessionProjectionController(options) {
       };
     }
     const forceStoryBytes = input.forceStoryBytes === true || sessionStoryAlignment === "room-realignment-required" && (remoteProjectionPending || deferredSessionAuthoritativeRemotePending);
-    if (!packageReplaced && !input.forceApply && !forceStoryBytes && lastAppliedRecord?.digest === record3.digest) {
+    if (!packageReplaced && !input.forceApply && !forceStoryBytes && lastAppliedRecord === record3) {
       return { ok: true };
     }
     const tBuild = projectionTraceNow();