@superdoc/mcp 1.2.0-next.12 → 1.2.0-next.14

package/dist/index.js

@@ -31314,7 +31314,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.15.0-next.12";
+var SDK_VERSION = "2.15.0-next.14";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -134832,26 +134832,68 @@ function canonicalName(namespace, localName2) {
     return `xml:${localName2}`;
   return namespace ? `{${namespace}}${localName2}` : localName2;
 }
-function computeRunSignature(runXml) {
-  const canonicalXml = canonicalizeXmlForSignature(runXml);
-  const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, (attribute, offset, xml) => {
-    const precedingTag = xml.slice(xml.lastIndexOf("<", offset), offset);
-    return /^<w:proofErr(?:\s|$)/.test(precedingTag) ? attribute : "";
-  }).replace(REVISION_ELEMENT_RE, (markup) => markup.replace(REVISION_ID_ATTR_RE, "")).replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
-    const name = nestedName ?? standaloneName;
-    const attributes = nestedAttributes ?? standaloneAttributes;
-    if (!isWordprocessingElement3(name, attributes, canonicalXml))
-      return markup;
-    if (runName && !isWordprocessingElement3(runName, runAttributes, canonicalXml))
-      return markup;
-    return "";
-  }));
-  let hash2 = 2166136261;
-  for (let i = 0;i < normalized.length; i += 1) {
-    hash2 ^= normalized.charCodeAt(i);
-    hash2 = Math.imul(hash2, 16777619) >>> 0;
+function normalizeBalancedBookmarkIds(canonicalXmls) {
+  const starts = new Map;
+  const ends = new Set;
+  const names = new Set;
+  for (const xml of canonicalXmls) {
+    const tags = [...xml.matchAll(BOOKMARK_TAG_RE)];
+    if (tags.length !== [...xml.matchAll(BOOKMARK_OPENING_RE)].length)
+      return canonicalXmls;
+    for (const tag of tags) {
+      if (tag[1] || !tag[0].endsWith("/>"))
+        return canonicalXmls;
+      const attributes = [...tag[3].matchAll(ATTRIBUTE_RE)];
+      const ids = attributes.filter((attribute) => attribute[1] === "w:id");
+      const bookmarkNames = attributes.filter((attribute) => attribute[1] === "w:name");
+      const id = ids[0]?.[2] ?? ids[0]?.[3];
+      if (ids.length !== 1 || !id || !/^\d+$/u.test(id))
+        return canonicalXmls;
+      if (tag[2] === "Start") {
+        const name = bookmarkNames[0]?.[2] ?? bookmarkNames[0]?.[3];
+        if (bookmarkNames.length !== 1 || !name || starts.has(id) || names.has(name))
+          return canonicalXmls;
+        starts.set(id, name);
+        names.add(name);
+      } else {
+        if (bookmarkNames.length > 0 || !starts.has(id) || ends.has(id))
+          return canonicalXmls;
+        ends.add(id);
+      }
+    }
   }
-  return `v2-run-${hash2.toString(16).padStart(8, "0")}`;
+  if (starts.size !== ends.size)
+    return canonicalXmls;
+  return canonicalXmls.map((xml) => xml.replace(BOOKMARK_TAG_RE, (tag, _closing, _kind, attributes) => {
+    const id = /\bw:id="([^"]*)"/u.exec(attributes)[1];
+    return tag.replace(/\bw:id="[^"]*"/u, `w:id=${JSON.stringify(`bookmark:${starts.get(id)}`)}`);
+  }));
+}
+function computeRunSignatures(runXmls) {
+  const canonicalXmls = normalizeBalancedBookmarkIds(runXmls.map(canonicalizeXmlForSignature));
+  return canonicalXmls.map((canonicalXml) => {
+    const normalized = normalizeRunXmlForSignature(canonicalXml.replace(REVISION_ATTR_RE, (attribute, offset, xml) => {
+      const precedingTag = xml.slice(xml.lastIndexOf("<", offset), offset);
+      return /^<w:proofErr(?:\s|$)/.test(precedingTag) ? attribute : "";
+    }).replace(REVISION_ELEMENT_RE, (markup) => markup.replace(REVISION_ID_ATTR_RE, "")).replace(COMMENT_MARKUP_RE, (markup, name, attributes) => isWordprocessingElement3(name, attributes, canonicalXml) ? "" : markup).replace(NOTE_REFERENCE_MARKUP_RE, (markup, runName, runAttributes, _rPrName, nestedName, nestedAttributes, standaloneName, standaloneAttributes) => {
+      const name = nestedName ?? standaloneName;
+      const attributes = nestedAttributes ?? standaloneAttributes;
+      if (!isWordprocessingElement3(name, attributes, canonicalXml))
+        return markup;
+      if (runName && !isWordprocessingElement3(runName, runAttributes, canonicalXml))
+        return markup;
+      return "";
+    }));
+    let hash2 = 2166136261;
+    for (let i = 0;i < normalized.length; i += 1) {
+      hash2 ^= normalized.charCodeAt(i);
+      hash2 = Math.imul(hash2, 16777619) >>> 0;
+    }
+    return `v2-run-${hash2.toString(16).padStart(8, "0")}`;
+  });
+}
+function computeRunSignature(runXml) {
+  return computeRunSignatures([runXml])[0];
 }
 function normalizeRunXmlForSignature(runXml) {
   const pieces = [];
@@ -134934,7 +134976,7 @@ function isWordprocessingElement3(name, attributes, namespaceContext) {
     return true;
   return (declaration[2] ?? declaration[3] ?? "") === WORDPROCESSINGML_NAMESPACE2;
 }
-var REVISION_ATTR_RE, REVISION_ELEMENT_RE, REVISION_ID_ATTR_RE, COMMENT_MARKUP_RE, PROOFING_BOUNDARY_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE;
+var REVISION_ATTR_RE, REVISION_ELEMENT_RE, REVISION_ID_ATTR_RE, COMMENT_MARKUP_RE, PROOFING_BOUNDARY_MARKUP_RE, NOTE_REFERENCE_MARKUP_RE, RUN_RE, RUN_PROPERTIES_RE, EMPTY_RUN_PROPERTIES_RE, TEXTISH_RE, RUN_CONTROL_RE, ATTRIBUTE_RE, WORDPROCESSINGML_NAMESPACE2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", WORDPROCESSINGML_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml", MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006", XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace", XML_TAG_RE, BOOKMARK_OPENING_RE, BOOKMARK_TAG_RE;
 var init_run_signature = __esm(() => {
   REVISION_ATTR_RE = /\s+(?:w:rsid\w*|w14:paraId|w14:textId)="[^"]*"/g;
   REVISION_ELEMENT_RE = /<w:(?:ins|del|moveFrom|moveTo)\b[^>]*>/g;
@@ -134949,6 +134991,8 @@ var init_run_signature = __esm(() => {
   RUN_CONTROL_RE = /<((?:[\w.-]+:)?(tab|br|cr))\b([^>]*)\/>/g;
   ATTRIBUTE_RE = /([\w.:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
   XML_TAG_RE = /<(\/?)(([A-Za-z_][\w.-]*)(?::([A-Za-z_][\w.-]*))?)((?:(?:"[^"]*"|'[^']*'|[^>"'])*))>/g;
+  BOOKMARK_OPENING_RE = /<\/?w:bookmark(?:Start|End)\b/g;
+  BOOKMARK_TAG_RE = /<(\/?)w:bookmark(Start|End)\b((?:"[^"]*"|[^">])*)>/g;
 });
 
 // ../../../v2/document-compare/src/note-story-projection.ts
@@ -134960,7 +135004,7 @@ function projectCapturedNoteStoryEntries(value) {
   const ranges = collectWordParagraphRanges(value.notePartXml);
   if (!ranges)
     return null;
-  return ranges.flatMap((range, ordinal) => {
+  const entries = ranges.flatMap((range, ordinal) => {
     if (range.start < noteStart || range.end > noteEnd)
       return [];
     const paragraphXml = value.notePartXml.slice(range.start, range.end);
@@ -134974,12 +135018,13 @@ function projectCapturedNoteStoryEntries(value) {
       text: visibleParagraphText(paragraphXml, range.namespaceBindings),
       headingLevel: metadata2.headingLevel,
       styleId: metadata2.styleId,
-      runSignature: computeRunSignature(runXml),
       runXml,
       paragraphPropertiesXml,
       paragraphPropertiesSignature: computeParagraphPropertiesSignature(paragraphPropertiesXml)
     }];
   });
+  const runSignatures = computeRunSignatures(entries.map((entry) => entry.runXml ?? ""));
+  return entries.map((entry, index) => ({ ...entry, runSignature: runSignatures[index] }));
 }
 function collectWordParagraphRanges(xml) {
   let valid = true;
@@ -188376,6 +188421,8 @@ function renderPasteParagraphBlock(spec) {
   return `<w:p${nsDecl} w14:paraId="${escapeXmlAttribute(spec.paraId)}">${pPr}${renderPasteRuns(spec.runs)}</w:p>`;
 }
 function renderReviewAwarePasteRun(run, stamp) {
+  if (run.kind === "sdt")
+    return renderPasteSdt(run, stamp);
   let xml = renderPasteRun(run);
   if (!("text" in run))
     return xml;
@@ -188516,6 +188563,11 @@ function renderTrackedPasteRuns(runs, stamp) {
       out.push(wrapTrackedInsertion(inner, stamp));
   };
   for (const run of runs) {
+    if (run.kind === "sdt") {
+      flushOrdinary();
+      out.push(wrapTrackedInsertion(renderPasteSdt(run), stamp));
+      continue;
+    }
     if (run.kind !== "hyperlink") {
       if (run.kind === "footnoteRef" || run.kind === "endnoteRef") {
         flushOrdinary();
@@ -188581,6 +188633,8 @@ function renderPasteTableCell(cell, renderParagraph = renderPasteParagraphBlock)
   return `<w:tc>${tcPr}${cell.paragraphs.map(renderParagraph).join("")}</w:tc>`;
 }
 function renderPasteRun(run, options = {}) {
+  if (run.kind === "sdt")
+    return renderPasteSdt(run);
   if (run.kind === "image")
     return run.xml;
   if (run.kind === "hyperlink")
@@ -188611,6 +188665,32 @@ function renderPasteRun(run, options = {}) {
   }
   return out.join("");
 }
+function renderPasteSdt(run, stamp) {
+  const properties = (run.alias !== undefined ? `<w:alias w:val="${escapeXmlAttribute(run.alias)}"/>` : "") + (run.tag !== undefined ? `<w:tag w:val="${escapeXmlAttribute(run.tag)}"/>` : "") + `<w:id w:val="${escapeXmlAttribute(run.id)}"/>` + (run.lockMode !== undefined ? `<w:lock w:val="${run.lockMode}"/>` : "") + (run.controlType === "text" && run.multiline !== undefined ? `<w:text w:multiLine="${run.multiline ? "1" : "0"}"/>` : `<w:${run.controlType}/>`);
+  return `<w:sdt><w:sdtPr>${properties}</w:sdtPr><w:sdtContent>${renderPasteRuns(run.runs, stamp)}</w:sdtContent></w:sdt>`;
+}
+function renderBlockSdtSequence(blocks, xml, ids) {
+  let result = "";
+  let previous = [];
+  for (let index = 0;index <= blocks.length; index += 1) {
+    const block = blocks[index];
+    const current = block && "blockSdts" in block ? block.blockSdts ?? [] : [];
+    let shared = 0;
+    while (shared < previous.length && shared < current.length && previous[shared].sourceId === current[shared].sourceId)
+      shared += 1;
+    for (let depth = previous.length - 1;depth >= shared; depth -= 1)
+      result += "</w:sdtContent></w:sdt>";
+    for (let depth = shared;depth < current.length; depth += 1) {
+      const wrapper = current[depth];
+      const id = ids.get(wrapper.sourceId);
+      result += "<w:sdt><w:sdtPr>" + (wrapper.alias !== undefined ? `<w:alias w:val="${escapeXmlAttribute(wrapper.alias)}"/>` : "") + (wrapper.tag !== undefined ? `<w:tag w:val="${escapeXmlAttribute(wrapper.tag)}"/>` : "") + `<w:id w:val="${escapeXmlAttribute(id)}"/>` + (wrapper.lockMode !== undefined ? `<w:lock w:val="${wrapper.lockMode}"/>` : "") + (wrapper.controlType === "text" && wrapper.multiline !== undefined ? `<w:text w:multiLine="${wrapper.multiline ? "1" : "0"}"/>` : `<w:${wrapper.controlType}/>`) + "</w:sdtPr><w:sdtContent>";
+    }
+    if (index < blocks.length)
+      result += xml[index];
+    previous = current;
+  }
+  return result;
+}
 function renderPasteHyperlink(run) {
   const targetAttribute = run.target.kind === "external" ? `r:id="${escapeXmlAttribute(run.target.relationshipId ?? "")}"` : `w:anchor="${escapeXmlAttribute(run.target.anchor)}"`;
   const tooltipAttribute = run.tooltip ? ` w:tooltip="${escapeXmlAttribute(run.tooltip)}"` : "";
@@ -189891,6 +189971,18 @@ function compileParsedOverlapEdit(input, tokens, descendedEditableContainers) {
     });
     token._classification = input.existingRevisionOwnership === "foreign" ? "different-user" : classifyOwnership(current, wrapperAuthor);
   }
+  const commented = wrappers.filter((entry) => entry.token.kind === "ins" && entry.token.commentedBoundary != null);
+  if (commented.length > 0) {
+    const parent = commented[0].token;
+    const following = touched.filter((entry) => entry.token.kind === "plain");
+    if (commented.length !== 1 || wrappers.length !== 1 || following.length !== 1 || following[0].token.byteStart < parent.byteEnd || parent._classification === "same-user" || input.changeMode !== "tracked" || input.newText.length === 0 || input.rangeStart <= parent.visibleStart || input.rangeStart >= parent.visibleEnd || input.rangeEnd <= parent.visibleEnd || input.rangeEnd > following[0].token.visibleEnd) {
+      return {
+        ok: false,
+        reason: "text-range-in-unsupported-tracked-wrapper",
+        detail: "overlap compiler: comment-bearing insertion requires a bounded foreign spanning replacement."
+      };
+    }
+  }
   if (input.newText.length > 0 && input.rangeStart < input.rangeEnd) {
     const spanningReplacement = tryRangeReplacementAcrossTokens(input, tokens, touched);
     if (spanningReplacement)
@@ -190531,8 +190623,21 @@ 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 }
+      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
+      } : {}
     });
+    if (token.commentedBoundary) {
+      if (!childIns || tail.length > 0)
+        return null;
+      pieces.push(token.commentedBoundary.startXml + token.openTag + nestedHead + childDel + token.closeTag + childIns);
+      replacementInserted = true;
+      if (!emittedRsids.includes(input.insRsid))
+        emittedRsids.push(input.insRsid);
+      emitDeletionRsid();
+      continue;
+    }
     if (childIns) {
       const headIns = head.length > 0 ? buildInsWrapperXml({
         openTag: token.openTag,
@@ -191893,6 +191998,55 @@ function isSupportedStructuralDeletionChild(piece) {
   }
   return piece.containerKind === "unknown" && (piece.localName === "smartTag" || piece.localName === "dir" || piece.localName === "bdo");
 }
+function readCommentedInsertionBoundary(piece) {
+  const markers = piece.children.filter((child) => child.kind === "marker");
+  if (markers.length !== 3 || piece.children.length !== 4)
+    return null;
+  const [start, end, reference] = markers;
+  if (start.markerKind !== "commentRangeStart" || end.markerKind !== "commentRangeEnd" || reference.markerKind !== "commentReference" || !start.id || start.id !== end.id || start.id !== reference.id || start.runCharStart != null || end.runCharStart != null)
+    return null;
+  const text = piece.children.find((child) => child.kind === "text");
+  if (!text || !text.decodedText)
+    return null;
+  const source = piece.rawXml;
+  const base2 = piece.charStart;
+  const openEnd = findXmlTagEnd(source, 1);
+  const closeStart = source.lastIndexOf(`</${piece.qname}>`);
+  const outsideBindings = Object.fromEntries(piece.namespaceBindings);
+  for (const attribute of scanRawXmlAttributes(source.slice(0, openEnd))) {
+    if (attribute.name === "xmlns" || attribute.prefix === "xmlns") {
+      delete outsideBindings[attribute.name === "xmlns" ? "" : attribute.localName];
+    }
+  }
+  const startXml = closeNamespaceScope(start.rawXml, Object.fromEntries(start.namespaceBindings), outsideBindings, { referencedOnly: true });
+  if (startXml == null)
+    return null;
+  const textRunStart = text.runCharStart - base2;
+  const textRunEnd = text.runCharEnd - base2;
+  const startStart = start.charStart - base2;
+  const startEnd = start.charEnd - base2;
+  const endStart = end.charStart - base2;
+  const endEnd = end.charEnd - base2;
+  if (openEnd < 0 || closeStart < 0 || startStart < openEnd || startEnd > textRunStart || textRunEnd > endStart || endEnd > reference.charStart - base2 || [
+    source.slice(openEnd, startStart),
+    source.slice(startEnd, textRunStart),
+    source.slice(textRunEnd, endStart)
+  ].some((gap) => gap.trim().length > 0))
+    return null;
+  const textRun = source.slice(textRunStart, textRunEnd);
+  if (textRun.replace(text.runOpenTag, "").replace(text.runProperties ?? "", "").replace(text.rawXml, "").replace(text.runCloseTag, "").trim().length > 0)
+    return null;
+  const referenceRunXml = source.slice(endEnd, closeStart).trim();
+  const referenceOpenEnd = findXmlTagEnd(referenceRunXml, 1);
+  const referenceCloseStart = referenceRunXml.lastIndexOf("</");
+  if (referenceOpenEnd < 0 || referenceCloseStart < referenceOpenEnd || !/^<([\w.-]+:)?r(?=[\s>])/.test(referenceRunXml) || !/<\/[\w.-]+:r>$/.test(referenceRunXml) || referenceRunXml.slice(referenceOpenEnd, referenceCloseStart).trim() !== reference.rawXml)
+    return null;
+  return {
+    startXml,
+    endXml: end.rawXml,
+    referenceRunXml
+  };
+}
 function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStructuralDeletionPassThrough) {
   const visibleStart = spanStart(piece);
   const visibleEnd = spanEnd(piece);
@@ -191932,6 +192086,7 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
       rawXml: child.rawXml
     })).sort((a, b) => a.localOffset - b.localOffset);
   }
+  const commentedBoundary = piece.trackedKind === "ins" && !nestedDeletions ? readCommentedInsertionBoundary(piece) : null;
   if (allowComplexDeletions && piece.trackedKind === "del") {
     const unsupportedChild = piece.children.find((child) => child.kind !== "text" && !(child.kind === "marker" && isCommentMarker2(child.markerKind)) && !(allowStructuralDeletionPassThrough && isSupportedStructuralDeletionChild(child)));
     if (unsupportedChild) {
@@ -191994,7 +192149,7 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
       }
     };
   }
-  const foreignChild = piece.children.find((child) => child.kind === "container" || child.kind === "unknown" || child.kind === "noteReference" || child.kind === "control" && !(piece.trackedKind === "ins" && child.control === "tab") || child.kind === "marker");
+  const foreignChild = piece.children.find((child) => child.kind === "container" || child.kind === "unknown" || child.kind === "noteReference" || child.kind === "control" && !(piece.trackedKind === "ins" && child.control === "tab") || child.kind === "marker" && !commentedBoundary);
   if (foreignChild) {
     if (foreignChild.kind === "container") {
       return unsupported2(containerRejectionReason(foreignChild.containerKind), `overlap compiler: ${foreignChild.containerKind} inside w:${piece.trackedKind}`);
@@ -192059,7 +192214,13 @@ function trackedToken(piece, spanStart, spanEnd, allowComplexDeletions, allowStr
     },
     ...innerRuns.length > 1 ? { innerRuns } : {}
   };
-  return piece.trackedKind === "ins" ? { kind: "ins", ...base2, rsidR, ...nestedDeletions ? { nestedDeletions } : {} } : { kind: "del", ...base2, rsidDel };
+  return piece.trackedKind === "ins" ? {
+    kind: "ins",
+    ...base2,
+    rsidR,
+    ...nestedDeletions ? { nestedDeletions } : {},
+    ...commentedBoundary ? { commentedBoundary } : {}
+  } : { kind: "del", ...base2, rsidDel };
 }
 function isCommentMarker2(markerKind) {
   return markerKind === "commentRangeStart" || markerKind === "commentRangeEnd" || markerKind === "commentReference";
@@ -192110,6 +192271,7 @@ var init_overlap_edit_compiler = __esm(() => {
   init_word_text_payload();
   init_xml_text();
   init_xml_sax();
+  init_xml_namespace_scope();
   init_word_text_names();
   init_paragraph_inline_model();
   init_comment_cascade();
@@ -206730,6 +206892,8 @@ function collectRetiredTrackedChangeCommentMetadataIds(op, logicalCatalog) {
   return ids;
 }
 function applyRetiredTrackedChangeCommentMetadataCleanup(args) {
+  if (args.perPart[COMMENTS_PART_URI]?.kind === "remove")
+    return [];
   const commentsBytes = args.state.packageBytes.get(COMMENTS_PART_URI);
   if (!commentsBytes || args.retiredSourceIds.size === 0)
     return [];
@@ -206831,16 +206995,45 @@ function applyCommentCascade(args) {
     const next = removeCommentCatalogEntries(TD46.decode(commentsBytes), wids);
     if (!next.ok)
       return { ok: false, reason: next.reason };
-    const patch = {
-      kind: "replaceBytes",
-      order: 0,
-      startByte: 0,
-      endByte: commentsBytes.length,
-      bytes: TE23.encode(next.xml)
-    };
-    args.perPart[COMMENTS_PART_URI] = { kind: "modify", patches: [patch] };
-    args.preconditions.push(byteWindowPrecondition4(COMMENTS_PART_URI, commentsBytes));
-    args.patchMaps[COMMENTS_PART_URI] = { partUri: COMMENTS_PART_URI, ranges: [] };
+    const parsedComments = collectXmlElementRanges(next.xml);
+    const commentsRoot = parsedComments.ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "comments");
+    const emptyComments = parsedComments.errors.length === 0 && commentsRoot && next.xml.slice(commentsRoot.openEnd, commentsRoot.closeStart).trim().length === 0;
+    const hasCommentSidecars = args.state.packageBytes.has(COMMENTS_EXTENDED_PART_URI) || args.state.packageBytes.has(COMMENTS_IDS_PART_URI);
+    if (emptyComments && !hasCommentSidecars) {
+      args.perPart[COMMENTS_PART_URI] = { kind: "remove" };
+      args.preconditions.push(byteWindowPrecondition4(COMMENTS_PART_URI, commentsBytes));
+      args.patchMaps[COMMENTS_PART_URI] = { partUri: COMMENTS_PART_URI, ranges: [] };
+      const relsBytes = args.state.packageBytes.get(DOCUMENT_RELS_PART_URI3);
+      if (relsBytes) {
+        const relsXml = currentPartXml(args.state, args.perPart, DOCUMENT_RELS_PART_URI3, XML_TD) ?? XML_TD.decode(relsBytes);
+        const removed = removeRelationshipForPartAndTypeXml({
+          relsXml,
+          ownerPartUri: DOCUMENT_PART_URI,
+          partUri: COMMENTS_PART_URI,
+          relationshipType: COMMENTS_RELATIONSHIP_TYPE
+        });
+        if (!removed.ok)
+          return { ok: false, reason: "unsupported-context" };
+        if (removed.value.xml !== relsXml) {
+          setWholePartReplacement(args, DOCUMENT_RELS_PART_URI3, relsBytes, removed.value.xml);
+        }
+      }
+      const contentTypesBytes = args.state.packageBytes.get(CONTENT_TYPES_PART_URI4);
+      if (contentTypesBytes) {
+        const contentTypesXml = currentPartXml(args.state, args.perPart, CONTENT_TYPES_PART_URI4, XML_TD) ?? XML_TD.decode(contentTypesBytes);
+        const removed = removeContentTypeOverrideXml({
+          contentTypesXml,
+          partName: COMMENTS_PART_URI
+        });
+        if (!removed.ok)
+          return { ok: false, reason: "unsupported-context" };
+        if (removed.value.xml !== contentTypesXml) {
+          setWholePartReplacement(args, CONTENT_TYPES_PART_URI4, contentTypesBytes, removed.value.xml);
+        }
+      }
+    } else {
+      setWholePartReplacement(args, COMMENTS_PART_URI, commentsBytes, next.xml);
+    }
   }
   const extendedBytes = args.state.packageBytes.get(COMMENTS_EXTENDED_PART_URI);
   if (extendedBytes && removedParaIds.size > 0) {
@@ -209038,7 +209231,7 @@ function dedupeRemappedRefs(refs) {
 function refKey(ref3) {
   return `${ref3.kind}|${ref3.entityId ?? ref3.commentId ?? ""}|${ref3.storyId ?? ""}`;
 }
-var TD46, XML_TD, TE23, DOCUMENT_PART_URI = "/word/document.xml", DOCUMENT_RELS_PART_URI3 = "/word/_rels/document.xml.rels", NUMBERING_PART_URI2 = "/word/numbering.xml", CONTENT_TYPES_PART_URI4 = "/[Content_Types].xml", NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", NOTE_LIFECYCLE_PROVENANCE_NS = "urn:superdoc:note-lifecycle", NOTE_FAMILY_PROFILE, INDEXABLE_STRUCTURAL_KINDS, TRACKED_TABLE_COLUMN_RESTORE_NS = "urn:superdoc:tracked-table-column";
+var TD46, XML_TD, TE23, DOCUMENT_PART_URI = "/word/document.xml", DOCUMENT_RELS_PART_URI3 = "/word/_rels/document.xml.rels", NUMBERING_PART_URI2 = "/word/numbering.xml", CONTENT_TYPES_PART_URI4 = "/[Content_Types].xml", NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", COMMENTS_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", NOTE_LIFECYCLE_PROVENANCE_NS = "urn:superdoc:note-lifecycle", NOTE_FAMILY_PROFILE, INDEXABLE_STRUCTURAL_KINDS, TRACKED_TABLE_COLUMN_RESTORE_NS = "urn:superdoc:tracked-table-column";
 var init_compile_tracked_change_decide = __esm(() => {
   init_empty_paragraph_move();
   init_native_sdt_ownership();
@@ -220127,6 +220320,18 @@ function collectProtectedReferenceTokens(xml, referenceSteps) {
   const tokens = [];
   for (let index = 0;index < referenceSteps.length; index += 1) {
     const step2 = referenceSteps[index];
+    if (step2.kind === "bookmark-range" || step2.kind === "complex-field") {
+      const fragment2 = step2.beforeFragmentXml;
+      if (!fragment2)
+        return null;
+      const start = xml.indexOf(fragment2);
+      if (start >= 0) {
+        if (xml.indexOf(fragment2, start + fragment2.length) >= 0)
+          return null;
+        tokens.push({ key: `reference:${index}`, start, end: start + fragment2.length, xml: fragment2 });
+      }
+      continue;
+    }
     const expectedLocalName = step2.kind === "bookmark-start" ? "bookmarkStart" : "fldSimple";
     const parsed = collectXmlElementRanges(xml, {
       fragment: true,
@@ -221281,7 +221486,7 @@ function validateLocalizedMainDocumentReplay(state, sectionSteps, referenceSteps
 function uniqueLocalizedReplayStart(xml, step2, documentRanges, allowRootNamespaceDeclarations = false) {
   const ranges = documentRanges ?? collectXmlElementRanges(xml).ranges;
   if (allowRootNamespaceDeclarations && isReferenceReplayStep(step2)) {
-    const expectedLocalName = step2.kind === "bookmark-start" ? "bookmarkStart" : "fldSimple";
+    const expectedLocalName = referenceReplayElementName(step2);
     const starts2 = ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === expectedLocalName && replayCarrierXmlEquals(xml.slice(range.start, range.end), step2.beforeXml)).map((range) => range.start);
     return starts2.length === 1 ? starts2[0] : null;
   }
@@ -221302,7 +221507,7 @@ function isInsideWordElement(ranges, position, localName2) {
   return ranges.some((range) => range.tag.namespaceUri === NS_W && range.tag.localName === localName2 && range.start < position && range.end > position);
 }
 function localizedReplayContext(xml, step2, start, documentRanges, allowRootNamespaceDeclarations = false) {
-  const expectedLocalName = isReferenceReplayStep(step2) ? step2.kind === "bookmark-start" ? "bookmarkStart" : "fldSimple" : "sectPr";
+  const expectedLocalName = isReferenceReplayStep(step2) ? referenceReplayElementName(step2) : "sectPr";
   const ranges = documentRanges ?? collectXmlElementRanges(xml).ranges;
   const before = ranges.find((range) => range.start === start && range.tag.namespaceUri === NS_W && range.tag.localName === expectedLocalName && (range.end === start + step2.beforeXml.length || allowRootNamespaceDeclarations && isReferenceReplayStep(step2) && replayCarrierXmlEquals(xml.slice(range.start, range.end), step2.beforeXml)));
   if (!before)
@@ -221336,8 +221541,55 @@ function isSafeReferenceReplayStep(step2, context) {
     const afterName = readResolvedReplayAttribute(context.after, "name");
     return afterName !== null && readResolvedReplayAttribute(context.before, "id") === readResolvedReplayAttribute(context.after, "id") && replaceReplayAttribute(step2.beforeXml, context.before, "name", afterName) === step2.afterXml;
   }
-  const instruction = readResolvedReplayAttribute(context.after, "instr");
-  return instruction !== null && /^\s*REF\s+[A-Za-z_][A-Za-z0-9_.]*(?:\s|$)/i.test(instruction) && replaceReplayAttribute(step2.beforeXml, context.before, "instr", instruction) === step2.afterXml;
+  if (step2.kind === "simple-field") {
+    const instruction = readResolvedReplayAttribute(context.after, "instr");
+    return instruction !== null && /^\s*REF\s+[A-Za-z_][A-Za-z0-9_.]*(?:\s|$)/i.test(instruction) && replaceReplayAttribute(step2.beforeXml, context.before, "instr", instruction) === step2.afterXml;
+  }
+  const beforeFragment = step2.beforeFragmentXml;
+  const afterFragment = step2.afterFragmentXml;
+  if (!beforeFragment || !afterFragment || replaceUniqueReplayFragment(step2.beforeXml, beforeFragment, afterFragment) !== step2.afterXml)
+    return false;
+  if (step2.kind === "bookmark-range") {
+    return isBalancedAddedBookmarkFragment(afterFragment, beforeFragment, context.parentNamespaceBindings);
+  }
+  return isCompleteAddedRefFieldFragment(afterFragment, beforeFragment, context.parentNamespaceBindings);
+}
+function referenceReplayElementName(step2) {
+  return step2.kind === "bookmark-start" ? "bookmarkStart" : step2.kind === "simple-field" ? "fldSimple" : "p";
+}
+function replaceUniqueReplayFragment(xml, before, after) {
+  const start = xml.indexOf(before);
+  if (start < 0 || xml.indexOf(before, start + before.length) >= 0)
+    return null;
+  return xml.slice(0, start) + after + xml.slice(start + before.length);
+}
+function isBalancedAddedBookmarkFragment(xml, expectedContent, namespaceBindings) {
+  const parsed = collectXmlElementRanges(xml, { fragment: true, additionalNamespaces: { ...namespaceBindings } });
+  if (parsed.errors.length > 0)
+    return false;
+  const starts = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "bookmarkStart");
+  const ends = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "bookmarkEnd");
+  if (starts.length !== 1 || ends.length !== 1 || !starts[0].tag.isSelfClosing || !ends[0].tag.isSelfClosing)
+    return false;
+  const id = readResolvedReplayAttribute(starts[0], "id");
+  return id !== null && readResolvedReplayAttribute(starts[0], "name") !== null && readResolvedReplayAttribute(ends[0], "id") === id && xml.slice(starts[0].end, ends[0].start) === expectedContent;
+}
+function isCompleteAddedRefFieldFragment(xml, expectedResult, namespaceBindings) {
+  const parsed = collectXmlElementRanges(xml, { fragment: true, additionalNamespaces: { ...namespaceBindings } });
+  if (parsed.errors.length > 0)
+    return false;
+  const chars = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "fldChar");
+  const types4 = chars.map((range) => readResolvedReplayAttribute(range, "fldCharType"));
+  if (types4.length !== 3 || types4.join(",") !== "begin,separate,end")
+    return false;
+  const instruction = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "instrText" && range.start > chars[0].end && range.end < chars[1].start).map((range) => xml.slice(range.start, range.end).replace(/^<[^>]+>|<\/[^>]+>$/g, "")).join("");
+  return /^\s*REF\s+[A-Za-z_][A-Za-z0-9_.]*(?:\s|$)/i.test(instruction) && xml.slice(parentRunEnd(parsed.ranges, chars[1]), parentRunStart(parsed.ranges, chars[2])) === expectedResult;
+}
+function parentRunStart(ranges, child) {
+  return ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "r" && range.start <= child.start && range.end >= child.end)?.start ?? -1;
+}
+function parentRunEnd(ranges, child) {
+  return ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "r" && range.start <= child.start && range.end >= child.end)?.end ?? -1;
 }
 function isReferenceReplayStep(step2) {
   return "kind" in step2;
@@ -221455,6 +221707,13 @@ function renderTrackedSectionReplay(step2, stamp, context) {
   return step2.afterXml.slice(0, close) + marker + step2.afterXml.slice(close);
 }
 function renderTrackedReferenceReplay(step2, stamps, context) {
+  if (step2.kind === "bookmark-range" || step2.kind === "complex-field") {
+    const beforeFragment = step2.beforeFragmentXml;
+    const afterFragment = step2.afterFragmentXml;
+    const deletionXml2 = renameWordTextElementsToDeletedText(beforeFragment, context.parentNamespaceBindings);
+    const tracked = renderTrackedWrapper("del", deletionXml2, stamps.del, context) + renderTrackedWrapper("ins", afterFragment, stamps.ins, context);
+    return replaceUniqueReplayFragment(step2.beforeXml, beforeFragment, tracked) ?? step2.beforeXml;
+  }
   const deletionXml = step2.kind === "simple-field" ? renameWordTextElementsToDeletedText(step2.beforeXml, context.parentNamespaceBindings) : step2.beforeXml;
   return renderTrackedWrapper("del", deletionXml, stamps.del, context) + renderTrackedWrapper("ins", step2.afterXml, stamps.ins, context);
 }
@@ -221544,7 +221803,7 @@ function validateTableTopologySteps(state, changeMode, steps) {
       if (deletedRows.has(key2) || step2.rowsXml.length !== 1 || table.rows.length <= 1)
         return false;
       const rowXml = TD58.decode(partBytes.subarray(anchor.row.rowByteStart, anchor.row.rowByteEnd));
-      if (step2.rowsXml[0] !== rowXml || !isSafeExactTableRowPayload(rowXml, namespaceBindings))
+      if (step2.rowsXml[0] !== rowXml || !isNamespaceSafeWordprocessingRow(rowXml, namespaceBindings))
         return false;
       const parsed = collectXmlElementRanges(rowXml, { fragment: true, additionalNamespaces: { ...namespaceBindings } });
       if (parsed.errors.length || parsed.ranges.some((range) => range.tag.namespaceUri === NS_W && [
@@ -221555,7 +221814,6 @@ function validateTableTopologySteps(state, changeMode, steps) {
         "commentReference",
         "footnoteReference",
         "endnoteReference",
-        "sdt",
         "fldSimple",
         "fldChar"
       ].includes(range.tag.localName)))
@@ -228918,7 +229176,7 @@ function planParagraphSplice(input) {
     };
     return input.trackedStamp ? renderTrackedPasteParagraphBlock(spec, input.trackedStamp) : renderPasteParagraphBlock(spec);
   };
-  const mergeable = (block) => block.kind === "paragraph" && !block.styleRef && !block.numbering && !block.listIntent && !block.paragraphProps && !block.pPrXml && !block.complete;
+  const mergeable = (block) => block.kind === "paragraph" && !block.styleRef && !block.numbering && !block.listIntent && !block.paragraphProps && !block.pPrXml && !block.blockSdts?.length && !block.complete;
   const paragraphs = [];
   if (blocks.length === 1 && mergeable(blocks[0])) {
     if (anchorParaId)
@@ -228937,10 +229195,13 @@ function planParagraphSplice(input) {
       paragraphs.push(headOpen + headPPr + split.headXml + (mergeFirst ? runsOf(blocks[0]) : "") + envelope.close);
     }
     const middleStart = mergeFirst ? 1 : 0;
+    const middleXml = [];
     for (let middleIndex = 0;middleIndex < middleBlocks.length; middleIndex += 1) {
       const block = middleBlocks[middleIndex];
-      paragraphs.push(standalone(block, middleStart + middleIndex, mergeable(block) ? envelope.pPr : undefined));
+      middleXml.push(standalone(block, middleStart + middleIndex, mergeable(block) ? envelope.pPr : undefined));
     }
+    if (middleXml.length)
+      paragraphs.push(renderBlockSdtSequence(middleBlocks, middleXml, input.blockSdtIds ?? new Map));
     const tailRunsXml = (mergeLast ? runsOf(blocks[blocks.length - 1]) : "") + split.tailXml;
     if (mergeLast || split.tailXml.length > 0) {
       const tailOpen = relocateEmptyAnchor ? envelope.open : withParaId(envelope.open, mintId(), input.partBytes, input.paragraphStartByte);
@@ -231243,6 +231504,10 @@ function preflightFragmentApply(input) {
   const target = resolveFragmentApplyTarget(state, op);
   if (!target.ok)
     return target;
+  if (isTextTarget2(op.target) && op.formattingMode === "match-destination" && op.fragment.blocks.some((block) => (block.kind === "paragraph" || block.kind === "heading") && block.blockSdts?.length))
+    return { ok: false, reason: "paste-structure-unsupported" };
+  if ((op.changeMode ?? "direct") === "tracked" && op.fragment.blocks.some((block) => (block.kind === "paragraph" || block.kind === "heading") && block.blockSdts?.length))
+    return { ok: false, reason: "paste-tracked-structural-unsupported" };
   if ((op.changeMode ?? "direct") === "tracked" && target.target.kind === "block" && target.target.blockKind === "table" && !trackedWholeTableRowsAreDirectChildren(state, target.target)) {
     return { ok: false, reason: "paste-tracked-structural-unsupported" };
   }
@@ -231507,6 +231772,8 @@ function validateFragmentRangeIntegrity(input) {
 }
 function fragmentRequiresCommit5Materialization(blocks) {
   for (const block of blocks) {
+    if ((block.kind === "paragraph" || block.kind === "heading") && block.blockSdts?.length)
+      return true;
     if (block.kind === "heading" || block.kind === "horizontalRule")
       return true;
     if (block.kind === "table") {
@@ -231526,7 +231793,7 @@ function fragmentRequiresCommit5Materialization(blocks) {
   return false;
 }
 function paragraphHasFutureInline(block) {
-  return block.paragraphProps !== undefined || block.listIntent?.start !== undefined || (block.inlines?.some((inline) => inline.kind === "lineBreak" || inline.kind === "hyperlink" || inline.kind === "footnoteRef" || inline.kind === "endnoteRef") ?? false);
+  return block.paragraphProps !== undefined || block.listIntent?.start !== undefined || (block.inlines?.some((inline) => inline.kind === "lineBreak" || inline.kind === "hyperlink" || inline.kind === "sdt" || inline.kind === "footnoteRef" || inline.kind === "endnoteRef") ?? false);
 }
 function collectFragmentSourcePaths(blocks) {
   const paths = [];
@@ -232037,6 +232304,7 @@ function runWholeStoryReplaceCommit(input, target, blocks, extras, inlineExtras)
     state,
     blocks,
     inlineSpecs: inlineExtras.inlineSpecs,
+    blockSdtIds: inlineExtras.blockSdtIds,
     partBytes: bytes,
     insertionByte: target.byteStart,
     ordinalSeed: 0,
@@ -232275,7 +232543,7 @@ function renderCompletePasteFragment(input) {
     renderedBlocks.push(xml);
   }
   return {
-    xml: renderedBlocks.join(""),
+    xml: renderBlockSdtSequence(input.blocks, renderedBlocks, input.blockSdtIds),
     createdParaIds,
     destinationParaIdsByBlock
   };
@@ -232307,6 +232575,7 @@ function runParagraphBlockPasteCommit(input, target, blocks, extras, inlineExtra
     state,
     blocks,
     inlineSpecs: inlineExtras.inlineSpecs,
+    blockSdtIds: inlineExtras.blockSdtIds,
     partBytes: bytes,
     insertionByte: target.placement === "after" ? anchor.byteEnd : anchor.byteStart,
     ordinalSeed: anchor.ordinal,
@@ -232475,6 +232744,7 @@ function runWholeTableReplaceCommit(input, target, blocks, extras, inlineExtras)
     state,
     blocks,
     inlineSpecs: inlineExtras.inlineSpecs,
+    blockSdtIds: inlineExtras.blockSdtIds,
     partBytes: bytes,
     insertionByte: target.byteStart,
     ordinalSeed: replacedParagraphs[0]?.ordinal ?? 0,
@@ -232644,6 +232914,7 @@ function runCrossParagraphTrackedPasteCommit(input, target, blocks, extras, inli
         paragraphStartByte: start.byteStart,
         mintParaId: () => mintParaId(state, state.packageRevision, start.ordinal + 1 + (mintSalt += 1)),
         inlineSpecs: inlineExtras.inlineSpecs,
+        blockSdtIds: inlineExtras.blockSdtIds,
         trackedStamp: stamp,
         wrapAllTracked: true,
         ...extras.commentIdMap ? { commentIdMap: extras.commentIdMap } : {},
@@ -232772,6 +233043,7 @@ function runCrossParagraphPasteCommit(input, target, blocks, extras, inlineExtra
         paragraphStartByte: start.byteStart,
         mintParaId: () => mintParaId(state, state.packageRevision, start.ordinal + 1 + (mintSalt += 1)),
         inlineSpecs: inlineExtras.inlineSpecs,
+        blockSdtIds: inlineExtras.blockSdtIds,
         ...extras.commentIdMap ? { commentIdMap: extras.commentIdMap } : {},
         ...extras.noteIdMap ? { noteIdMap: extras.noteIdMap } : {}
       });
@@ -233418,6 +233690,7 @@ function runPasteSpliceCommit(input, target, resolvedBlocks, listExtras, imageEx
       paragraphStartByte,
       mintParaId: mintParaId3,
       inlineSpecs: imageExtras.inlineSpecs,
+      blockSdtIds: imageExtras.blockSdtIds,
       ...stamp ? { trackedStamp: stamp, wrapAllTracked } : {},
       ...listExtras.commentIdMap ? { commentIdMap: listExtras.commentIdMap } : {},
       ...listExtras.noteIdMap ? { noteIdMap: listExtras.noteIdMap } : {}
@@ -233654,6 +233927,8 @@ function validateImageFragment(fragment2) {
         continue;
       if (inline.kind === "footnoteRef" || inline.kind === "endnoteRef")
         continue;
+      if (inline.kind === "sdt")
+        continue;
       if (inline.kind === "hyperlink") {
         if (inline.inlines.some((child) => child.kind === "image")) {
           return { ok: false, reason: "paste-structure-unsupported" };
@@ -233674,7 +233949,7 @@ function validateImageFragment(fragment2) {
 function prepareImageExtras(state, storyId, partUri, fragment2, blocks, changeMode, relationshipHyperlinks, hyperlinkCharacterStyleId, preparedPackageXml) {
   const inlineParagraphs = [];
   for (const block of blocks) {
-    if (block.kind === "paragraph" && block.inlines)
+    if (block.kind === "paragraph" && (block.inlines || block.blockSdts?.length))
       inlineParagraphs.push(block);
     if (block.kind === "table") {
       for (const row of block.rows) {
@@ -233687,7 +233962,7 @@ function prepareImageExtras(state, storyId, partUri, fragment2, blocks, changeMo
     }
   }
   if (inlineParagraphs.length === 0) {
-    return { ok: true, value: { inlineSpecs: new Map, partUris: [], perPart: {}, preconditions: [], patchMaps: {} } };
+    return { ok: true, value: { inlineSpecs: new Map, blockSdtIds: new Map, partUris: [], perPart: {}, preconditions: [], patchMaps: {} } };
   }
   const assets = new Map((fragment2.assets ?? []).map((asset) => [asset.id, asset]));
   const hasImages = inlineParagraphs.some((paragraph) => paragraph.inlines?.some((inline) => inline.kind === "image"));
@@ -233782,6 +234057,43 @@ function prepareImageExtras(state, storyId, partUri, fragment2, blocks, changeMo
   }
   let docPrId = allocateDocPrId(state, storyId);
   const inlineSpecs = new Map;
+  const hasControls = inlineParagraphs.some((paragraph) => paragraph.blockSdts?.length || paragraph.inlines?.some((inline) => inline.kind === "sdt"));
+  const usedControlIds = new Set;
+  if (hasControls) {
+    for (const [uri, bytes] of state.packageBytes) {
+      if (!uri.endsWith(".xml"))
+        continue;
+      const xml = TD64.decode(bytes);
+      for (const match of xml.matchAll(/<w:sdtPr\b[^>]*>[\s\S]*?<w:id\b[^>]*\bw:val=(['"])(\d+)\1/g)) {
+        const id = Number(match[2]);
+        if (Number.isSafeInteger(id) && id > 0)
+          usedControlIds.add(id);
+      }
+    }
+  }
+  let nextControlId = 1002;
+  for (const id of usedControlIds)
+    if (id >= nextControlId)
+      nextControlId = id + 1;
+  const mintControlId = () => {
+    if (nextControlId > 2147483647)
+      nextControlId = 1;
+    while (usedControlIds.has(nextControlId)) {
+      nextControlId += 1;
+      if (nextControlId > 2147483647)
+        nextControlId = 1;
+    }
+    const id = nextControlId++;
+    usedControlIds.add(id);
+    return String(id);
+  };
+  const blockSdtIds = new Map;
+  for (const paragraph of inlineParagraphs) {
+    for (const wrapper of paragraph.blockSdts ?? []) {
+      if (!blockSdtIds.has(wrapper.sourceId))
+        blockSdtIds.set(wrapper.sourceId, mintControlId());
+    }
+  }
   const leafSpec = (inline) => {
     if (inline.kind === "text")
       return toPasteTextRunSpec(inline);
@@ -233802,37 +234114,68 @@ function prepareImageExtras(state, storyId, partUri, fragment2, blocks, changeMo
       })
     };
   };
+  const sdtSpec = (inline) => ({
+    kind: "sdt",
+    id: mintControlId(),
+    controlType: inline.controlType,
+    ...inline.tag !== undefined ? { tag: inline.tag } : {},
+    ...inline.alias !== undefined ? { alias: inline.alias } : {},
+    ...inline.lockMode !== undefined ? { lockMode: inline.lockMode } : {},
+    ...inline.multiline !== undefined ? { multiline: inline.multiline } : {},
+    runs: inline.inlines.map((child) => child.kind === "sdt" ? sdtSpec(child) : leafSpec(child))
+  });
+  const inlineSpec = (inline) => {
+    if (inline.kind === "sdt")
+      return sdtSpec(inline);
+    if (inline.kind === "footnoteRef" || inline.kind === "endnoteRef") {
+      return { kind: inline.kind, noteId: inline.noteId };
+    }
+    if (inline.kind !== "hyperlink")
+      return leafSpec(inline);
+    const target = inline.target.kind === "external" ? {
+      kind: "external",
+      url: inline.target.url,
+      ...relationshipHyperlinks ? { relationshipId: hyperlinkRelationshipIds.get(inline) } : {}
+    } : { kind: "anchor", anchor: inline.target.anchor };
+    return {
+      kind: "hyperlink",
+      target,
+      ...inline.tooltip ? { tooltip: inline.tooltip } : {},
+      ...hyperlinkCharacterStyleId ? { characterStyleId: hyperlinkCharacterStyleId } : {},
+      runs: inline.inlines.map(leafSpec)
+    };
+  };
   for (const paragraph of inlineParagraphs) {
-    inlineSpecs.set(paragraph, (paragraph.inlines ?? []).map((inline) => {
-      if (inline.kind === "footnoteRef" || inline.kind === "endnoteRef") {
-        return { kind: inline.kind, noteId: inline.noteId };
-      }
-      if (inline.kind !== "hyperlink")
-        return leafSpec(inline);
-      const target = inline.target.kind === "external" ? {
-        kind: "external",
-        url: inline.target.url,
-        ...relationshipHyperlinks ? { relationshipId: hyperlinkRelationshipIds.get(inline) } : {}
-      } : { kind: "anchor", anchor: inline.target.anchor };
-      return {
-        kind: "hyperlink",
-        target,
-        ...inline.tooltip ? { tooltip: inline.tooltip } : {},
-        ...hyperlinkCharacterStyleId ? { characterStyleId: hyperlinkCharacterStyleId } : {},
-        runs: inline.inlines.map(leafSpec)
-      };
-    }));
+    if (paragraph.inlines)
+      inlineSpecs.set(paragraph, paragraph.inlines.map(inlineSpec));
   }
   const preconditions = [];
   if (relsUri && relsBytes && (hasImages || hasExternalLinks))
     preconditions.push(byteWindowPrecondition7(relsUri, relsBytes));
   if (contentTypesChanged && contentTypesBytes)
     preconditions.push(byteWindowPrecondition7(CONTENT_TYPES_PART_URI11, contentTypesBytes));
-  return { ok: true, value: { inlineSpecs, partUris: packagePartUris, perPart, preconditions, patchMaps: {} } };
+  return { ok: true, value: { inlineSpecs, blockSdtIds, partUris: packagePartUris, perPart, preconditions, patchMaps: {} } };
 }
 function validateBlocks(blocks) {
   const budget = { totalChars: 0, hyperlinkRefs: 0, sourcePaths: new Set };
+  const closedControls = new Set;
+  let activeControls = [];
   for (const block of blocks) {
+    const controls = block.kind === "paragraph" || block.kind === "heading" ? block.blockSdts ?? [] : [];
+    if (controls.length && (block.kind !== "paragraph" && block.kind !== "heading" || !block.complete || controls.length > 16)) {
+      return { ok: false, reason: "paste-structure-unsupported" };
+    }
+    let common = 0;
+    while (common < controls.length && common < activeControls.length && controls[common].sourceId === activeControls[common].sourceId && controls[common].controlType === activeControls[common].controlType && controls[common].tag === activeControls[common].tag && controls[common].alias === activeControls[common].alias)
+      common += 1;
+    for (const wrapper of activeControls.slice(common))
+      closedControls.add(wrapper.sourceId);
+    for (const wrapper of controls.slice(common)) {
+      if (!/^[0-9]{1,10}$/.test(wrapper.sourceId) || closedControls.has(wrapper.sourceId) || controls.filter((candidate2) => candidate2.sourceId === wrapper.sourceId).length !== 1 || wrapper.controlType !== "text" && wrapper.controlType !== "richText" || !isValidOptionalXmlAttributeText(wrapper.tag, 255) || !isValidOptionalXmlAttributeText(wrapper.alias, 255)) {
+        return { ok: false, reason: "paste-structure-unsupported" };
+      }
+    }
+    activeControls = controls;
     if (!recordSourcePath(block.sourcePath, budget.sourcePaths)) {
       return { ok: false, reason: "paste-structure-unsupported" };
     }
@@ -233896,6 +234239,9 @@ function validateBlocks(blocks) {
             if (cellBlock.kind !== "paragraph") {
               return { ok: false, reason: "paste-structure-unsupported" };
             }
+            if (cellBlock.blockSdts?.length) {
+              return { ok: false, reason: "paste-structure-unsupported" };
+            }
             if (!recordSourcePath(cellBlock.sourcePath, budget.sourcePaths)) {
               return { ok: false, reason: "paste-structure-unsupported" };
             }
@@ -234029,9 +234375,14 @@ function validateParagraphBlock(block, budget) {
   }
   return { ok: true };
 }
-function validatePasteInline(inline, budget) {
+function validatePasteInline(inline, budget, depth = 0) {
+  if (depth > 32)
+    return false;
   if (!recordSourcePath(inline.sourcePath, budget.sourcePaths))
     return false;
+  if (inline.kind === "sdt") {
+    return (inline.controlType === "text" || inline.controlType === "richText") && isValidOptionalXmlAttributeText(inline.tag, 255) && isValidOptionalXmlAttributeText(inline.alias, 255) && Array.isArray(inline.inlines) && inline.inlines.length > 0 && inline.inlines.every((child) => child.kind === "text" || child.kind === "lineBreak" || child.kind === "sdt") && inline.inlines.every((child) => validatePasteInline(child, budget, depth + 1));
+  }
   if (inline.kind === "text") {
     return typeof inline.text === "string" && !hasUnsupportedControlChar(inline.text) && isValidPasteRunMarks(inline.marks);
   }
@@ -234057,7 +234408,7 @@ function validatePasteInline(inline, budget) {
   } else if (inline.target.kind !== "anchor" || typeof inline.target.anchor !== "string" || inline.target.anchor.length === 0 || inline.target.anchor.length > MAX_HYPERLINK_ANCHOR_CHARS || hasUnsupportedXmlAttributeChar(inline.target.anchor)) {
     return false;
   }
-  return inline.inlines.every((child) => validatePasteInline(child, budget));
+  return inline.inlines.every((child) => validatePasteInline(child, budget, depth + 1));
 }
 function rewritePastePPrStyleRef(pPrXml, styleId) {
   const escaped = styleId.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -234069,7 +234420,13 @@ function rewritePastePPrStyleRef(pPrXml, styleId) {
 function hasMatchingInlineTextProjection(block) {
   if (!Array.isArray(block.inlines))
     return false;
-  const textInlines = block.inlines.flatMap((inline) => inline.kind === "text" ? [inline] : inline.kind === "hyperlink" ? inline.inlines.flatMap((child) => child.kind === "text" ? [child] : []) : []);
+  const textInlines = block.inlines.flatMap(function project(inline) {
+    if (inline.kind === "text")
+      return [inline];
+    if (inline.kind === "hyperlink" || inline.kind === "sdt")
+      return inline.inlines.flatMap(project);
+    return [];
+  });
   return textInlines.length === block.runs.length && textInlines.every((inline, index) => {
     const run = block.runs[index];
     return inline.text === run.text && haveEqualRunMarks(inline.marks, run.marks);
@@ -247145,12 +247502,13 @@ function prepareHistoryReplayMutation(state, entry, direction, patchGroup) {
   const controlBytes = controlOwner && state.packageBytes.get(controlOwner.partUri);
   const controlPatch = controlOwner && patchGroup.perPart[controlOwner.partUri];
   const contentControlRewrite = patchGroup.source.kind === "storySurfaceRewrite" && patchGroup.source.contentControlRewrite && controlBytes && controlPatch ? prepareContentControlRewrite(controlBytes, controlPatch) : null;
+  const declaredStorySurfaceTargetBlockIds = patchGroup.source.kind === "storySurfaceRewrite" ? [...new Set(patchGroup.source.targetBlockIds)] : [];
   const targetBlockIds2 = contentControlRewrite ? [...new Set([
     ...contentControlRewrite.removedBlockIds,
     ...contentControlRewrite.addedBlockIds,
     ...contentControlRewrite.contentBlockIds,
     ...contentControlRewrite.leadingBlockIds
-  ])] : patchGroup.source.kind === "compareApply" ? [...new Set(patchGroup.source.bodySteps.map((step2) => step2.blockId))] : collectPatchGroupTargetBlockIds(patchGroup);
+  ])] : patchGroup.source.kind === "compareApply" ? [...new Set(patchGroup.source.bodySteps.map((step2) => step2.blockId))] : declaredStorySurfaceTargetBlockIds.length > 0 ? declaredStorySurfaceTargetBlockIds : collectPatchGroupTargetBlockIds(patchGroup);
   const currentBaseRevisions = {
     package: state.packageRevision,
     perPart: {}
@@ -291329,7 +291687,7 @@ class V2SelectionMutationAdapter {
     const buildResolutionMs = nowMs6() - buildResolutionStartedAt;
     let replacements = resolved.coordinateSpace !== "tracked" && resolved.startOffset < resolved.endOffset && selectedText.length === resolved.endOffset - resolved.startOffset && isPlannableTextPayload(request.text) ? planTrackedRewriteReplacement(selectedText, request.text) : [{ start: 0, end: resolved.endOffset - resolved.startOffset, text: request.text }];
     let structuralRewrite = false;
-    if (options?.changeMode === "tracked" && isRewrite && replacements.length > 1) {
+    if (options?.changeMode === "tracked" && replacements.length > 1) {
       const paragraphBytes = getSDDocumentSessionInternalPartRange(this.context.session, resolved.partUri, resolved.paragraphByteStart ?? resolved.startByte, resolved.paragraphByteEnd ?? resolved.endByte);
       if (paragraphBytes) {
         const scopedReplacements = planTrackedRewriteReplacement(selectedText, request.text, {
@@ -326296,8 +326654,8 @@ function lowerInline(inline, path7, images) {
 }
 function lowerHyperlinkChild(inline, path7, images) {
   const lowered = lowerInline(inline, path7, images);
-  if (lowered.kind === "hyperlink")
-    unsupported4(path7, "Nested hyperlinks are not supported.");
+  if (lowered.kind === "hyperlink" || lowered.kind === "sdt")
+    unsupported4(path7, "Nested hyperlinks and content controls are not supported.");
   if (lowered.kind === "footnoteRef" || lowered.kind === "endnoteRef") {
     unsupported4(path7, "Note references cannot be nested inside hyperlinks.");
   }
@@ -345491,40 +345849,63 @@ class V2ImagesAdapter {
         return trackedTarget;
       return this.createTrackedBodyImage(input, options, trackedTarget, decoded, requestedSize);
     }
-    const target = this.resolveCreateImageTarget(input, options);
-    if (!target.success)
-      return target;
-    const inserted = this.insertInline({
-      storyId: target.storyId,
-      paraId: target.paraId,
-      offset: target.offset,
-      binary: decoded.binary,
-      format: decoded.format,
-      widthPx: requestedSize.widthPx,
-      heightPx: requestedSize.heightPx,
-      name: input.alt ?? input.title
-    });
-    if (!inserted.success) {
-      return createImageFailure(inserted.failure.code, inserted.failure.message);
-    }
-    let entry = this.findInsertedImageEntry(target.storyId, target.paraId, inserted.imageNodeId);
-    if (entry && (input.title || input.alt)) {
-      const metadata2 = this.setAltText({
-        imageId: entry.publicId,
-        description: input.title ?? input.alt ?? ""
+    const abortCapture = Symbol("create.image.abort");
+    const imageFormat = decoded.format;
+    let capturedTxIds = [];
+    let failure8 = null;
+    let published = null;
+    try {
+      published = this.context.captureCommittedHistory((txIds) => {
+        capturedTxIds = txIds;
+        const resolved = this.resolveCreateImageTarget(input, options);
+        if (!resolved.success) {
+          failure8 = resolved;
+          throw abortCapture;
+        }
+        const inserted = this.insertInline({
+          storyId: resolved.storyId,
+          paraId: resolved.paraId,
+          offset: resolved.offset,
+          binary: decoded.binary,
+          format: imageFormat,
+          widthPx: requestedSize.widthPx,
+          heightPx: requestedSize.heightPx,
+          name: input.alt ?? input.title
+        });
+        if (!inserted.success) {
+          failure8 = createImageFailure(inserted.failure.code, inserted.failure.message);
+          throw abortCapture;
+        }
+        let entry = this.findInsertedImageEntry(resolved.storyId, resolved.paraId, inserted.imageNodeId);
+        if (entry && (input.title || input.alt)) {
+          const metadata2 = this.setAltText({
+            imageId: entry.publicId,
+            description: input.title ?? input.alt ?? ""
+          });
+          if (!metadata2.success) {
+            failure8 = createImageFailure(metadata2.failure.code, metadata2.failure.message);
+            throw abortCapture;
+          }
+          entry = readBodyImageEntryById(this.context, entry.publicId) ?? entry;
+        }
+        return { imageNodeId: inserted.imageNodeId, entry };
       });
-      if (!metadata2.success)
-        return createImageFailure(metadata2.failure.code, metadata2.failure.message);
-      entry = readBodyImageEntryById(this.context, entry.publicId) ?? entry;
+    } catch (error48) {
+      rollbackCapturedHistory(this.context, capturedTxIds);
+      if (error48 === abortCapture && failure8)
+        return failure8;
+      throw error48;
     }
+    const txId = publishImageCreateHistory(this.context, capturedTxIds);
     return {
       success: true,
-      image: entry?.summary.address ?? {
+      image: published?.entry?.summary.address ?? {
         kind: "inline",
         nodeType: "image",
-        nodeId: inserted.imageNodeId ?? "(unknown)",
+        nodeId: published?.imageNodeId ?? "(unknown)",
         placement: "inline"
-      }
+      },
+      ...txId ? { txId } : {}
     };
   }
   delete(input, options = {}) {
@@ -347542,6 +347923,16 @@ function validateImageDeleteTarget(context, entry) {
   }
   return null;
 }
+function publishImageCreateHistory(context, txIds) {
+  const uniqueTxIds = [...new Set(txIds)];
+  if (uniqueTxIds.length === 0)
+    return;
+  const logicalGroup = { kind: "image-create", id: uniqueTxIds[0] };
+  for (const txId of uniqueTxIds) {
+    recordCommittedTxIdForHistory(context, txId, { logicalGroup });
+  }
+  return uniqueTxIds[uniqueTxIds.length - 1];
+}
 function createImageFailure(code2, message) {
   return { success: false, failure: { code: code2, message } };
 }
@@ -349286,6 +349677,7 @@ var init_adapter17 = __esm(() => {
   init_document_reader();
   init_section_xml();
   init_adapter();
+  init_composite();
   init_stories();
   init_common();
   init_tracked_pr_change();
@@ -353085,13 +353477,14 @@ function buildCompareSourceObservation(context) {
     if (!bytes)
       continue;
     const xml = TD98.decode(bytes);
+    const canonicalizeBookmarkIds = bookmarkIdsAreBalanced(xml);
     for (const match of xml.matchAll(/<[\w.-]+:bookmarkStart\b([^>]*)>/g)) {
       const name = tagAttr(match[1] ?? "", "name");
       if (!name || name === "_GoBack")
         continue;
       acc["fields-references"].present = true;
       acc["fields-references"].entityCount += 1;
-      acc["fields-references"].fingerprintParts.push(`bookmark:${source.partUri}:${name}:${tagAttr(match[1] ?? "", "id") ?? ""}`);
+      acc["fields-references"].fingerprintParts.push(`bookmark:${source.partUri}:${name}` + (canonicalizeBookmarkIds ? "" : `:unbalanced-id:${tagAttr(match[1] ?? "", "id") ?? ""}`));
     }
     for (const match of xml.matchAll(/<[\w.-]+:permStart\b([^>]*)>/g)) {
       const id = tagAttr(match[1] ?? "", "id");
@@ -353133,6 +353526,24 @@ function buildCompareSourceObservation(context) {
   }));
   return { parts, familySignals };
 }
+function bookmarkIdsAreBalanced(xml) {
+  const starts = new Map;
+  for (const match of xml.matchAll(/<[\w.-]+:bookmarkStart\b([^>]*)>/g)) {
+    const id = tagAttr(match[1] ?? "", "id");
+    if (id === null || starts.has(id))
+      return false;
+    starts.set(id, match.index);
+  }
+  const ends = new Set;
+  for (const match of xml.matchAll(/<[\w.-]+:bookmarkEnd\b([^>]*)>/g)) {
+    const id = tagAttr(match[1] ?? "", "id");
+    const start = id === null ? undefined : starts.get(id);
+    if (id === null || start === undefined || ends.has(id) || match.index < start)
+      return false;
+    ends.add(id);
+  }
+  return starts.size === ends.size;
+}
 function captureCompareSourceInventory(context) {
   return buildCompareSourceInventory(buildCompareSourceObservation(context));
 }
@@ -353741,6 +354152,7 @@ function projectFieldsReferences(context) {
     if (!bytes)
       continue;
     const xml = TD100.decode(bytes);
+    const canonicalizeBookmarkIds = bookmarkIdsAreBalanced2(xml);
     for (const match of xml.matchAll(/<[\w.-]+:bookmarkStart\b([^>]*)>/g)) {
       const name = tagAttr3(match[1] ?? "", "name");
       if (!name || name === "_GoBack")
@@ -353751,7 +354163,7 @@ function projectFieldsReferences(context) {
         key: uniqueEntityKey(baseKey, keySeen),
         stableKey: `bookmark:${name}`,
         semanticKey: `bookmark:${name}`,
-        contentSignature: digest3(`bookmark:${name}#id:${id ?? ""}#part:${source.partUri}`),
+        contentSignature: digest3(`bookmark:${name}#part:${source.partUri}` + (canonicalizeBookmarkIds ? "" : `#unbalanced-id:${id ?? ""}`)),
         ordinal: ordinal++,
         label: source.scopeKey === "body" ? `bookmark ${name}` : `bookmark ${name} (${source.scopeKey})`
       });
@@ -353759,6 +354171,24 @@ function projectFieldsReferences(context) {
   }
   return entries;
 }
+function bookmarkIdsAreBalanced2(xml) {
+  const starts = new Map;
+  for (const match of xml.matchAll(/<[\w.-]+:bookmarkStart\b([^>]*)>/g)) {
+    const id = tagAttr3(match[1] ?? "", "id");
+    if (id === null || starts.has(id))
+      return false;
+    starts.set(id, match.index);
+  }
+  const ends = new Set;
+  for (const match of xml.matchAll(/<[\w.-]+:bookmarkEnd\b([^>]*)>/g)) {
+    const id = tagAttr3(match[1] ?? "", "id");
+    const start = id === null ? undefined : starts.get(id);
+    if (id === null || start === undefined || ends.has(id) || match.index < start)
+      return false;
+    ends.add(id);
+  }
+  return starts.size === ends.size;
+}
 function projectContentControls(context) {
   const entries = [];
   let ordinal = 0;
@@ -354619,8 +355049,12 @@ function projectStories(context, slots) {
     if (family === "footnotes" || family === "endnotes")
       requiredPartBytes(context, story.partUri);
     const paragraphs = readStoryParagraphs(context, story.storyId).filter(isWordprocessingParagraph);
+    const runXmls = paragraphs.map((p) => extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {}));
+    const runSignatures = computeRunSignatures(runXmls);
+    const runXmlByOrdinal = new Map(paragraphs.map((p, i2) => [p.ordinal, runXmls[i2]]));
+    const runSignatureByOrdinal = new Map(paragraphs.map((p, i2) => [p.ordinal, runSignatures[i2]]));
     const projectEntry2 = (p) => {
-      const runXml = extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {});
+      const runXml = runXmlByOrdinal.get(p.ordinal);
       const paragraphPropertiesXml = extractParagraphPropertiesXml(p.rawXml, p.namespaceBindings ?? {});
       const blockId = family === "header-footer-parts" && isStructurallyBlankStoryParagraph({ text: p.text, runXml }) ? `${slotKey}::blank:${p.ordinal}` : p.blockId;
       return {
@@ -354629,7 +355063,7 @@ function projectStories(context, slots) {
         text: p.text,
         headingLevel: p.headingLevel,
         styleId: p.styleId,
-        runSignature: computeRunSignature(runXml),
+        runSignature: runSignatureByOrdinal.get(p.ordinal),
         runXml,
         trackedChangeAnnotationKeys: trackedChangeAnnotationKeysForParagraph(context, p),
         paragraphPropertiesXml,
@@ -354702,8 +355136,10 @@ function bodyParagraphStructuralScopes(context, paragraphs) {
 function projectBody(context) {
   const paragraphs = readBodyParagraphs(context).filter(isWordprocessingParagraph);
   const scopes = bodyParagraphStructuralScopes(context, paragraphs);
+  const runXmls = paragraphs.map((p) => extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {}));
+  const runSignatures = computeRunSignatures(runXmls);
   return paragraphs.map((p, ordinal) => {
-    const runXml = extractParagraphRunXml(p.rawXml, p.namespaceBindings ?? {});
+    const runXml = runXmls[ordinal];
     const paragraphPropertiesXml = extractParagraphPropertiesXml(p.rawXml, p.namespaceBindings ?? {});
     return {
       blockId: p.blockId,
@@ -354712,7 +355148,7 @@ function projectBody(context) {
       text: p.text,
       headingLevel: p.headingLevel,
       styleId: p.styleId,
-      runSignature: computeRunSignature(runXml),
+      runSignature: runSignatures[ordinal],
       runXml,
       trackedChangeAnnotationKeys: trackedChangeAnnotationKeysForParagraph(context, p),
       paragraphPropertiesXml,
@@ -358567,6 +359003,119 @@ var init_main_document_revision_closure = __esm(() => {
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/tracked-table-row-replay.js
+function rowReplayCoversContentControls(baseAnnotations, targetAnnotations, steps, baseXml, targetXml) {
+  if (steps.length === 0)
+    return false;
+  const base3 = baseAnnotations?.find((group) => group.family === "content-controls")?.entries;
+  const target = targetAnnotations?.find((group) => group.family === "content-controls")?.entries;
+  if (!base3 || !target)
+    return false;
+  const inserted = new Set;
+  const deleted = new Set;
+  for (const step3 of steps) {
+    const identities = step3.kind === "insertRows" ? inserted : deleted;
+    for (const rowXml of step3.rowsXml) {
+      for (const match of rowXml.matchAll(/<[\w.-]+:sdtPr\b[^>]*>([\s\S]*?)<\/[\w.-]+:sdtPr>/g)) {
+        const properties = match[1];
+        if (/<[\w.-]+:dataBinding\b/.test(properties))
+          return false;
+        const tag = /<[\w.-]+:tag\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(properties)?.[1];
+        const alias = /<[\w.-]+:alias\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(properties)?.[1];
+        const id = /<[\w.-]+:id\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(properties)?.[1];
+        const identity2 = tag ?? alias ?? id;
+        const key2 = identity2 ? `sdt:${identity2}` : null;
+        if (!key2 || identities.has(key2))
+          return false;
+        identities.add(key2);
+      }
+    }
+  }
+  const baseByKey = new Map(base3.map((entry) => [entry.key, entry]));
+  const targetByKey = new Map(target.map((entry) => [entry.key, entry]));
+  if (baseByKey.size !== base3.length || targetByKey.size !== target.length)
+    return false;
+  const survivingBaseKeys = base3.filter((entry) => targetByKey.has(entry.key)).map((entry) => entry.key);
+  const survivingTargetKeys = target.filter((entry) => baseByKey.has(entry.key)).map((entry) => entry.key);
+  if (survivingBaseKeys.some((key2, index2) => key2 !== survivingTargetKeys[index2]))
+    return false;
+  if ([...inserted, ...deleted].some((key2) => baseByKey.has(key2) && targetByKey.has(key2)))
+    return false;
+  const baseShapes = contentControlShapes(baseXml);
+  const targetShapes = contentControlShapes(targetXml);
+  if (!baseShapes || !targetShapes)
+    return false;
+  if (survivingBaseKeys.some((key2) => key2.startsWith("sdt:") && (!baseShapes.has(key2) || baseShapes.get(key2) !== targetShapes.get(key2))))
+    return false;
+  for (const entry of base3) {
+    const other = targetByKey.get(entry.key);
+    if (other) {
+      if (entry.contentSignature !== other.contentSignature || entry.semanticKey !== other.semanticKey)
+        return false;
+    } else if (!deleted.has(entry.key))
+      return false;
+  }
+  for (const entry of target) {
+    if (!baseByKey.has(entry.key) && !inserted.has(entry.key))
+      return false;
+  }
+  return [...inserted].every((key2) => targetByKey.has(key2) && !baseByKey.has(key2)) && [...deleted].every((key2) => baseByKey.has(key2) && !targetByKey.has(key2));
+}
+function contentControlShapes(xml) {
+  const parsed = collectXmlElementRanges(xml);
+  if (parsed.errors.length > 0)
+    return null;
+  const ranges = [...parsed.ranges].sort((first, second) => first.start - second.start || second.end - first.end);
+  const parents = new Map;
+  const paths = new Map;
+  const siblingCounts = new Map;
+  const stack = [];
+  for (const range of ranges) {
+    while (stack.length && stack[stack.length - 1].end <= range.start)
+      stack.pop();
+    const parent = stack[stack.length - 1] ?? null;
+    if (parent && range.end > parent.end)
+      return null;
+    const siblingIndex = siblingCounts.get(parent) ?? 0;
+    siblingCounts.set(parent, siblingIndex + 1);
+    parents.set(range, parent);
+    paths.set(range, `${parent ? paths.get(parent) : ""}/${range.tag.namespaceUri}:${range.tag.localName}[${siblingIndex}]`);
+    stack.push(range);
+  }
+  const shapes = new Map;
+  const identityCounts = new Map;
+  for (const properties of ranges.filter((range) => range.tag.namespaceUri === WORDPROCESSINGML_NS4 && range.tag.localName === "sdtPr")) {
+    const propertyXml = xml.slice(properties.start, properties.end);
+    const tag = /<[^>]*:tag\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(propertyXml)?.[1];
+    const alias = /<[^>]*:alias\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(propertyXml)?.[1];
+    const id = /<[^>]*:id\b[^>]*\b(?:[\w.-]+:)?val="([^"]*)"/.exec(propertyXml)?.[1];
+    const key2 = tag ?? alias ?? id;
+    if (!key2)
+      return null;
+    const control = parents.get(properties);
+    if (!control || control.tag.namespaceUri !== WORDPROCESSINGML_NS4 || control.tag.localName !== "sdt")
+      return null;
+    const parent = parents.get(control);
+    const content3 = ranges.find((range) => parents.get(range) === control && range.tag.namespaceUri === WORDPROCESSINGML_NS4 && range.tag.localName === "sdtContent");
+    const firstChild = content3 && ranges.find((range) => parents.get(range) === content3);
+    if (!parent || !content3 || !firstChild)
+      return null;
+    const identity2 = `sdt:${key2}`;
+    const count = (identityCounts.get(identity2) ?? 0) + 1;
+    identityCounts.set(identity2, count);
+    const uniqueIdentity = count === 1 ? identity2 : `${identity2}#${count}`;
+    let ancestor = parent;
+    let insideRow = false;
+    while (ancestor) {
+      if (ancestor.tag.namespaceUri === WORDPROCESSINGML_NS4 && ancestor.tag.localName === "tr") {
+        insideRow = true;
+        break;
+      }
+      ancestor = parents.get(ancestor) ?? null;
+    }
+    shapes.set(uniqueIdentity, `${parent.tag.namespaceUri}:${parent.tag.localName}|${firstChild.tag.namespaceUri}:${firstChild.tag.localName}|${insideRow ? "row" : paths.get(control)}`);
+  }
+  return shapes;
+}
 function buildTrackedTableRowReplayPlan(input) {
   if (input.base.xml === input.target.xml) {
     return { steps: [], bodyOperations: input.bodyOperations, unsafeReasons: [] };
@@ -358584,30 +359133,36 @@ function buildTrackedTableRowReplayPlan(input) {
   }
   const ownedBlockIds = new Set;
   const steps = [];
+  const usedParagraphIds = new Set([
+    ...input.base.xml.matchAll(/\bparaId="([0-9A-Fa-f]{8})"/g),
+    ...input.target.xml.matchAll(/\bparaId="([0-9A-Fa-f]{8})"/g)
+  ].map((match) => match[1].toUpperCase()));
+  const baseParagraphIds = new Set([...input.base.xml.matchAll(/\bparaId="([0-9A-Fa-f]{8})"/g)].map((match) => match[1].toUpperCase()));
   for (let tableIndex = 0;tableIndex < baseCatalog.tables.length; tableIndex += 1) {
     const baseTable = baseCatalog.tables[tableIndex];
     const targetTable = targetCatalog.tables[tableIndex];
-    if (!isSimpleTable(baseTable) || !isSimpleTable(targetTable)) {
+    if (!isSimpleTable(baseTable, baseBytes, baseRoot) || !isSimpleTable(targetTable, targetBytes, targetRoot)) {
       return unsafe(`table ${baseTable.tableNodeId} has columns, merges, nesting, or unsupported cell content`);
     }
     if (baseTable.gridColumnCount !== targetTable.gridColumnCount) {
       return unsafe(`table ${baseTable.tableNodeId} changes its column grid`);
     }
-    const baseRowsById = uniqueRows(baseTable.rows.map((row) => row.rowNodeId));
-    const targetRowsById = uniqueRows(targetTable.rows.map((row) => row.rowNodeId));
-    if (!baseRowsById || !targetRowsById)
-      return unsafe(`table ${baseTable.tableNodeId} has ambiguous row identities`);
-    const targetPositions = baseTable.rows.flatMap((row) => {
-      const position2 = targetRowsById.get(row.rowNodeId);
-      return position2 === undefined ? [] : [position2];
-    });
-    if (targetPositions.length === 0)
+    const rowKey = (row, bytes) => sliceBytes(bytes, row.rowByteStart, row.rowByteEnd).replace(/\s+w14:paraId="[0-9A-Fa-f]{8}"/g, "");
+    const baseKeys = baseTable.rows.map((row) => rowKey(row, baseBytes));
+    const targetKeys = targetTable.rows.map((row) => rowKey(row, targetBytes));
+    const baseIsShorter = baseKeys.length <= targetKeys.length;
+    const matched = matchRowSubsequence(baseIsShorter ? baseKeys : targetKeys, baseIsShorter ? targetKeys : baseKeys, (baseIsShorter ? baseTable.rows : targetTable.rows).map((row) => row.rowNodeId), (baseIsShorter ? targetTable.rows : baseTable.rows).map((row) => row.rowNodeId));
+    if (!matched)
+      return unsafe(`table ${baseTable.tableNodeId} modifies, reorders, or ambiguously matches rows`, new Set(baseKeys).size < baseKeys.length || new Set(targetKeys).size < targetKeys.length);
+    const baseIndexByTarget = new Map([...matched].map(([shortIndex, longIndex]) => baseIsShorter ? [longIndex, shortIndex] : [shortIndex, longIndex]));
+    if (baseIndexByTarget.size === 0)
       return unsafe(`table ${baseTable.tableNodeId} has no surviving row`);
-    if (targetPositions.some((position2, index3) => index3 > 0 && position2 <= targetPositions[index3 - 1])) {
-      return unsafe(`table ${baseTable.tableNodeId} reorders rows`);
+    if (hasInconsistentRowIdentity(baseTable.rows, targetTable.rows, baseIndexByTarget)) {
+      return unsafe(`table ${baseTable.tableNodeId} reassigns a row identity outside its original position`, true);
     }
-    for (const baseRow of baseTable.rows) {
-      const targetPosition = targetRowsById.get(baseRow.rowNodeId);
+    const targetIndexByBase = new Map([...baseIndexByTarget].map(([targetIndex, baseIndex]) => [baseIndex, targetIndex]));
+    for (const [baseIndex, baseRow] of baseTable.rows.entries()) {
+      const targetPosition = targetIndexByBase.get(baseIndex);
       if (targetPosition === undefined) {
         const rowXml = sliceBytes(baseBytes, baseRow.rowByteStart, baseRow.rowByteEnd);
         if (containsWordprocessingRevisionMarkup(rowXml, baseRoot.namespaceBindings)) {
@@ -358631,26 +359186,27 @@ function buildTrackedTableRowReplayPlan(input) {
       }
       const targetRow = targetTable.rows[targetPosition];
       if (sliceBytes(baseBytes, baseRow.rowByteStart, baseRow.rowByteEnd) !== sliceBytes(targetBytes, targetRow.rowByteStart, targetRow.rowByteEnd)) {
-        return unsafe(`table ${baseTable.tableNodeId} modifies an existing row`);
+        if (baseKeys[baseIndex] !== targetKeys[targetPosition]) {
+          return unsafe(`table ${baseTable.tableNodeId} modifies an existing row`);
+        }
       }
     }
     if (tableSkeleton(baseBytes, baseTable) !== tableSkeleton(targetBytes, targetTable)) {
       return unsafe(`table ${baseTable.tableNodeId} changes non-row table structure`);
     }
-    const baseIds = new Set(baseTable.rows.map((row) => row.rowNodeId));
     let index2 = 0;
     while (index2 < targetTable.rows.length) {
-      if (baseIds.has(targetTable.rows[index2].rowNodeId)) {
+      if (baseIndexByTarget.has(index2)) {
         index2 += 1;
         continue;
       }
       const start = index2;
-      while (index2 < targetTable.rows.length && !baseIds.has(targetTable.rows[index2].rowNodeId))
+      while (index2 < targetTable.rows.length && !baseIndexByTarget.has(index2))
         index2 += 1;
       const inserted = targetTable.rows.slice(start, index2);
-      const nextBaseRow = targetTable.rows[index2];
-      const previousBaseRow = [...targetTable.rows.slice(0, start)].reverse().find((row) => baseIds.has(row.rowNodeId));
-      const anchor = nextBaseRow ?? previousBaseRow;
+      const nextBaseIndex = baseIndexByTarget.get(index2);
+      const previousBaseIndex = [...baseIndexByTarget.entries()].reverse().find(([targetIndex]) => targetIndex < start)?.[1];
+      const anchor = baseTable.rows[nextBaseIndex ?? previousBaseIndex ?? -1];
       if (!anchor)
         return unsafe(`table ${baseTable.tableNodeId} has no stable insertion anchor`);
       for (const row of inserted) {
@@ -358672,20 +359228,34 @@ function buildTrackedTableRowReplayPlan(input) {
         const rowXml = transplantableRowPayload(sourceRowXml, baseRoot, targetRoot);
         if (!rowXml)
           return unsafe("inserted row uses a namespace that cannot be transplanted safely");
-        rowsXml.push(rowXml);
+        const identifiedRowXml = ensureInsertedParagraphIds(rowXml, baseRoot, baseParagraphIds, usedParagraphIds);
+        if (!identifiedRowXml)
+          return unsafe("inserted row cannot be assigned safe paragraph identities");
+        rowsXml.push(identifiedRowXml);
       }
       steps.push({
         kind: "insertRows",
         storyId: STORY_ID2,
         tableNodeId: baseTable.tableNodeId,
         anchorRowNodeId: anchor.rowNodeId,
-        placement: nextBaseRow ? "before" : "after",
+        placement: nextBaseIndex !== undefined ? "before" : "after",
         rowsXml
       });
     }
+    if (steps.some((step3) => step3.tableNodeId === baseTable.tableNodeId)) {
+      for (const entry of [...input.baseBody ?? [], ...input.targetBody]) {
+        if (entry.structuralScope?.startsWith(`table:${baseTable.tableNodeId}:cell:`) || entry.structuralScope?.startsWith(`table:${targetTable.tableNodeId}:cell:`)) {
+          ownedBlockIds.add(entry.blockId);
+        }
+      }
+    }
   }
   if (steps.length === 0)
     return unsafe("table topology changed without an inserted or deleted row");
+  const ambiguousBodyOperation = input.bodyOperations.find((operation) => ownedBlockIds.has(operation.blockId) && (operation.kind === "insert" || operation.kind === "insertAtStart" ? input.targetBody.some((entry) => entry.blockId === operation.blockId && !entry.structuralScope?.startsWith("table:")) : input.baseBody?.some((entry) => entry.blockId === operation.blockId && !entry.structuralScope?.startsWith("table:"))));
+  if (ambiguousBodyOperation) {
+    return unsafe(`body operation ${ambiguousBodyOperation.blockId} shares a table-cell identity`, true);
+  }
   const bodyOperations = input.bodyOperations.filter((operation) => !ownedBlockIds.has(operation.blockId));
   const unownedStructuralOperation = bodyOperations.find((operation) => {
     const target = input.targetBody.find((entry) => entry.blockId === operation.blockId);
@@ -358715,21 +359285,135 @@ function containsWordprocessingRevisionMarkup(xml, namespaceBindings) {
   }
   return containsRevision;
 }
-function unsafe(reason) {
-  return { steps: [], bodyOperations: [], unsafeReasons: [reason] };
+function unsafe(reason, refuseBlockFallback = false) {
+  return { steps: [], bodyOperations: [], unsafeReasons: [reason], refuseBlockFallback };
 }
-function uniqueRows(ids) {
-  const result = new Map;
-  for (let index2 = 0;index2 < ids.length; index2 += 1) {
-    const id = ids[index2];
-    if (result.has(id))
+function matchRowSubsequence(shortKeys, longKeys, shortIds, longIds) {
+  const remainingMatches = (shortStart, longStart) => {
+    for (let shortIndex = shortStart;shortIndex < shortKeys.length; shortIndex += 1) {
+      while (longStart < longKeys.length && longKeys[longStart] !== shortKeys[shortIndex])
+        longStart += 1;
+      if (longStart === longKeys.length)
+        return false;
+      longStart += 1;
+    }
+    return true;
+  };
+  const matches = new Map;
+  let nextLongIndex = 0;
+  for (let shortIndex = 0;shortIndex < shortKeys.length; shortIndex += 1) {
+    const candidates = [];
+    for (let longIndex = nextLongIndex;longIndex < longKeys.length; longIndex += 1) {
+      if (shortKeys[shortIndex] === longKeys[longIndex] && remainingMatches(shortIndex + 1, longIndex + 1))
+        candidates.push(longIndex);
+    }
+    if (candidates.length === 0)
       return null;
-    result.set(id, index2);
+    const sameIdentity = candidates.filter((index2) => shortIds[shortIndex] === longIds[index2]);
+    if (candidates.length > 1 && sameIdentity.length !== 1)
+      return null;
+    const selected = sameIdentity[0] ?? candidates[0];
+    matches.set(shortIndex, selected);
+    nextLongIndex = selected + 1;
   }
-  return result;
+  for (const [shortIndex, longIndex] of matches) {
+    const key2 = shortKeys[shortIndex];
+    if (shortKeys.indexOf(key2) === shortKeys.lastIndexOf(key2) && longKeys.indexOf(key2) === longKeys.lastIndexOf(key2))
+      continue;
+    const sharedLongIndex = longIds.findIndex((id, index2) => id === shortIds[shortIndex] && longKeys[index2] === key2);
+    const sharedShortIndex = shortIds.findIndex((id, index2) => id === longIds[longIndex] && shortKeys[index2] === key2);
+    if (sharedLongIndex >= 0 && sharedLongIndex !== longIndex || sharedShortIndex >= 0 && sharedShortIndex !== shortIndex)
+      return null;
+  }
+  return matches;
+}
+function hasInconsistentRowIdentity(baseRows, targetRows, baseIndexByTarget) {
+  const baseIndexById = new Map(baseRows.map((row, index2) => [row.rowNodeId, index2]));
+  for (const [targetIndex, targetRow] of targetRows.entries()) {
+    if (targetRow.identityProvenance !== "para-id")
+      continue;
+    const baseIndex = baseIndexById.get(targetRow.rowNodeId);
+    if (baseIndex === undefined || baseRows[baseIndex].identityProvenance !== "para-id")
+      continue;
+    if (baseIndex !== targetIndex && baseIndexByTarget.get(targetIndex) !== baseIndex)
+      return true;
+  }
+  return false;
+}
+function isSimpleTable(table, bytes, root) {
+  return !table.containsNestedTable && !table.hasGridSpan && !table.hasVMerge && table.isRectangular && table.rows.every((row) => row.cells.every((cell) => !cell.containsUnsupportedContent || isSafeContentControlCell(sliceBytes(bytes, cell.bodyByteStart, cell.bodyByteEnd), root)));
+}
+function isSafeContentControlCell(xml, root) {
+  let foundControl = false;
+  let safe = true;
+  const parser = createXmlSaxParser({
+    namespaceAware: true,
+    fragment: true,
+    additionalNamespaces: { ...root.namespaceBindings }
+  });
+  parser.on("error", () => {
+    safe = false;
+  });
+  parser.on("opentag", (tag) => {
+    if (tag.namespaceUri !== WORDPROCESSINGML_NS4)
+      return;
+    if (tag.localName === "sdt")
+      foundControl = true;
+    if (["drawing", "object", "oMath", "oMathPara", "tbl"].includes(tag.localName) || tag.attributes.some((attribute2) => isRelationshipNamespace(attribute2.namespaceUri)))
+      safe = false;
+  });
+  try {
+    parser.write(xml);
+    parser.close();
+  } catch {
+    return false;
+  }
+  return foundControl && safe;
 }
-function isSimpleTable(table) {
-  return !table.containsNestedTable && !table.hasGridSpan && !table.hasVMerge && table.isRectangular && table.rows.every((row) => row.cells.every((cell) => !cell.containsUnsupportedContent));
+function ensureInsertedParagraphIds(xml, root, baseIds, usedIds) {
+  const parsed = collectXmlElementRanges(xml, {
+    fragment: true,
+    additionalNamespaces: { ...root.namespaceBindings }
+  });
+  if (parsed.errors.length > 0)
+    return null;
+  const insertions = [];
+  for (const paragraph4 of parsed.ranges.filter((range) => range.tag.namespaceUri === WORDPROCESSINGML_NS4 && range.tag.localName === "p")) {
+    const existingId = paragraph4.tag.attributes.find((attribute2) => attribute2.namespaceUri === WORDPROCESSINGML_2010_NS && attribute2.localName === "paraId");
+    if (existingId && !baseIds.has(existingId.value.toUpperCase()))
+      continue;
+    let identifier;
+    for (let candidate2 = 1879048192;candidate2 > 0; candidate2 -= 1) {
+      const value2 = candidate2.toString(16).toUpperCase().padStart(8, "0");
+      if (!usedIds.has(value2)) {
+        identifier = value2;
+        usedIds.add(value2);
+        break;
+      }
+    }
+    if (!identifier)
+      return null;
+    if (existingId) {
+      const opening = xml.slice(paragraph4.start, paragraph4.openEnd);
+      const attribute2 = new RegExp(`\\b${existingId.name}="${existingId.value}"`);
+      const match = attribute2.exec(opening);
+      if (!match)
+        return null;
+      insertions.push({
+        offset: paragraph4.start + match.index,
+        text: `${existingId.name}="${identifier}"`,
+        end: paragraph4.start + match.index + match[0].length
+      });
+    } else {
+      const localDeclaration = paragraph4.namespaceBindings.w14 === WORDPROCESSINGML_2010_NS ? "" : ` xmlns:w14="${WORDPROCESSINGML_2010_NS}"`;
+      const opening = xml.slice(paragraph4.start, paragraph4.openEnd);
+      insertions.push({
+        offset: paragraph4.openEnd - (opening.endsWith("/>") ? 2 : 1),
+        text: `${localDeclaration} w14:paraId="${identifier}"`
+      });
+    }
+  }
+  return insertions.reverse().reduce((result, insertion) => result.slice(0, insertion.offset) + insertion.text + result.slice(insertion.end ?? insertion.offset), xml);
 }
 function tableSkeleton(bytes, table) {
   let cursor = table.tableByteStart;
@@ -360034,10 +360718,16 @@ function projectMainDocumentBodyEntries(source, options = {}) {
   });
   const scopes = mapBodyParagraphStructuralScopes(tableCatalog, paragraphIndex.entries);
   const namespaceBindingsByByteStart = scanParagraphNamespaceBindingsByByteStart(source.xml);
-  return paragraphIndex.entries.map((entry) => {
-    const rawXml = TD107.decode(bytes.subarray(entry.byteStart, entry.byteEnd));
+  const rawXmls = paragraphIndex.entries.map((entry) => TD107.decode(bytes.subarray(entry.byteStart, entry.byteEnd)));
+  const runXmls = paragraphIndex.entries.map((entry, index2) => {
+    const namespaceBindings = namespaceBindingsByByteStart.get(entry.byteStart) ?? {};
+    return extractParagraphRunXml(rawXmls[index2], namespaceBindings);
+  });
+  const runSignatures = computeRunSignatures(runXmls);
+  return paragraphIndex.entries.map((entry, index2) => {
+    const rawXml = rawXmls[index2];
     const namespaceBindings = namespaceBindingsByByteStart.get(entry.byteStart) ?? {};
-    const runXml = extractParagraphRunXml(rawXml, namespaceBindings);
+    const runXml = runXmls[index2];
     const paragraphPropertiesXml = extractParagraphPropertiesXml(rawXml, namespaceBindings);
     return {
       blockId: entry.blockId,
@@ -360046,7 +360736,7 @@ function projectMainDocumentBodyEntries(source, options = {}) {
       text: readVisibleParagraphText(rawXml),
       headingLevel: paragraphHeadingLevel(rawXml, { paragraphStyleOutlineLevels }),
       styleId: paragraphStyleId(rawXml),
-      runSignature: computeRunSignature(runXml),
+      runSignature: runSignatures[index2],
       runXml,
       paragraphPropertiesXml,
       paragraphPropertiesSignature: computeParagraphPropertiesSignature2(paragraphPropertiesXml)
@@ -361391,7 +362081,32 @@ function paragraphOpeningTag2(paragraphXml) {
   return paragraphXml.slice(0, paragraphXml.indexOf(">") + 1);
 }
 function ownedStructuresEqual(leftXml, rightXml) {
-  return arraysEqual2(collectElements(leftXml, "sectPr"), collectElements(rightXml, "sectPr")) && arraysEqual2(collectEmptyElements(leftXml, "bookmarkStart"), collectEmptyElements(rightXml, "bookmarkStart")) && arraysEqual2(collectEmptyElements(leftXml, "bookmarkEnd"), collectEmptyElements(rightXml, "bookmarkEnd")) && arraysEqual2(collectElements(leftXml, "fldSimple"), collectElements(rightXml, "fldSimple")) && arraysEqual2(collectElements(leftXml, "instrText"), collectElements(rightXml, "instrText")) && arraysEqual2(collectEmptyElements(leftXml, "fldChar"), collectEmptyElements(rightXml, "fldChar"));
+  return arraysEqual2(collectElements(leftXml, "sectPr"), collectElements(rightXml, "sectPr")) && bookmarkStructuresEqual(leftXml, rightXml) && arraysEqual2(collectElements(leftXml, "fldSimple"), collectElements(rightXml, "fldSimple")) && arraysEqual2(collectElements(leftXml, "instrText"), collectElements(rightXml, "instrText")) && arraysEqual2(collectEmptyElements(leftXml, "fldChar"), collectEmptyElements(rightXml, "fldChar"));
+}
+function bookmarkStructuresEqual(leftXml, rightXml) {
+  const summarize = (xml) => {
+    if (!bookmarkRangesArePaired(xml))
+      return null;
+    const nameById = new Map(collectWordElements(xml, "bookmarkStart", true).map((element) => {
+      const id = readAttribute2(element, "id");
+      const name = readAttribute2(element, "name");
+      return [id, name];
+    }));
+    const starts = collectWordElements(xml, "bookmarkStart", true).map((element) => ({
+      position: element.range.start,
+      value: `start:${replaceAttribute(element, "id", "__bookmark_id__")}`
+    }));
+    const ends = collectWordElements(xml, "bookmarkEnd", true).map((element) => ({
+      position: element.range.start,
+      value: `end:${replaceAttribute(element, "id", `__bookmark_${nameById.get(readAttribute2(element, "id")) ?? "missing"}__`)}`
+    }));
+    return [...starts, ...ends].sort((a, b) => a.position - b.position).map((event) => event.value);
+  };
+  const left = summarize(leftXml);
+  const right = summarize(rightXml);
+  if (!left || !right || left.length !== right.length)
+    return false;
+  return left.every((value2, index2) => value2 === right[index2]);
 }
 function arraysEqual2(left, right) {
   return left.length === right.length && left.every((value2, index2) => value2 === right[index2]);
@@ -361427,39 +362142,44 @@ function buildSectionSteps(baseXml, targetXml, unsafeReasons) {
 function buildReferenceSteps(baseXml, targetXml, unsafeReasons) {
   const baseBookmarks = collectWordElements(baseXml, "bookmarkStart", true);
   const targetBookmarks = collectWordElements(targetXml, "bookmarkStart", true);
-  if (baseBookmarks.length !== targetBookmarks.length) {
-    unsafeReasons.push("bookmark topology changed");
-    return [];
-  }
   if (!bookmarkRangesArePaired(baseXml) || !bookmarkRangesArePaired(targetXml)) {
     unsafeReasons.push("bookmark topology is unbalanced or duplicated");
     return [];
   }
   const renamedBookmarks = new Map;
   const steps = [];
-  for (let index2 = 0;index2 < baseBookmarks.length; index2 += 1) {
-    const before = baseBookmarks[index2];
-    const after = targetBookmarks[index2];
-    const beforeXml = before.xml;
-    const afterXml = after.xml;
-    if (beforeXml === afterXml)
-      continue;
-    const beforeId = readAttribute2(before, "id");
-    const afterId = readAttribute2(after, "id");
-    const beforeName = readAttribute2(before, "name");
-    const afterName = readAttribute2(after, "name");
-    if (!beforeId || beforeId !== afterId || !beforeName || !afterName || replaceAttribute(before, "name", afterName) !== afterXml) {
-      unsafeReasons.push(`bookmark ${index2} changed beyond a name-only rename`);
-      continue;
+  if (baseBookmarks.length === targetBookmarks.length) {
+    for (let index2 = 0;index2 < baseBookmarks.length; index2 += 1) {
+      const before = baseBookmarks[index2];
+      const after = targetBookmarks[index2];
+      const beforeXml = before.xml;
+      const afterXml = after.xml;
+      if (beforeXml === afterXml)
+        continue;
+      const beforeId = readAttribute2(before, "id");
+      const afterId = readAttribute2(after, "id");
+      const beforeName = readAttribute2(before, "name");
+      const afterName = readAttribute2(after, "name");
+      if (beforeId && afterId && beforeName && beforeName === afterName && replaceAttribute(after, "id", beforeId) === beforeXml) {
+        continue;
+      }
+      if (!beforeId || beforeId !== afterId || !beforeName || !afterName || replaceAttribute(before, "name", afterName) !== afterXml) {
+        unsafeReasons.push(`bookmark ${index2} changed beyond a name-only rename or ID allocation`);
+        continue;
+      }
+      renamedBookmarks.set(beforeName, afterName);
+      steps.push({
+        kind: "bookmark-start",
+        beforeXml,
+        afterXml,
+        beforeNamespaceBindings: { ...before.range.namespaceBindings },
+        afterNamespaceBindings: { ...after.range.namespaceBindings }
+      });
     }
-    renamedBookmarks.set(beforeName, afterName);
-    steps.push({
-      kind: "bookmark-start",
-      beforeXml,
-      afterXml,
-      beforeNamespaceBindings: { ...before.range.namespaceBindings },
-      afterNamespaceBindings: { ...after.range.namespaceBindings }
-    });
+  } else if (targetBookmarks.length > baseBookmarks.length) {
+    steps.push(...buildAddedBookmarkSteps(baseXml, targetXml, baseBookmarks, targetBookmarks, unsafeReasons));
+  } else {
+    unsafeReasons.push("bookmark removal is not supported");
   }
   const baseFields = collectWordElements(baseXml, "fldSimple");
   const targetFields = collectWordElements(targetXml, "fldSimple");
@@ -361490,8 +362210,125 @@ function buildReferenceSteps(baseXml, targetXml, unsafeReasons) {
       afterNamespaceBindings: { ...after.range.namespaceBindings }
     });
   }
+  steps.push(...buildAddedComplexFieldSteps(baseXml, targetXml, unsafeReasons));
+  return steps;
+}
+function buildAddedBookmarkSteps(baseXml, targetXml, baseBookmarks, targetBookmarks, unsafeReasons) {
+  const baseNames = new Set(baseBookmarks.map((element) => readAttribute2(element, "name")));
+  const targetNames = targetBookmarks.map((element) => readAttribute2(element, "name"));
+  if (baseNames.has(null) || targetNames.some((name) => name === null) || new Set(targetNames).size !== targetNames.length || [...baseNames].some((name) => !targetNames.includes(name))) {
+    unsafeReasons.push("bookmark addition cannot be matched unambiguously by name");
+    return [];
+  }
+  const baseParagraphs = collectWordElements(baseXml, "p");
+  const targetParagraphs = collectWordElements(targetXml, "p");
+  if (baseParagraphs.length !== targetParagraphs.length) {
+    unsafeReasons.push("bookmark addition changed paragraph topology");
+    return [];
+  }
+  const targetEnds = collectWordElements(targetXml, "bookmarkEnd", true);
+  const steps = [];
+  for (const start of targetBookmarks.filter((element) => !baseNames.has(readAttribute2(element, "name")))) {
+    const id = readAttribute2(start, "id");
+    const end = targetEnds.find((candidate2) => readAttribute2(candidate2, "id") === id);
+    const paragraphIndex = targetParagraphs.findIndex((paragraph4) => paragraph4.range.start < start.range.start && paragraph4.range.end > (end?.range.end ?? Number.MAX_SAFE_INTEGER));
+    if (!id || !end || paragraphIndex < 0) {
+      unsafeReasons.push("added bookmark range is not contained in one paragraph");
+      continue;
+    }
+    const before = baseParagraphs[paragraphIndex];
+    const after = targetParagraphs[paragraphIndex];
+    const beforeFragmentXml = targetXml.slice(start.range.end, end.range.start);
+    const afterFragmentXml = targetXml.slice(start.range.start, end.range.end);
+    if (replaceUnique(after.xml, afterFragmentXml, beforeFragmentXml) !== before.xml) {
+      unsafeReasons.push("added bookmark range changes content beyond a balanced wrapper");
+      continue;
+    }
+    steps.push({
+      kind: "bookmark-range",
+      beforeXml: before.xml,
+      afterXml: after.xml,
+      beforeFragmentXml,
+      afterFragmentXml,
+      beforeNamespaceBindings: { ...before.range.namespaceBindings },
+      afterNamespaceBindings: { ...after.range.namespaceBindings }
+    });
+  }
   return steps;
 }
+function buildAddedComplexFieldSteps(baseXml, targetXml, unsafeReasons) {
+  const baseParagraphs = collectWordElements(baseXml, "p");
+  const targetParagraphs = collectWordElements(targetXml, "p");
+  if (baseParagraphs.length !== targetParagraphs.length)
+    return [];
+  const targetBookmarkNameCounts = new Map;
+  for (const bookmark of collectWordElements(targetXml, "bookmarkStart", true)) {
+    const name = readAttribute2(bookmark, "name");
+    if (name !== null) {
+      targetBookmarkNameCounts.set(name, (targetBookmarkNameCounts.get(name) ?? 0) + 1);
+    }
+  }
+  const steps = [];
+  for (let index2 = 0;index2 < targetParagraphs.length; index2 += 1) {
+    const before = baseParagraphs[index2];
+    const after = targetParagraphs[index2];
+    if (before.xml === after.xml)
+      continue;
+    const candidate2 = addedComplexRefField(after, before.xml);
+    if (!candidate2)
+      continue;
+    const targetCount = targetBookmarkNameCounts.get(candidate2.referenceName) ?? 0;
+    if (targetCount === 0) {
+      unsafeReasons.push(`complex REF field ${index2} targets a missing bookmark`);
+      continue;
+    }
+    if (targetCount !== 1) {
+      unsafeReasons.push(`complex REF field ${index2} targets an ambiguous bookmark`);
+      continue;
+    }
+    steps.push({
+      kind: "complex-field",
+      beforeXml: before.xml,
+      afterXml: after.xml,
+      beforeFragmentXml: candidate2.resultXml,
+      afterFragmentXml: candidate2.fieldXml,
+      beforeNamespaceBindings: { ...before.range.namespaceBindings },
+      afterNamespaceBindings: { ...after.range.namespaceBindings }
+    });
+  }
+  return steps;
+}
+function addedComplexRefField(targetParagraph, expectedBaseParagraphXml) {
+  const fields = collectWordElements(targetParagraph.xml, "fldChar", true, targetParagraph.range.namespaceBindings);
+  for (let beginIndex = 0;beginIndex < fields.length; beginIndex += 1) {
+    const begin = fields[beginIndex];
+    if (readAttribute2(begin, "fldCharType") !== "begin")
+      continue;
+    const separate = fields.slice(beginIndex + 1).find((field) => readAttribute2(field, "fldCharType") === "separate");
+    const end = separate && fields.find((field) => field.range.start > separate.range.start && readAttribute2(field, "fldCharType") === "end");
+    if (!separate || !end)
+      continue;
+    const runs = collectWordElements(targetParagraph.xml, "r", false, targetParagraph.range.namespaceBindings);
+    const beginRun = runs.find((run) => run.range.start <= begin.range.start && run.range.end >= begin.range.end);
+    const separateRun = runs.find((run) => run.range.start <= separate.range.start && run.range.end >= separate.range.end);
+    const endRun = runs.find((run) => run.range.start <= end.range.start && run.range.end >= end.range.end);
+    if (!beginRun || !separateRun || !endRun)
+      continue;
+    const instruction = collectWordElements(targetParagraph.xml, "instrText", false, targetParagraph.range.namespaceBindings).filter((element) => element.range.start > begin.range.end && element.range.end < separate.range.start).map((element) => element.xml.replace(/^<[^>]+>|<\/[^>]+>$/g, "")).join("");
+    const parsed = parseRefInstruction(instruction);
+    if (!parsed)
+      continue;
+    const fieldXml = targetParagraph.xml.slice(beginRun.range.start, endRun.range.end);
+    const resultXml = targetParagraph.xml.slice(separateRun.range.end, endRun.range.start);
+    const fieldChars = fields.filter((field) => field.range.start >= begin.range.start && field.range.end <= end.range.end);
+    if (fieldChars.length !== 3 || fieldChars.map((field) => readAttribute2(field, "fldCharType")).join(",") !== "begin,separate,end")
+      continue;
+    if (!resultXml || replaceUnique(targetParagraph.xml, fieldXml, resultXml) !== expectedBaseParagraphXml)
+      continue;
+    return { fieldXml, resultXml, referenceName: parsed.name };
+  }
+  return null;
+}
 function bookmarkRangesArePaired(xml) {
   const startsById = new Map;
   for (const element of collectWordElements(xml, "bookmarkStart", true)) {
@@ -361520,8 +362357,10 @@ function collectEmptyElements(xml, localName2) {
 function collectElements(xml, localName2) {
   return collectWordElements(xml, localName2).map((element) => element.xml);
 }
-function collectWordElements(xml, localName2, selfClosingOnly = false) {
-  const parsed = collectXmlElementRanges(xml, { additionalNamespaces: { w: WORDPROCESSINGML_NS6 } });
+function collectWordElements(xml, localName2, selfClosingOnly = false, additionalNamespaces = {}) {
+  const parsed = collectXmlElementRanges(xml, {
+    additionalNamespaces: { w: WORDPROCESSINGML_NS6, ...additionalNamespaces }
+  });
   if (parsed.errors.length > 0)
     return [];
   return parsed.ranges.filter((range) => range.tag.namespaceUri === WORDPROCESSINGML_NS6 && range.tag.localName === localName2 && (!selfClosingOnly || range.tag.isSelfClosing)).sort((left, right) => left.start - right.start).map((range) => ({ xml: xml.slice(range.start, range.end), range }));
@@ -361676,7 +362515,11 @@ class V2DiffAdapter {
     try {
       const engine = createV2CompareEngine(this.context);
       const base3 = captureCompareSnapshotSync(this.context);
-      const analysis = engine.analyzeSnapshots(base3, targetPayload.compareSnapshot);
+      const baseMainDocument = projectDiffMainDocumentSource(this.context);
+      const targetMainDocument = targetPayload.mainDocument ?? EMPTY_MAIN_DOCUMENT_SOURCE;
+      const rawAnalysis = engine.analyzeSnapshots(base3, targetPayload.compareSnapshot);
+      const comparisonTarget = paragraphIdentityOnlyComparisonTarget(base3, targetPayload.compareSnapshot, baseMainDocument, targetMainDocument, rawAnalysis.result);
+      const analysis = comparisonTarget ? engine.analyzeSnapshots(base3, comparisonTarget) : rawAnalysis;
       if (!analysis.plan) {
         throw diffValidationError("INVALID_INPUT", "diff.compare: compare engine did not return a semantic analysis plan.");
       }
@@ -361693,8 +362536,6 @@ class V2DiffAdapter {
       const baseNumbering = projectDiffNumberingSource(this.context);
       const targetNumbering = targetPayload.numbering ?? { xml: null };
       const numberingPlan = buildNumberingApplyPlan(baseNumbering, targetNumbering);
-      const baseMainDocument = projectDiffMainDocumentSource(this.context);
-      const targetMainDocument = targetPayload.mainDocument ?? EMPTY_MAIN_DOCUMENT_SOURCE;
       const sectionsReferencesPlan = buildSectionsReferencesReplayPlan(baseMainDocument, targetMainDocument);
       const adapterApplySupportedFamilies = new Set;
       if (sectionsReferencesPlan.unsafeReasons.length === 0) {
@@ -361967,8 +362808,9 @@ class V2DiffAdapter {
         unsupportedReason: "section-reference-replay-unsafe"
       });
     }
-    const localizedBodyOperations = sectionsReferencesPlan.hasUnownedMainDocumentChanges ? buildLocalizedBodyOperations(payload.base.body, payload.target.body, sectionsReferencesPlan.sectionSteps, sectionsReferencesPlan.referenceSteps, { base: payload.base.definitions, target: payload.target.definitions }, canonicalBodyOperations) : [];
-    if (localizedBodyOperations.length > 0) {
+    const usesLocalizedMainDocumentReplay = sectionsReferencesChanged && (sectionsReferencesPlan.sectionSteps.length > 0 || sectionsReferencesPlan.referenceSteps.length > 0);
+    const localizedBodyOperations = usesLocalizedMainDocumentReplay ? buildLocalizedBodyOperations(payload.base.body, payload.target.body, sectionsReferencesPlan.sectionSteps, sectionsReferencesPlan.referenceSteps, { base: payload.base.definitions, target: payload.target.definitions }, canonicalBodyOperations) : [];
+    if (usesLocalizedMainDocumentReplay) {
       setRuntimeBodyOperationCounts(operationCounts, payload.applyPlan, localizedBodyOperations);
     }
     const localizedMainDocumentCovered = !sectionsReferencesPlan.hasUnownedMainDocumentChanges || localizedMainDocumentChangesAreCovered({
@@ -362014,19 +362856,23 @@ class V2DiffAdapter {
       }
     }
     const mainDocumentPlan = tablesChanged && !reviewMarkup ? buildMainDocumentApplyPlan(liveBaseMainDocument, payloadMainDocument.target) : { steps: [], unsafeReasons: [] };
-    const trackedTableBodyOperations = !tablesChanged || !reviewMarkup ? payload.applyPlan.bodyOperations : localizedBodyOperations.length > 0 ? localizedBodyOperations : mergeCanonicalRevisionReplay(computeCompareBodyOperations(payload.base.body, payload.target.body, {
+    const trackedTableBodyOperations = !tablesChanged || !reviewMarkup ? payload.applyPlan.bodyOperations : usesLocalizedMainDocumentReplay ? localizedBodyOperations : mergeCanonicalRevisionReplay(computeCompareBodyOperations(payload.base.body, payload.target.body, {
       base: payload.base.definitions,
       target: payload.target.definitions
     }), canonicalBodyOperations);
     const trackedTablePropertyPlan = tablesChanged && reviewMarkup ? buildTrackedTablePropertyReplayPlan(liveBaseMainDocument, payloadMainDocument.target) : null;
-    let trackedTableBlockPlan = tablesChanged && reviewMarkup && !trackedTablePropertyPlan ? buildTrackedTableBlockReplayPlan({ base: liveBaseMainDocument, target: payloadMainDocument.target, bodyOperations: trackedTableBodyOperations }) : null;
-    let trackedTablePlan = tablesChanged && reviewMarkup && !trackedTableBlockPlan && !trackedTablePropertyPlan ? buildTrackedTableRowReplayPlan({
+    let trackedTablePlan = tablesChanged && reviewMarkup && !trackedTablePropertyPlan ? buildTrackedTableRowReplayPlan({
       base: liveBaseMainDocument,
       target: payloadMainDocument.target,
+      baseBody: payload.base.body,
       targetBody: payload.target.body,
       bodyOperations: trackedTableBodyOperations
-    }) : { steps: [], bodyOperations: trackedTableBlockPlan?.bodyOperations ?? (trackedTablePropertyPlan ? trackedTableBodyOperations : payload.applyPlan.bodyOperations), unsafeReasons: [] };
-    if (trackedTablePlan.unsafeReasons.length > 0) {
+    }) : { steps: [], bodyOperations: trackedTablePropertyPlan ? trackedTableBodyOperations : payload.applyPlan.bodyOperations, unsafeReasons: [] };
+    let trackedTableBlockPlan = tablesChanged && reviewMarkup && !trackedTablePropertyPlan && !trackedTablePlan.refuseBlockFallback && (trackedTablePlan.unsafeReasons.length > 0 || trackedTablePlan.steps.length === 0) ? buildTrackedTableBlockReplayPlan({ base: liveBaseMainDocument, target: payloadMainDocument.target, bodyOperations: trackedTableBodyOperations }) : null;
+    if (trackedTableBlockPlan) {
+      trackedTablePlan = { steps: [], bodyOperations: trackedTableBlockPlan.bodyOperations, unsafeReasons: [] };
+    }
+    if (trackedTablePlan.unsafeReasons.length > 0 && !trackedTablePlan.refuseBlockFallback) {
       const replacement = buildTrackedTableBlockReplayPlan({
         base: liveBaseMainDocument,
         target: payloadMainDocument.target,
@@ -362081,7 +362927,7 @@ class V2DiffAdapter {
     if (mainDocumentPlan.unsafeReasons.length > 0) {
       throw diffValidationError("CAPABILITY_UNSUPPORTED", `diff.apply: main document replay is unsafe — [${mainDocumentPlan.unsafeReasons.join("; ")}]. ` + "No mutation was performed (full payloads are never partially applied).", { changedFamilies: ["tables"], unsupportedReason: "main-document-replay-unsafe" });
     }
-    const runtimeApplyPlan = localizedBodyOperations.length > 0 ? {
+    const runtimeApplyPlan = usesLocalizedMainDocumentReplay ? {
       ...runtimeApplyPlanBase,
       applyPlan: {
         ...runtimeApplyPlanBase.applyPlan,
@@ -362113,6 +362959,13 @@ class V2DiffAdapter {
         handledFamilies.add("body");
       }
     }
+    const rowControlsCovered = trackedTablePlan.steps.length > 0 && rowReplayCoversContentControls(payload.base.annotations, payload.target.annotations, trackedTablePlan.steps, liveBaseMainDocument.xml, payloadMainDocument.target.xml);
+    if (trackedTablePlan.steps.length > 0 && !rowControlsCovered) {
+      throw diffValidationError("CAPABILITY_UNSUPPORTED", "diff.apply: row replay cannot cover content-control structure. No mutation was performed.", { changedFamilies: ["content-controls"], unsupportedReason: "content-control-replay-unsafe" });
+    }
+    if (changedPolicies.some((policy) => policy.family === "content-controls") && rowControlsCovered) {
+      handledFamilies.add("content-controls");
+    }
     if (mainRevisionChangesHandled)
       handledFamilies.add("tracked-changes");
     if (mainDocumentPlan.steps.length > 0)
@@ -362289,6 +363142,23 @@ function buildCompareApplyEligibility(context, payload, plans) {
       direct.add("fields-references");
       tracked.add("fields-references");
     }
+    const usesLocalizedMainDocumentReplay = plans.sectionsReferencesPlan.sectionSteps.length > 0 || plans.sectionsReferencesPlan.referenceSteps.length > 0;
+    if (usesLocalizedMainDocumentReplay) {
+      const localizedBodyOperations = buildLocalizedBodyOperations(payload.base.body, payload.target.body, plans.sectionsReferencesPlan.sectionSteps, plans.sectionsReferencesPlan.referenceSteps, { base: payload.base.definitions, target: payload.target.definitions }, payload.applyPlan.bodyOperations);
+      const localizedMainDocumentCovered = !plans.sectionsReferencesPlan.hasUnownedMainDocumentChanges || localizedMainDocumentChangesAreCovered({
+        base: payload.mainDocument?.base ?? EMPTY_MAIN_DOCUMENT_SOURCE,
+        target: payload.mainDocument?.target ?? EMPTY_MAIN_DOCUMENT_SOURCE,
+        baseBody: payload.base.body,
+        targetBody: payload.target.body,
+        sectionSteps: plans.sectionsReferencesPlan.sectionSteps,
+        referenceSteps: plans.sectionsReferencesPlan.referenceSteps,
+        bodyOperations: localizedBodyOperations
+      });
+      if (localizedMainDocumentCovered) {
+        direct.add("body");
+        tracked.add("body");
+      }
+    }
   }
   const slotsChanged = plans.physicalPlan.hasReferenceIdChanges || payload.familyPolicy.some((policy) => policy.family === "header-footer-slots" && policy.applyRequired);
   const slotPlan = slotsChanged ? buildHeaderFooterSlotPackageRewrite(context, payload.base.slots ?? [], payload.target.slots ?? [], plans.physicalPlan.refByPart) : { rewrites: [], unsafeReasons: [], operationCount: 0 };
@@ -362350,13 +363220,19 @@ function buildCompareApplyEligibility(context, payload, plans) {
     const trackedTablePlan = buildTrackedTableRowReplayPlan({
       base: mainDocument.base,
       target: mainDocument.target,
+      baseBody: payload.base.body,
       targetBody: payload.target.body,
-      bodyOperations: payload.applyPlan.bodyOperations
+      bodyOperations: payload.applyPlan.bodyOperations.length > 0 ? payload.applyPlan.bodyOperations : computeCompareBodyOperations(payload.base.body, payload.target.body, {
+        base: payload.base.definitions,
+        target: payload.target.definitions
+      })
     });
     if (trackedTablePlan.unsafeReasons.length === 0 && trackedTablePlan.steps.length > 0) {
       tracked.add("tables");
       if (bodyDeferredToTableReplay)
         tracked.add("body");
+      if (rowReplayCoversContentControls(payload.base.annotations, payload.target.annotations, trackedTablePlan.steps, mainDocument.base.xml, mainDocument.target.xml))
+        tracked.add("content-controls");
     }
   }
   const packageGraphCoveredByComments = direct.has("comments") && packageGraphKeysNotCoveredByComments(context, payload.base, payload.target, plans.commentPlan.steps).length === 0;
@@ -362414,7 +363290,16 @@ function buildCompareApplyEligibility(context, payload, plans) {
     });
   }
   for (const mode of ["direct", "tracked"]) {
-    const runtimePlan = buildHeaderFooterRuntimeApplyPlan(payload, slotPlan, plans.physicalPlan, mode === "tracked");
+    let runtimePlan = buildHeaderFooterRuntimeApplyPlan(payload, slotPlan, plans.physicalPlan, mode === "tracked");
+    if (plans.sectionsReferencesPlan.unsafeReasons.length === 0 && (plans.sectionsReferencesPlan.sectionSteps.length > 0 || plans.sectionsReferencesPlan.referenceSteps.length > 0)) {
+      runtimePlan = {
+        ...runtimePlan,
+        applyPlan: {
+          ...runtimePlan.applyPlan,
+          bodyOperations: buildLocalizedBodyOperations(payload.base.body, payload.target.body, plans.sectionsReferencesPlan.sectionSteps, plans.sectionsReferencesPlan.referenceSteps, { base: payload.base.definitions, target: payload.target.definitions }, payload.applyPlan.bodyOperations)
+        }
+      };
+    }
     const unsupportedFamilies = findStructurallyUnsupportedOperationFamilies(context, runtimePlan, payload.mainDocument?.base ?? EMPTY_MAIN_DOCUMENT_SOURCE, mode === "tracked", plans.sectionsReferencesPlan.referenceSteps);
     if (unsupportedFamilies.length > 0) {
       hazards[mode].push({
@@ -362958,7 +363843,8 @@ function buildLocalizedBodyOperations(base3, target, sectionSteps, referenceStep
     throwLocalizedBodyCorrespondenceError(sectionSteps, referenceSteps);
   const neutralTarget = target.map((entry) => {
     const baseEntry = correspondence.baseByTargetId.get(entry.blockId);
-    const neutralRunXml = baseEntry?.runXml && entry.runXml ? referenceSteps.reduce((xml, step3) => reverseReferenceAttribute(xml, step3), entry.runXml) : entry.runXml;
+    const reversedRunXml = baseEntry?.runXml && entry.runXml ? referenceSteps.reduce((xml, step3) => reverseReferenceAttribute(xml, step3), entry.runXml) : entry.runXml;
+    const neutralRunXml = baseEntry?.runXml && reversedRunXml && stripReplayNamespaceDeclarations(reversedRunXml) === stripReplayNamespaceDeclarations(baseEntry.runXml) ? baseEntry.runXml : reversedRunXml;
     const neutralParagraphPropertiesXml = baseEntry?.paragraphPropertiesXml !== undefined && entry.paragraphPropertiesXml !== undefined ? sectionSteps.reduce((xml, step3) => reverseSectionProperties(xml, baseEntry.paragraphPropertiesXml, step3), entry.paragraphPropertiesXml) : entry.paragraphPropertiesXml;
     if (neutralRunXml === entry.runXml && neutralParagraphPropertiesXml === entry.paragraphPropertiesXml)
       return entry;
@@ -363025,6 +363911,17 @@ function reverseSectionProperties(targetParagraphPropertiesXml, baseParagraphPro
   return targetParagraphPropertiesXml.slice(0, targetStart) + step3.beforeXml + targetParagraphPropertiesXml.slice(targetStart + step3.afterXml.length);
 }
 function reverseReferenceAttribute(xml, step3) {
+  if (step3.kind === "bookmark-range" || step3.kind === "complex-field") {
+    if (step3.beforeFragmentXml === undefined || step3.afterFragmentXml === undefined)
+      return xml;
+    const normalizedXml = stripReplayNamespaceDeclarations(xml);
+    const after = stripReplayNamespaceDeclarations(step3.afterFragmentXml);
+    const before = stripReplayNamespaceDeclarations(step3.beforeFragmentXml);
+    const start = normalizedXml.indexOf(after);
+    if (start < 0 || normalizedXml.indexOf(after, start + after.length) >= 0)
+      return xml;
+    return normalizedXml.slice(0, start) + before + normalizedXml.slice(start + after.length);
+  }
   const elementName = step3.kind === "bookmark-start" ? "bookmarkStart" : "fldSimple";
   const localName2 = step3.kind === "bookmark-start" ? "name" : "instr";
   const afterValue = readReplayAttribute(step3.afterXml, localName2, step3.afterNamespaceBindings);
@@ -363094,7 +363991,9 @@ function validateFullDiffCanonicalArtifacts(engine, payload) {
   const problems = [];
   let canonicalAnalysis;
   try {
-    canonicalAnalysis = engine.analyzeSnapshots(payload.base, payload.target);
+    const rawAnalysis = engine.analyzeSnapshots(payload.base, payload.target);
+    const comparisonTarget = paragraphIdentityOnlyComparisonTarget(payload.base, payload.target, payload.mainDocument?.base ?? EMPTY_MAIN_DOCUMENT_SOURCE, payload.mainDocument?.target ?? EMPTY_MAIN_DOCUMENT_SOURCE, rawAnalysis.result);
+    canonicalAnalysis = comparisonTarget ? engine.analyzeSnapshots(payload.base, comparisonTarget) : rawAnalysis;
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     return { problems: [`payload.base/target could not be re-analyzed (${message})`] };
@@ -363114,6 +364013,25 @@ function validateFullDiffCanonicalArtifacts(engine, payload) {
   }
   return { problems };
 }
+function paragraphIdentityOnlyComparisonTarget(base3, target, baseDocument, targetDocument, rawAnalysis) {
+  if (!baseDocument.xml || !targetDocument.xml || baseDocument.xml === targetDocument.xml)
+    return null;
+  const withoutParagraphIds = (xml) => xml.includes("<!DOCTYPE") ? xml : xml.replace(/<!\[CDATA\[[\s\S]*?\]\]>|<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<[A-Za-z_](?:[^>"']|"[^"]*"|'[^']*')*>/g, (token) => token.startsWith("<!") || token.startsWith("<?") ? token : token.replace(/("[^"]*"|'[^']*')|(\s+w14:paraId="[0-9A-Fa-f]{8}")/g, (part, quotedValue) => quotedValue ?? "").replace(/\s+\/>$/, "/>"));
+  if (withoutParagraphIds(baseDocument.xml) !== withoutParagraphIds(targetDocument.xml))
+    return null;
+  if (validateMainDocumentSourceAgainstSnapshotPart(baseDocument, base3, "base").length > 0 || validateMainDocumentSourceAgainstSnapshotPart(targetDocument, target, "target").length > 0)
+    return null;
+  const levels = (source) => new Map(Object.entries(source.paragraphStyleOutlineLevels ?? {}));
+  if (validateMainDocumentSourceAgainstBodySnapshot(baseDocument, base3.body, { paragraphStyleOutlineLevels: levels(baseDocument) }).length > 0 || validateMainDocumentSourceAgainstBodySnapshot(targetDocument, target.body, { paragraphStyleOutlineLevels: levels(targetDocument) }).length > 0)
+    return null;
+  const otherParts = (snapshot2) => snapshot2.sourceInventory?.parts.filter((part) => part.partUri !== DOCUMENT_PART_URI6);
+  if (!base3.sourceInventory || !target.sourceInventory || !artifactEquals(otherParts(base3), otherParts(target)))
+    return null;
+  const changedFamilies3 = rawAnalysis.families.filter((family) => family.state === "changed-supported");
+  if (!changedFamilies3.some((family) => family.family === "tables") || changedFamilies3.some((family) => family.family !== "body" && family.family !== "tables"))
+    return null;
+  return { ...base3, identity: target.identity };
+}
 function artifactEquals(left, right) {
   return JSON.stringify(normalizeArtifactForCompare(left)) === JSON.stringify(normalizeArtifactForCompare(right));
 }
@@ -363293,8 +364211,14 @@ function containsStructuralParagraphTag(xml, blockKind) {
   return errors4.length === 0 ? found : null;
 }
 function findUniqueReplayCarrier(xml, step3) {
+  if (step3.kind === "bookmark-range" || step3.kind === "complex-field") {
+    const fragment3 = step3.afterFragmentXml;
+    if (!fragment3)
+      return null;
+    const start = xml.indexOf(fragment3);
+    return start >= 0 && xml.indexOf(fragment3, start + fragment3.length) < 0 ? { start, end: start + fragment3.length } : null;
+  }
   const expectedName = step3.kind === "bookmark-start" ? "bookmarkStart" : "fldSimple";
-  const localName2 = step3.kind === "bookmark-start" ? "name" : "instr";
   const parsed = collectXmlElementRanges(xml, {
     fragment: true,
     additionalNamespaces: { ...step3.beforeNamespaceBindings }
@@ -377122,13 +378046,7 @@ function normalizeParagraphBlock(value2, path7, version2, allowHeading) {
         return normalized;
       inlines.push(normalized);
     }
-    const projected = inlines.flatMap((inline) => {
-      if (inline.kind === "text")
-        return [inline];
-      if (inline.kind === "hyperlink")
-        return inline.inlines.filter((child) => child.kind === "text");
-      return [];
-    });
+    const projected = inlines.flatMap(projectInlineText);
     if (projected.length !== runs.length || projected.some((inline, runIndex) => inline.text !== runs[runIndex]?.text || JSON.stringify(inline.marks ?? {}) !== JSON.stringify(runs[runIndex]?.marks ?? {}))) {
       return structureFailure("Paragraph runs must equal the text projection of inlines.", path7);
     }
@@ -377153,6 +378071,12 @@ function normalizeParagraphBlock(value2, path7, version2, allowHeading) {
   const paragraphProps = normalizeParagraphProperties(value2.paragraphProps, [...path7, "paragraphProps"]);
   if (isPlanFailure(paragraphProps))
     return paragraphProps;
+  const blockSdts = normalizeBlockSdts(value2.blockSdts, [...path7, "blockSdts"]);
+  if (isPlanFailure(blockSdts))
+    return blockSdts;
+  if (blockSdts && (version2 !== SUPERDOC_V22_CLIPBOARD_FRAGMENT_VERSION || value2.complete !== true)) {
+    return structureFailure("Complete block content controls require a v2.2 paragraph.", [...path7, "blockSdts"]);
+  }
   const sourcePath = normalizeSourcePath(value2.sourcePath, [...path7, "sourcePath"]);
   if (isPlanFailure(sourcePath))
     return sourcePath;
@@ -377167,16 +378091,83 @@ function normalizeParagraphBlock(value2, path7, version2, allowHeading) {
     ...typeof continuation === "number" ? { listItemContinuationLevel: continuation } : {},
     ...typeof value2.pPrXml === "string" && value2.pPrXml.length > 0 ? { pPrXml: value2.pPrXml } : {},
     ...value2.complete === true ? { complete: true } : {},
+    ...blockSdts ? { blockSdts } : {},
     ...sourcePath ? { sourcePath } : {}
   };
   return isHeading ? { kind: "heading", level: value2.level, ...common } : { kind: "paragraph", ...common };
 }
-function normalizeInline(value2, path7, allowHyperlink) {
+function normalizeBlockSdts(value2, path7) {
+  if (value2 === undefined)
+    return;
+  if (!Array.isArray(value2) || value2.length === 0 || value2.length > 16) {
+    return structureFailure("Block content-control ancestry must contain 1 to 16 wrappers.", path7);
+  }
+  const ids = new Set;
+  const result = [];
+  for (const [index2, wrapper] of value2.entries()) {
+    if (!isRecord15(wrapper) || typeof wrapper.sourceId !== "string" || !/^[0-9]{1,10}$/.test(wrapper.sourceId) || ids.has(wrapper.sourceId) || wrapper.controlType !== "text" && wrapper.controlType !== "richText" || !validSdtMetadata(wrapper) || wrapper.tag !== undefined && (typeof wrapper.tag !== "string" || wrapper.tag.length > 255 || !isXml10SafeAttributeValue(wrapper.tag)) || wrapper.alias !== undefined && (typeof wrapper.alias !== "string" || wrapper.alias.length > 255 || !isXml10SafeAttributeValue(wrapper.alias))) {
+      return structureFailure("Invalid block content-control wrapper.", [...path7, index2]);
+    }
+    ids.add(wrapper.sourceId);
+    result.push({
+      sourceId: wrapper.sourceId,
+      controlType: wrapper.controlType,
+      ...wrapper.tag !== undefined ? { tag: wrapper.tag } : {},
+      ...wrapper.alias !== undefined ? { alias: wrapper.alias } : {},
+      ...wrapper.lockMode !== undefined ? { lockMode: wrapper.lockMode } : {},
+      ...wrapper.multiline !== undefined ? { multiline: wrapper.multiline } : {}
+    });
+  }
+  return result;
+}
+function validSdtMetadata(value2) {
+  return (value2.lockMode === undefined || value2.lockMode === "unlocked" || value2.lockMode === "sdtLocked" || value2.lockMode === "contentLocked" || value2.lockMode === "sdtContentLocked") && (value2.multiline === undefined || value2.controlType === "text" && typeof value2.multiline === "boolean");
+}
+function projectInlineText(inline) {
+  if (inline.kind === "text")
+    return [inline];
+  if (inline.kind === "sdt" || inline.kind === "hyperlink")
+    return inline.inlines.flatMap(projectInlineText);
+  return [];
+}
+function normalizeInline(value2, path7, allowHyperlink, depth = 0) {
   if (!isRecord15(value2))
     return structureFailure("Paste inlines must be objects.", path7);
+  if (depth > 32)
+    return structureFailure("Paste inline nesting exceeds the allowed depth.", path7);
   const sourcePath = normalizeSourcePath(value2.sourcePath, [...path7, "sourcePath"]);
   if (isPlanFailure(sourcePath))
     return sourcePath;
+  if (value2.kind === "sdt") {
+    if (value2.controlType !== "text" && value2.controlType !== "richText" || !validSdtMetadata(value2) || !Array.isArray(value2.inlines) || value2.inlines.length === 0) {
+      return structureFailure("Content controls require a supported type and nonempty inlines.", path7);
+    }
+    for (const key2 of ["tag", "alias"]) {
+      if (value2[key2] !== undefined && (typeof value2[key2] !== "string" || value2[key2].length > 255 || !isXml10SafeAttributeValue(value2[key2]))) {
+        return structureFailure(`Content control ${key2} must be XML-safe and at most 255 characters.`, [...path7, key2]);
+      }
+    }
+    const inlines = [];
+    for (const [index2, child] of value2.inlines.entries()) {
+      const normalized = normalizeInline(child, [...path7, "inlines", index2], false, depth + 1);
+      if (isPlanFailure(normalized))
+        return normalized;
+      if (normalized.kind !== "text" && normalized.kind !== "lineBreak" && normalized.kind !== "sdt") {
+        return structureFailure("Unsupported content inside a content control.", [...path7, "inlines", index2]);
+      }
+      inlines.push(normalized);
+    }
+    return {
+      kind: "sdt",
+      controlType: value2.controlType,
+      inlines,
+      ...typeof value2.tag === "string" ? { tag: value2.tag } : {},
+      ...typeof value2.alias === "string" ? { alias: value2.alias } : {},
+      ...value2.lockMode !== undefined ? { lockMode: value2.lockMode } : {},
+      ...value2.multiline !== undefined ? { multiline: value2.multiline } : {},
+      ...sourcePath ? { sourcePath } : {}
+    };
+  }
   if (value2.kind === "text" && typeof value2.text === "string" && isXml10SafeString(value2.text)) {
     if (value2.marks !== undefined && (!isRecord15(value2.marks) || Array.isArray(value2.marks))) {
       return structureFailure("Paste run marks must be an object.", [...path7, "marks"]);
@@ -377234,8 +378225,8 @@ function normalizeInline(value2, path7, allowHyperlink) {
     const normalized = normalizeInline(child, [...path7, "inlines", childIndex], false);
     if (isPlanFailure(normalized))
       return normalized;
-    if (normalized.kind === "hyperlink")
-      return structureFailure("Nested hyperlinks are not supported.", [...path7, "inlines", childIndex]);
+    if (normalized.kind === "hyperlink" || normalized.kind === "sdt")
+      return structureFailure("Nested hyperlinks and content controls are not supported.", [...path7, "inlines", childIndex]);
     if (normalized.kind === "footnoteRef" || normalized.kind === "endnoteRef") {
       return structureFailure("Note references cannot be nested inside hyperlinks.", [...path7, "inlines", childIndex]);
     }
@@ -377680,6 +378671,9 @@ function normalizeTableBlock(block, index2, version2) {
         const paragraph4 = normalizeParagraphBlock(cellBlock, ["blocks", index2, "rows", rowIndex, "cells", cellIndex, "blocks", cellBlockIndex], version2, false);
         if (isPlanFailure(paragraph4))
           return paragraph4;
+        if (paragraph4.blockSdts?.length) {
+          return structureFailure("Block content controls inside table cells are not supported.", ["blocks", index2, "rows", rowIndex, "cells", cellIndex, "blocks", cellBlockIndex, "blockSdts"]);
+        }
         cellBlocks.push(paragraph4);
       }
       cells.push({
@@ -378437,7 +379431,8 @@ function serializeSelectionRange(context, target, includeHtml, options) {
       code: "PRECONDITION_FAILED",
       message: "story part bytes are unavailable."
     };
-  const boundaryMap = buildStructuralBoundaryMap(bytes.subarray(0, endEntry.byteEnd));
+  const boundaryMap = buildStructuralBoundaryMap(bytes);
+  const blockSdtWrappers = scanBlockSdtWrappers(SERIALIZE_TD.decode(bytes));
   const hyperlinkDescriptorResolver = new SelectionHyperlinkDescriptorResolver(context, resolved.storyId);
   let tableCatalog;
   const notes = new SerializeNotes;
@@ -378500,6 +379495,7 @@ function serializeSelectionRange(context, target, includeHtml, options) {
       loadCatalog: loadCommentsCatalog
     };
     const tableCellPath = boundaryMap.byBlockId(entry.blockId)?.tableCellPath ?? [];
+    const blockSdtPath = boundaryMap.byBlockId(entry.blockId)?.blockSdtPath ?? [];
     const properties = readParagraphProperties(paragraphXml);
     const fullyCovered = 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));
@@ -378508,7 +379504,23 @@ function serializeSelectionRange(context, target, includeHtml, options) {
     const semanticHeadingLevel = semanticStyleRole?.startsWith("heading-") ? Number(semanticStyleRole.slice("heading-".length)) : null;
     const parts = [];
     let objectOrdinal = 0;
-    for (const piece of map3.leaves()) {
+    for (const piece of copySelectionPieces(map3.pieces)) {
+      if (piece.kind === "container" && piece.containerKind === "sdt") {
+        const sdt = from <= piece.visibleStart && piece.visibleEnd <= to ? serializeSdtPart(piece, from, to, notes, styleContext, review) : null;
+        if (sdt) {
+          parts.push(sdt);
+          continue;
+        }
+        for (const leaf of copySelectionPieces(piece.children, false)) {
+          if (leaf.visibleStart >= to || leaf.visibleEnd <= from)
+            continue;
+          notes.add("fields", "Content-control and field structure is not preserved by copy; visible text was kept.");
+          const leafParts = [];
+          walkPieces([leaf], from, to, leafParts, notes, styleContext, review);
+          parts.push(...leafParts);
+        }
+        continue;
+      }
       if (isVisibleZeroWidthObjectPiece(piece)) {
         const selected = fullyCovered || selectedObjectOrdinals?.has(objectOrdinal);
         objectOrdinal += 1;
@@ -378588,8 +379600,18 @@ function serializeSelectionRange(context, target, includeHtml, options) {
     }
     const pPrXml = fullyCovered ? materializeEffectivePPrXml(capturedPPrXml, properties.styleRef, copyParagraphPropertyModel ?? (copyParagraphPropertyModel = compileCopyParagraphPropertyXmlModel(context)), inTable ? "table" : "full", resolveRunMarks(extractParagraphMarkRPrXml(capturedPPrXml), styleContext), numbering != null) : null;
     const listLevel = numbering ? Number.parseInt(numbering.ilvl, 10) : undefined;
+    const blockSdts = blockSdtPath.map((ordinal) => {
+      const wrapper = blockSdtWrappers.get(ordinal);
+      if (!wrapper || !fullyCovered || tableCellPath.length > 0 || !wrapper.supported || index2.entries.some((candidate2) => boundaryMap.byBlockId(candidate2.blockId)?.blockSdtPath.includes(ordinal) && (candidate2.ordinal < startEntry.ordinal || candidate2.ordinal > endEntry.ordinal || candidate2.ordinal === startEntry.ordinal && startPoint.offset !== 0 || candidate2.ordinal === endEntry.ordinal && endPoint.offset !== parseParagraphInlineMap(SERIALIZE_TD.decode(bytes.subarray(endEntry.byteStart, endEntry.byteEnd))).visibleLength)))
+        return null;
+      return wrapper.properties;
+    });
+    if (blockSdtPath.length > 0 && blockSdts.some((wrapper) => wrapper === null)) {
+      notes.add("block-sdt", "A partial or unsupported block content control was copied as visible text without its wrapper.");
+    }
     blocks.push({
       blockId: entry.blockId,
+      ...blockSdts.length > 0 && blockSdts.every((wrapper) => wrapper !== null) ? { blockSdts } : {},
       runs: parts.flatMap(serializedPartRuns),
       ...fullyCovered && properties.styleRef ? { styleRef: properties.styleRef } : {},
       ...fullyCovered && semanticStyleRole ? { semanticStyleRole } : {},
@@ -378639,14 +379661,16 @@ function serializeSelectionRange(context, target, includeHtml, options) {
     })), notes.diagnostics());
     plan = buildPlan(fallbackFragment, "plain-text", notes.diagnostics(), true);
   } else {
-    const fragment3 = withPasteComments(buildFragment(grouped.map(fragmentBlockFor), notes.diagnostics()), commentsById);
+    const hasPreservedControls = blocks.some((block) => !!block.blockSdts?.length || block.parts.some((part) => part.kind === "sdt"));
+    const legacyDiagnostics = hasPreservedControls ? [...notes.diagnostics(), diagnostic("paste-no-faithful-representation", "The v2.1 clipboard flavor retains visible text but not content-control structure; use the v2.2 flavor to preserve controls.", "superdoc-v2-fragment", "warning")] : notes.diagnostics();
+    const fragment3 = withPasteComments(buildFragment(grouped.map(fragmentBlockFor), legacyDiagnostics), commentsById);
     items.push({
       type: SUPERDOC_V2_CLIPBOARD_MIME,
       kind: "string",
       data: JSON.stringify(fragment3)
     });
     const assets = [...rich.assetsByPartUri.values()];
-    const hasRichInlineStructure = blocks.some((block) => block.parts.some((part) => part.kind === "hyperlink" || part.kind === "image"));
+    const hasRichInlineStructure = blocks.some((block) => !!block.blockSdts?.length || block.parts.some((part) => part.kind === "hyperlink" || part.kind === "image" || part.kind === "sdt"));
     if (!rich.invalid && hasRichInlineStructure) {
       const richBlocks = grouped.map(richFragmentBlockFor);
       const wireFragment = withPasteComments({
@@ -378670,6 +379694,84 @@ function serializeSelectionRange(context, target, includeHtml, options) {
     }
   };
 }
+function topLevelChildrenCoverXml(xml, children2) {
+  let cursor = 0;
+  for (const child of children2) {
+    const start = xml.indexOf(child.xml, cursor);
+    if (start < 0 || xml.slice(cursor, start).trim().length > 0)
+      return false;
+    cursor = start + child.xml.length;
+  }
+  return xml.slice(cursor).trim().length === 0;
+}
+function parseSupportedSdtProperties(xml) {
+  const children2 = parseTopLevelChildren(xml);
+  if (!topLevelChildrenCoverXml(xml, children2))
+    return null;
+  const properties = { controlType: "richText" };
+  let seenControlType = false;
+  for (const child of children2) {
+    if (child.prefix !== "w")
+      return null;
+    if (child.localName === "id") {
+      if (!/^<w:id\b[^>]*\/>$/.test(child.xml))
+        return null;
+    } else if (child.localName === "tag" || child.localName === "alias") {
+      if (!/^<w:(?:tag|alias)\b[^>]*\/>$/.test(child.xml))
+        return null;
+      const value2 = readBareAttribute(child.xml, "w:val");
+      if (value2 === null || value2.length > 255)
+        return null;
+      properties[child.localName] = value2;
+    } else if (child.localName === "lock") {
+      const match = /^<w:lock\s+w:val=(['"])(unlocked|sdtLocked|contentLocked|sdtContentLocked)\1\s*\/>$/.exec(child.xml);
+      if (!match || properties.lockMode !== undefined)
+        return null;
+      properties.lockMode = match[2];
+    } else if (child.localName === "text") {
+      const match = /^<w:text(?:\s+w:multiLine=(['"])(1|0|true|false|on|off)\1)?\s*\/>$/.exec(child.xml);
+      if (!match || seenControlType)
+        return null;
+      seenControlType = true;
+      properties.controlType = "text";
+      if (match[2] !== undefined)
+        properties.multiline = match[2] === "1" || match[2] === "true" || match[2] === "on";
+    } else if (child.localName === "richText") {
+      if (!/^<w:richText\s*\/>$/.test(child.xml) || seenControlType)
+        return null;
+      seenControlType = true;
+    } else {
+      return null;
+    }
+  }
+  return properties;
+}
+function scanBlockSdtWrappers(xml) {
+  const wrappers = new Map;
+  const stack = [];
+  const tokens = /<w:p\b[^>]*>[\s\S]*?<\/w:p\s*>|<w:sdt\b[^>]*>|<\/w:sdt\s*>/g;
+  let ordinal = 0;
+  for (const token of xml.matchAll(tokens)) {
+    if (token[0].startsWith("<w:p"))
+      continue;
+    if (token[0].startsWith("</")) {
+      const frame = stack.pop();
+      if (!frame)
+        continue;
+      const wrapperXml = xml.slice(frame.start, token.index + token[0].length);
+      const propertiesXml = /<w:sdtPr\b[^>]*>([\s\S]*?)<\/w:sdtPr>/.exec(wrapperXml)?.[1];
+      const contentXml = /<w:sdtContent\b[^>]*>([\s\S]*)<\/w:sdtContent>/.exec(wrapperXml)?.[1];
+      const children2 = contentXml === undefined ? [] : parseTopLevelChildren(contentXml);
+      const parsedProperties = propertiesXml === undefined ? null : parseSupportedSdtProperties(propertiesXml);
+      const properties = { sourceId: String(frame.ordinal), ...parsedProperties ?? { controlType: "richText" } };
+      const supported = parsedProperties !== null && contentXml !== undefined && children2.length > 0 && children2.every((child) => child.prefix === "w" && (child.localName === "p" || child.localName === "sdt")) && topLevelChildrenCoverXml(contentXml, children2);
+      wrappers.set(frame.ordinal, { properties, supported });
+    } else {
+      stack.push({ ordinal: ordinal++, start: token.index });
+    }
+  }
+  return wrappers;
+}
 function serializeSelectedDrawing(input) {
   const fail6 = (key2, message) => {
     input.notes.add(key2, message);
@@ -378842,7 +379944,7 @@ function appendSerializedParts(out, parts, hyperlink) {
 function serializedPartRuns(part) {
   if (part.kind === "run")
     return [part.run];
-  if (part.kind === "hyperlink")
+  if (part.kind === "hyperlink" || part.kind === "sdt")
     return part.parts.flatMap(serializedPartRuns);
   return [];
 }
@@ -378868,6 +379970,48 @@ function noteContainingStructures(piece, notes, preservesHyperlink) {
   }
   return supported;
 }
+function copySelectionPieces(pieces, stopAtSdt = true) {
+  return pieces.flatMap((piece) => {
+    if (piece.kind === "container" && piece.containerKind === "sdt" && stopAtSdt)
+      return [piece];
+    if (piece.kind === "container" || piece.kind === "tracked") {
+      if (piece.kind === "container" && piece.policy === "atomic")
+        return [piece];
+      return copySelectionPieces(piece.children, stopAtSdt);
+    }
+    return [piece];
+  });
+}
+function serializeSdtPart(piece, from, to, notes, styleContext, review) {
+  const propertiesXml = /<w:sdtPr\b[^>]*>([\s\S]*?)<\/w:sdtPr>/.exec(piece.rawXml)?.[1];
+  if (propertiesXml === undefined)
+    return null;
+  const properties = parseSupportedSdtProperties(propertiesXml);
+  if (!properties)
+    return null;
+  const parts = [];
+  for (const child of piece.children) {
+    if (child.kind === "container" && child.containerKind === "sdt") {
+      if (child.visibleStart < from || child.visibleEnd > to)
+        return null;
+      const nested = serializeSdtPart(child, from, to, notes, styleContext, review);
+      if (!nested)
+        return null;
+      parts.push(nested);
+    } else if (child.kind === "text" || child.kind === "control") {
+      if (child.kind === "text" && child.textRole !== "visible")
+        return null;
+      const leaves = [];
+      walkPieces([child], from, to, leaves, notes, styleContext, review);
+      parts.push(...leaves);
+    } else {
+      return null;
+    }
+  }
+  if (!parts.length)
+    return null;
+  return { kind: "sdt", ...properties, parts };
+}
 
 class SerializeNotes {
   constructor() {
@@ -379479,10 +380623,34 @@ function paragraphFragmentFor(block) {
 function richParagraphFragmentFor(block) {
   return {
     ...paragraphFragmentFor(block),
+    ...block.blockSdts ? { blockSdts: block.blockSdts } : {},
     inlines: block.parts.flatMap(serializedPartInlines)
   };
 }
+function serializedSdtChildInline(part) {
+  if (part.kind === "sdt")
+    return {
+      kind: "sdt",
+      controlType: part.controlType,
+      ...part.tag !== undefined ? { tag: part.tag } : {},
+      ...part.alias !== undefined ? { alias: part.alias } : {},
+      ...part.lockMode !== undefined ? { lockMode: part.lockMode } : {},
+      ...part.multiline !== undefined ? { multiline: part.multiline } : {},
+      inlines: part.parts.map(serializedSdtChildInline)
+    };
+  return serializedLeafPartInline(part);
+}
 function serializedPartInlines(part) {
+  if (part.kind === "sdt")
+    return [{
+      kind: "sdt",
+      controlType: part.controlType,
+      ...part.tag !== undefined ? { tag: part.tag } : {},
+      ...part.alias !== undefined ? { alias: part.alias } : {},
+      ...part.lockMode !== undefined ? { lockMode: part.lockMode } : {},
+      ...part.multiline !== undefined ? { multiline: part.multiline } : {},
+      inlines: part.parts.map(serializedSdtChildInline)
+    }];
   if (part.kind !== "hyperlink")
     return [serializedLeafPartInline(part)];
   return [
@@ -379540,7 +380708,7 @@ function serializedPartPlainText(part) {
 `;
   if (part.kind === "run")
     return part.run.text;
-  if (part.kind === "hyperlink")
+  if (part.kind === "hyperlink" || part.kind === "sdt")
     return part.parts.map(serializedPartPlainText).join("");
   return "";
 }
@@ -379564,6 +380732,8 @@ function renderHtmlPart(part) {
     return renderHtmlRun(part.run);
   if (part.kind === "image")
     return "";
+  if (part.kind === "sdt")
+    return part.parts.map(renderHtmlPart).join("");
   const href = part.target.kind === "external" ? part.target.url : `#${part.target.anchor}`;
   const title = part.tooltip ? ` title="${escapeHtmlAttribute3(part.tooltip)}"` : "";
   return `<a href="${escapeHtmlAttribute3(href)}"${title}>${part.parts.map(renderHtmlPart).join("")}</a>`;