@superdoc/mcp 1.6.1-next.1 → 1.6.1-next.2

package/dist/index.js

@@ -31600,7 +31600,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.19.1-next.1";
+var SDK_VERSION = "2.19.1-next.2";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { accessSync, chmodSync, constants, existsSync, statSync } from "node:fs";
@@ -127288,7 +127288,8 @@ function buildStructuralBoundaryMap(bytes) {
           sdtOrdinal: sdtCounter,
           wrapperLocked: lockPolicy.wrapperLocked,
           contentLocked: lockPolicy.contentLocked,
-          contentEditable: !lockPolicy.contentLocked && isSdtContentEditable(sdtXml)
+          contentEditable: !lockPolicy.contentLocked && isSdtContentEditable(sdtXml),
+          textAtomic: isTextAtomicBlockSdt(sdtXml)
         });
         sdtCounter += 1;
       } else if (tag.local === "customXml") {
@@ -127311,6 +127312,7 @@ function recordParagraph2(input) {
   const blockCustomXmlPath = [];
   let hasLockedBlockSdt = false;
   let hasNonEditableBlockSdtContent = false;
+  let hasTextAtomicBlockSdt = false;
   let hasContentLockedBlockSdt = false;
   let lastTable = -1;
   let lastRow = -1;
@@ -127330,6 +127332,7 @@ function recordParagraph2(input) {
       blockSdtPath.push(frame.sdtOrdinal);
       hasLockedBlockSdt || (hasLockedBlockSdt = frame.wrapperLocked);
       hasNonEditableBlockSdtContent || (hasNonEditableBlockSdtContent = !frame.contentEditable);
+      hasTextAtomicBlockSdt || (hasTextAtomicBlockSdt = frame.textAtomic);
       hasContentLockedBlockSdt || (hasContentLockedBlockSdt = frame.contentLocked);
     } else if (frame.kind === "customXml") {
       blockCustomXmlPath.push(frame.customXmlOrdinal);
@@ -127342,6 +127345,7 @@ function recordParagraph2(input) {
     blockSdtPath,
     hasLockedBlockSdt,
     hasNonEditableBlockSdtContent,
+    hasTextAtomicBlockSdt,
     hasContentLockedBlockSdt,
     blockCustomXmlPath,
     sectionIndex: input.sectionIndex,
@@ -127351,6 +127355,13 @@ function recordParagraph2(input) {
     carriesSectionBreak: carriesSectionBreak(input.paragraphXml)
   };
 }
+function isTextAtomicBlockSdt(sdtXml) {
+  const contentMatch = /<(?:[\w.-]+:)?sdtContent\b/iu.exec(sdtXml);
+  if (!contentMatch)
+    return false;
+  const properties = sdtXml.slice(0, contentMatch.index);
+  return /<(?:[\w.-]+:)?(?:checkbox|dropDownList)\b/iu.test(properties);
+}
 function blockSdtLockPolicy(sdtXml) {
   const properties = /<(?:[\w.-]+:)?sdtPr\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?sdtPr\s*>/.exec(sdtXml)?.[1];
   if (!properties)
@@ -165856,7 +165867,7 @@ function planDirectInlineEdit(paragraphBytes, startOffset, endOffset, newText, c
   if (tocPlan)
     return tocPlan;
   if (startOffset === endOffset) {
-    const beside = planCollapsedInsertBesideContainer(paragraphBytes, xml, model.pieces, startOffset, newText);
+    const beside = planCollapsedInsertBesideContainer(paragraphBytes, xml, model.pieces, startOffset, newText, collapsedInlineAffinity);
     if (beside)
       return beside;
   }
@@ -166330,19 +166341,22 @@ function planCollapsedInsert(paragraphBytes, xml, pieces, leaves, at, newText, t
     runPropertiesXml: carrier?.runProperties ?? paragraphMarkRPr
   };
 }
-function planCollapsedInsertBesideContainer(paragraphBytes, xml, pieces, at, newText) {
+function planCollapsedInsertBesideContainer(paragraphBytes, xml, pieces, at, newText, collapsedInlineAffinity) {
   if (newText.length === 0)
     return null;
   for (const piece of pieces) {
     if (piece.kind !== "container")
       continue;
-    if (piece.containerKind !== "hyperlink" && piece.containerKind !== "fldSimple")
+    if (piece.containerKind !== "hyperlink" && piece.containerKind !== "fldSimple" && piece.containerKind !== "sdt")
       continue;
     if (piece.visibleEnd <= piece.visibleStart)
       continue;
     const atLeading = piece.visibleStart === at && !hasVisibleSiblingEndingAt(pieces, at);
     const atTrailing = piece.visibleEnd === at && !hasVisibleSiblingStartingAt(pieces, at);
-    if (!atLeading && !atTrailing)
+    const isSdt = piece.containerKind === "sdt";
+    const leading = isSdt ? piece.visibleStart === at && collapsedInlineAffinity === "upstream" : atLeading;
+    const trailing = isSdt ? piece.visibleEnd === at && collapsedInlineAffinity === "downstream" : atTrailing;
+    if (!leading && !trailing)
       continue;
     const blocked = findBlockingPiece(pieces, at, at);
     if (blocked)
@@ -166354,7 +166368,7 @@ function planCollapsedInsertBesideContainer(paragraphBytes, xml, pieces, at, new
     const freshRunQnames = paragraphRunQnames(xml);
     if (!freshRunQnames)
       return { ok: false, reason: "invalid-range" };
-    const insertByte = atLeading ? Math.min(piece.byteStart, ...leadingRangeStarts.map((marker) => marker.runByteStart ?? marker.byteStart)) : Math.max(piece.byteEnd, ...trailingRangeEnds.map((marker) => marker.runByteEnd ?? marker.byteEnd));
+    const insertByte = leading ? Math.min(piece.byteStart, ...leadingRangeStarts.map((marker) => marker.runByteStart ?? marker.byteStart)) : Math.max(piece.byteEnd, ...trailingRangeEnds.map((marker) => marker.runByteEnd ?? marker.byteEnd));
     const op = {
       start: insertByte,
       end: insertByte,
@@ -166363,7 +166377,8 @@ function planCollapsedInsertBesideContainer(paragraphBytes, xml, pieces, at, new
     return {
       ok: true,
       bytes: spliceBytes(paragraphBytes, [op]),
-      runPropertiesXml: paragraphMarkRPr
+      runPropertiesXml: paragraphMarkRPr,
+      ...isSdt ? { requiresCollaborationSessionSync: true } : {}
     };
   }
   return null;
@@ -171992,6 +172007,7 @@ function isTerminalDeletionOfPendingFullParagraphInsertion(fragment3, entries) {
 }
 function collectTextCandidates(lookupContext, partXml, entries, storyId) {
   const out = [];
+  const bookmarkGroups = collectBookmarkRevisionGroups(entries.filter((entry) => entry.type === "insertion").flatMap((entry) => entry.fragments), partXml);
   for (const entry of entries) {
     if (entry.type !== "insertion" || entry.subtype !== "text-insertion")
       continue;
@@ -172003,6 +172019,8 @@ function collectTextCandidates(lookupContext, partXml, entries, storyId) {
       continue;
     if (entry.fragments.length === 0)
       continue;
+    if (entry.fragments.every((fragment3) => bookmarkGroups.has(fragment3)))
+      continue;
     if (!entry.fragments.every((fragment3) => fragment3.kind === "ins"))
       continue;
     let paragraphStart = null;
@@ -173852,6 +173870,7 @@ var init_review_groups = __esm(() => {
   init_structural_groups();
   init_numbering_catalog();
   init_field_paragraph_deletion_groups();
+  init_bookmark_revision_groups();
   init_field_paragraph_range_deletion_groups();
   init_image_paragraph_deletion_groups();
 });
@@ -194696,7 +194715,7 @@ var init_created_text_span_proof = __esm(() => {
 });
 
 // ../../../v2/editor-core/dist/document/transactions/content-locked-block-sdt.js
-function isParagraphInsideContentLockedBlockSdt(state, address2) {
+function isParagraphInsideNonEditableBlockSdt(state, address2) {
   const index = address2.storyId === state.mainStoryId ? getMainParagraphIndexFromState(state) : getStoryParagraphIndexFromState(state, address2.storyId);
   const entry = index?.byParaId(address2.blockId);
   if (!entry || entry.directBodyChildOrdinal != null || entry.containingBodyChildOrdinal == null) {
@@ -194711,7 +194730,7 @@ function isParagraphInsideContentLockedBlockSdt(state, address2) {
     return false;
   const map3 = buildStructuralBoundaryMap(scanBytes);
   const context = map3.byBlockId(entry.blockId) ?? map3.contexts[entry.ordinal - (chunk?.scanParagraphStartOrdinal ?? 0)] ?? null;
-  return context?.hasContentLockedBlockSdt === true;
+  return context?.hasContentLockedBlockSdt === true || context?.hasTextAtomicBlockSdt === true;
 }
 function provesNoSdtCarrier(bytes) {
   if (bytes.length === 0 || bytes.includes(0))
@@ -198895,7 +198914,7 @@ function runEditTextCommit(input) {
       return rejected2(txId, "unsupported-context");
     return rejected2(txId, classifyCrossBlockEditText(bytes, op));
   }
-  if (isParagraphInsideContentLockedBlockSdt(state, {
+  if (isParagraphInsideNonEditableBlockSdt(state, {
     storyId: op.on.storyId,
     partUri: op.on.partUri,
     blockId: op.on.startBlockId
@@ -198959,7 +198978,10 @@ function runDirectEditTextBatchCommit(input, edits) {
   for (const [blockId, blockEdits] of byBlock) {
     let blockUsedOverlapCompiler = false;
     const paragraph = index.byParaId(blockId);
-    if (!paragraph || index.duplicateParaIds.has(blockId) || paragraph.partUri !== partUri || paragraph.partRevision !== first.on.partRevision || paragraph.storyRevision !== first.on.storyRevision || isParagraphInsideContentLockedBlockSdt(state, { storyId, partUri, blockId })) {
+    if (isParagraphInsideNonEditableBlockSdt(state, { storyId, partUri, blockId })) {
+      return rejected2(txId, "text-range-in-sdt");
+    }
+    if (!paragraph || index.duplicateParaIds.has(blockId) || paragraph.partUri !== partUri || paragraph.partRevision !== first.on.partRevision || paragraph.storyRevision !== first.on.storyRevision) {
       return rejected2(txId, "patch-precondition-failed");
     }
     for (const edit of blockEdits) {
@@ -199378,7 +199400,10 @@ function runTrackedEditTextBatchCommit(input, edits) {
   let requiresCollaborationSessionSync = false;
   for (const [blockId, blockEdits] of byBlock) {
     const paragraph = index.byParaId(blockId);
-    if (!paragraph || index.duplicateParaIds.has(blockId) || paragraph.partUri !== partUri || paragraph.partRevision !== first.on.partRevision || paragraph.storyRevision !== first.on.storyRevision || isParagraphInsideContentLockedBlockSdt(state, { storyId, partUri, blockId })) {
+    if (isParagraphInsideNonEditableBlockSdt(state, { storyId, partUri, blockId })) {
+      return rejected2(txId, "text-range-in-sdt");
+    }
+    if (!paragraph || index.duplicateParaIds.has(blockId) || paragraph.partUri !== partUri || paragraph.partRevision !== first.on.partRevision || paragraph.storyRevision !== first.on.storyRevision) {
       return rejected2(txId, "patch-precondition-failed");
     }
     for (const edit of blockEdits) {
@@ -199774,7 +199799,7 @@ function runInsertInlineControlCommit(input) {
   if (op.on.startByte < 0 || op.on.endByte > bytes.length || op.on.startByte > op.on.endByte) {
     return rejected2(txId, "invalid-range");
   }
-  if (isParagraphInsideContentLockedBlockSdt(state, {
+  if (isParagraphInsideNonEditableBlockSdt(state, {
     storyId: op.on.storyId,
     partUri: op.on.partUri,
     blockId: op.on.startBlockId
@@ -217912,6 +217937,45 @@ function collectFieldChar(fieldChars, { tag, start, end }) {
     locked: lock === "true" || lock === "1" || lock === "on"
   });
 }
+function createFieldTokenCollector(fieldChars, instructionTokens) {
+  const instructionContexts = [];
+  return {
+    onOpenTag({ tag, start, end, namespaceBindings }) {
+      const parent = instructionContexts.at(-1);
+      const inWordRun = parent?.inWordRun ?? false;
+      const isWord = tag.namespaceUri === NS_W || tag.namespaceUri === NS_WSTRICT;
+      const isMce = tag.namespaceUri === NS_MC;
+      const isRunProxy = isMce && (tag.localName === "AlternateContent" || tag.localName === "Choice" || tag.localName === "Fallback");
+      const context = {
+        inWordRun: isWord && tag.localName === "r" || isRunProxy && inWordRun,
+        deleted: (parent?.deleted ?? false) || isWord && (tag.localName === "del" || tag.localName === "moveFrom"),
+        effective: parent?.effective ?? true,
+        choiceSelected: isMce && tag.localName === "AlternateContent" ? false : undefined
+      };
+      if (isMce && parent?.choiceSelected != null) {
+        if (tag.localName === "Choice") {
+          const requires = readXmlAttribute(tag, "", "Requires")?.value.trim().split(/\s+/).filter(Boolean) ?? [];
+          const selected = !parent.choiceSelected && requires.length > 0 && requires.every((prefix) => UNDERSTOOD_FIELD_INSTRUCTION_NAMESPACES.has(namespaceBindings[prefix] ?? ""));
+          context.effective && (context.effective = selected);
+          if (selected)
+            parent.choiceSelected = true;
+        } else if (tag.localName === "Fallback") {
+          context.effective && (context.effective = !parent.choiceSelected);
+        }
+      }
+      instructionContexts.push(context);
+      if (!isWord)
+        return;
+      if (tag.localName === "tab" && inWordRun && !context.deleted && context.effective) {
+        instructionTokens.push({ start, text: "\t", inlineTab: true });
+      }
+      collectFieldChar(fieldChars, { tag, start, end, namespaceBindings });
+    },
+    onCloseTag() {
+      instructionContexts.pop();
+    }
+  };
+}
 function buildFieldCatalogFromXml(input, xml, utf8Offsets) {
   let paragraphScan = input.sharedParagraphScan ?? null;
   const ownerResolution = {
@@ -217976,12 +218040,29 @@ function buildFieldCatalogFromXml(input, xml, utf8Offsets) {
   }
   const discovered = [];
   const fieldChars = input.preparedFieldChars ?? discovered;
+  const instructionTokens = [...input.preparedInstructionTokens ?? []];
   if (input.preparedFieldChars === undefined && /<(?:[\w.-]+:)?fldChar\b/.test(xml)) {
-    walkXmlElements(xml, { onOpenTag: (event) => collectFieldChar(discovered, event) });
+    walkXmlElements(xml, createFieldTokenCollector(discovered, instructionTokens));
+  }
+  if (fieldChars.length > 0) {
+    const instrTextRe = /<[\w.-]+:instrText\b[^>]*>([\s\S]*?)<\/[\w.-]+:instrText>/g;
+    for (let match = instrTextRe.exec(xml);match; match = instrTextRe.exec(xml)) {
+      instructionTokens.push({ start: match.index, text: decodeXmlText(match[1]) });
+    }
+    instructionTokens.sort((left, right) => left.start - right.start);
   }
-  const instrTextRe = /<([\w.-]+):instrText\b[^>]*>([\s\S]*?)<\/[\w.-]+:instrText>/g;
+  let instructionIndex = 0;
   const stack = [];
   for (const marker of fieldChars) {
+    while (instructionIndex < instructionTokens.length && instructionTokens[instructionIndex].start < marker.start) {
+      const token = instructionTokens[instructionIndex++];
+      if (token.inlineTab && stack.at(-1)?.separateAt != null)
+        continue;
+      for (const frame of stack) {
+        if (frame.separateAt == null)
+          frame.instructionFragments.push(token.text);
+      }
+    }
     const charType = marker.type;
     const matchStart = marker.start;
     const matchEnd = marker.end;
@@ -218016,16 +218097,7 @@ function buildFieldCatalogFromXml(input, xml, utf8Offsets) {
       const fieldEnd = endEnclosingRunEnd;
       const resultStart = frame.resultStartOffset ?? fieldEnd;
       const resultEnd = Math.max(resultStart, enclosingRunStart(xml, matchStart));
-      const instrSpanStart = frame.beginOffset;
-      const instrSpanEnd = frame.separateAt ?? matchStart;
-      const instrSlice = xml.slice(instrSpanStart, instrSpanEnd);
-      const instrTextParts = [];
-      let instrM;
-      const instrLocal = new RegExp(instrTextRe.source, "g");
-      while ((instrM = instrLocal.exec(instrSlice)) != null) {
-        instrTextParts.push(decodeXmlText(instrM[2] ?? ""));
-      }
-      const instructionText = instrTextParts.join("").trim();
+      const instructionText = frame.instructionFragments.join("").trim();
       const resultText = frame.separateAt != null ? extractText(xml.slice(resultStart, resultEnd)) : "";
       const paraId = enclosingParaId(frame.beginOffset);
       const byteStart = byteOffsetAt3(utf8Offsets, fieldStart);
@@ -218539,12 +218611,13 @@ async function buildFieldCatalogForStoryCooperatively(input) {
       }
     }
     const preparedFieldChars = [];
+    const preparedInstructionTokens = [];
     if (/<(?:[\w.-]+:)?fldChar\b/.test(decoded.xml)) {
       let aborted2 = false;
       let yieldFailed = false;
       let yieldError;
       await walkXmlElementsCooperatively(decoded.xml, {
-        onOpenTag: (event) => collectFieldChar(preparedFieldChars, event),
+        ...createFieldTokenCollector(preparedFieldChars, preparedInstructionTokens),
         yieldPoint: async () => {
           let current;
           try {
@@ -218576,6 +218649,7 @@ async function buildFieldCatalogForStoryCooperatively(input) {
       storyId: input.storyId,
       partUri: input.partUri,
       preparedFieldChars,
+      preparedInstructionTokens,
       ...paragraphOwnerResolver ? { paragraphOwnerResolver } : { sharedParagraphScan }
     }, decoded.xml, utf8Offsets);
     catalog.ownerResolution.packedRejectionReason = ownerDiagnostics.rejectionReason;
@@ -218606,7 +218680,7 @@ function listFieldCatalogsForState(state) {
   }
   return out;
 }
-var TD53, UTF8_OFFSET_CHECKPOINT_STRIDE = 256, FIELD_CANDIDATE_BYTES, FIELD_CANDIDATE_SEARCHES, STATE_CACHE2, STATE_IN_FLIGHT, DECODED_PART_IN_FLIGHT;
+var TD53, UTF8_OFFSET_CHECKPOINT_STRIDE = 256, UNDERSTOOD_FIELD_INSTRUCTION_NAMESPACES, FIELD_CANDIDATE_BYTES, FIELD_CANDIDATE_SEARCHES, STATE_CACHE2, STATE_IN_FLIGHT, DECODED_PART_IN_FLIGHT;
 var init_field_catalog = __esm(() => {
   init_sd_document_state();
   init_xml_text();
@@ -218615,6 +218689,7 @@ var init_field_catalog = __esm(() => {
   init_part_wml_scan_cache();
   init_field_paragraph_owner();
   TD53 = new TextDecoder;
+  UNDERSTOOD_FIELD_INSTRUCTION_NAMESPACES = new Set([NS_W, NS_WSTRICT, NS_W14]);
   FIELD_CANDIDATE_BYTES = [["fldSimple", 3], ["fldChar", 3], ["instrText", 7]];
   FIELD_CANDIDATE_SEARCHES = FIELD_CANDIDATE_BYTES.map(([token, anchorOffset]) => ({
     token: new TextEncoder().encode(token),
@@ -224191,11 +224266,11 @@ function runTrackedTextMoveCommit(input) {
   if (source.value.entry.storyId !== input.state.mainStoryId) {
     return rejected10(input.txId, "tracked-text-move-cross-story");
   }
-  if (isParagraphInsideContentLockedBlockSdt(input.state, {
+  if (isParagraphInsideNonEditableBlockSdt(input.state, {
     storyId: source.value.entry.storyId,
     partUri: source.value.entry.partUri,
     blockId: source.value.entry.blockId
-  }) || isParagraphInsideContentLockedBlockSdt(input.state, {
+  }) || isParagraphInsideNonEditableBlockSdt(input.state, {
     storyId: destination.entry.storyId,
     partUri: destination.entry.partUri,
     blockId: destination.entry.blockId
@@ -290292,6 +290367,107 @@ var init_section_xml = __esm(() => {
   SECTPR_CHILD_RANK = new Map(SECTPR_CHILD_ORDER.map((name, index) => [name, index]));
 });
 
+// ../../../v2/document-api-v2-adapter/dist/formatting/paragraph-property-order.js
+function setParagraphPropertyChild(children2, localName2, xml) {
+  const parsed = parseSingleElement(xml);
+  const existingIndex = children2.findIndex((child) => child.localName === localName2);
+  if (existingIndex >= 0) {
+    const next = [...children2];
+    next[existingIndex] = parsed;
+    return next;
+  }
+  const targetRank = PARAGRAPH_PROPERTY_CHILD_RANK.get(localName2);
+  if (targetRank == null)
+    throw new Error(`Unknown paragraph property child: ${localName2}`);
+  let insertionIndex = 0;
+  for (const [index, child] of children2.entries()) {
+    const childRank = paragraphPropertyRankRange(child);
+    if (!childRank)
+      continue;
+    if (childRank.minimum > targetRank) {
+      return [...children2.slice(0, index), parsed, ...children2.slice(index)];
+    }
+    if (childRank.maximum >= targetRank) {
+      throw new ParagraphPropertyMutationUnavailableError(`Cannot safely insert w:${localName2} within mc:AlternateContent paragraph properties`);
+    }
+    insertionIndex = index + 1;
+  }
+  return [...children2.slice(0, insertionIndex), parsed, ...children2.slice(insertionIndex)];
+}
+function paragraphPropertyRankRange(child) {
+  const directRank = PARAGRAPH_PROPERTY_CHILD_RANK.get(child.localName);
+  if (directRank != null)
+    return { minimum: directRank, maximum: directRank };
+  if (child.localName !== "AlternateContent")
+    return null;
+  const alternateContent = parseContainerXml(child.xml, "AlternateContent");
+  if (!alternateContent)
+    return null;
+  const ranks = parseTopLevelChildren(alternateContent.inner).flatMap((branch) => {
+    if (branch.localName !== "Choice" && branch.localName !== "Fallback")
+      return [];
+    const branchContainer = parseContainerXml(branch.xml, branch.localName);
+    if (!branchContainer)
+      return [];
+    return parseTopLevelChildren(branchContainer.inner).flatMap((candidate2) => {
+      const range = paragraphPropertyRankRange(candidate2);
+      return range ? [range.minimum, range.maximum] : [];
+    });
+  });
+  if (ranks.length === 0)
+    return null;
+  return { minimum: Math.min(...ranks), maximum: Math.max(...ranks) };
+}
+var PARAGRAPH_PROPERTY_CHILD_ORDER, PARAGRAPH_PROPERTY_CHILD_RANK, ParagraphPropertyMutationUnavailableError;
+var init_paragraph_property_order = __esm(() => {
+  init_common();
+  PARAGRAPH_PROPERTY_CHILD_ORDER = [
+    "pStyle",
+    "keepNext",
+    "keepLines",
+    "pageBreakBefore",
+    "framePr",
+    "widowControl",
+    "numPr",
+    "suppressLineNumbers",
+    "pBdr",
+    "shd",
+    "tabs",
+    "suppressAutoHyphens",
+    "kinsoku",
+    "wordWrap",
+    "overflowPunct",
+    "topLinePunct",
+    "autoSpaceDE",
+    "autoSpaceDN",
+    "bidi",
+    "adjustRightInd",
+    "snapToGrid",
+    "spacing",
+    "ind",
+    "contextualSpacing",
+    "mirrorIndents",
+    "suppressOverlap",
+    "jc",
+    "textDirection",
+    "textAlignment",
+    "textboxTightWrap",
+    "outlineLvl",
+    "divId",
+    "cnfStyle",
+    "rPr",
+    "sectPr",
+    "pPrChange"
+  ];
+  PARAGRAPH_PROPERTY_CHILD_RANK = new Map(PARAGRAPH_PROPERTY_CHILD_ORDER.map((name, index) => [name, index]));
+  ParagraphPropertyMutationUnavailableError = class ParagraphPropertyMutationUnavailableError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ParagraphPropertyMutationUnavailableError";
+    }
+  };
+});
+
 // ../../../v2/document-api-v2-adapter/dist/references/date-time-field.js
 function readDateTimePictureSwitch(instruction) {
   return /\\@\s+"([^"]*)"/u.exec(instruction)?.[1] ?? null;
@@ -292099,17 +292275,18 @@ function buildTocFieldBodyXml(context, instruction, options) {
   return buildComplexFieldXml(instruction, buildTocFieldResultXml(context, instruction, options));
 }
 function buildTocFieldResultXml(context, instruction, options) {
-  if (shouldUseV1EmptyTocSourceSet(instruction)) {
-    return buildTextRunXml("No table of contents entries found.");
-  }
-  const entries = buildTocEntries(context, instruction, options?.currentField, options?.preservedTocPages, options?.tocBookmarkNames);
+  return buildTocFieldResult(context, instruction, options).xml;
+}
+function buildTocFieldResult(context, instruction, options) {
+  const emptyText = shouldUseV1EmptyTocSourceSet(instruction) ? "No table of contents entries found." : "";
+  const entries = emptyText ? [] : buildTocEntries(context, instruction, options?.currentField, options?.preservedTocPages, options?.tocBookmarkNames);
   if (options?.currentField) {
-    return buildTocResultXmlPreservingParagraphs(context, instruction, entries, options.currentField);
+    return buildTocResultXmlPreservingParagraphs(context, instruction, entries, options.currentField, emptyText);
   }
-  return buildTocResultRunsXml(instruction, entries);
+  return { xml: emptyText ? buildTextRunXml(emptyText) : buildTocResultRunsXml(instruction, entries) };
 }
 function buildTocFieldXml(context, instruction, options) {
-  const contentXml = options?.currentField && options.preserveParagraphs ? buildTocFieldBodyXml(context, instruction, options) : buildNewTocFieldContentXml(context, instruction, options?.seedParagraph, options?.currentField, options?.preservedTocPages, options?.reservedParaIds, options?.tocBookmarkNames);
+  const contentXml = options?.currentField && options.preserveParagraphs ? buildTocFieldBodyXml(context, instruction, options) : buildNewTocFieldContentXml(context, instruction, options?.seedParagraph, options?.currentField, options?.preservedTocPages, options?.reservedParaIds, options?.tocBookmarkNames, options?.insertionByteStart);
   if (options?.bare)
     return contentXml;
   return "<w:sdt>" + "<w:sdtPr>" + "<w:docPartObj>" + '<w:docPartGallery w:val="Table of Contents"/>' + "<w:docPartUnique/>" + "</w:docPartObj>" + "</w:sdtPr>" + "<w:sdtContent>" + contentXml + "</w:sdtContent>" + "</w:sdt>";
@@ -292496,28 +292673,8 @@ function prepareTocSdtReplacement(context, entry, instruction, tocBookmarkNames)
     afterXml: buildNewTocFieldContentXml(context, instruction, paragraph2, entry, preservedTocPages, reservedParaIds, tocBookmarkNames)
   };
 }
-function replaceTocSdtXml(context, entry, instruction, txIdPrefix) {
-  const prepared = prepareTocSdtReplacement(context, entry, instruction);
-  if (!prepared.ok)
-    return prepared;
-  const nextBytes = spliceBytes3(prepared.bytes, prepared.byteStart, prepared.byteEnd, encodeXml(prepared.afterXml));
-  return commitKernelStorySurfacePatch({
-    context,
-    txIdPrefix,
-    perPart: { [entry.partUri]: replaceWholePartEntry(prepared.bytes, nextBytes) },
-    storyIds: [entry.storyId],
-    signalLanesToRebuild: ["paragraphIndex", "headings", "noteAnchorRefs"]
-  });
-}
 function replaceTocXml(context, entry, instruction, txIdPrefix) {
-  const sdtReplacement = replaceTocSdtXml(context, entry, instruction, txIdPrefix);
-  if (sdtReplacement.ok || sdtReplacement.message !== "Unable to locate the containing TOC content control.") {
-    return sdtReplacement;
-  }
-  return replaceBareTocFieldXml(context, entry, instruction, txIdPrefix);
-}
-function replaceBareTocFieldXml(context, entry, instruction, txIdPrefix) {
-  const prepared = prepareBareTocFieldReplacement(context, entry, instruction);
+  const prepared = prepareTocReplacement(context, entry, instruction);
   if (!prepared.ok)
     return prepared;
   const nextBytes = spliceBytes3(prepared.bytes, prepared.byteStart, prepared.byteEnd, encodeXml(prepared.afterXml));
@@ -292529,6 +292686,10 @@ function replaceBareTocFieldXml(context, entry, instruction, txIdPrefix) {
     signalLanesToRebuild: ["paragraphIndex", "headings", "noteAnchorRefs"]
   });
 }
+function prepareTocReplacement(context, entry, instruction, tocBookmarkNames) {
+  const sdt = prepareTocSdtReplacement(context, entry, instruction, tocBookmarkNames);
+  return !sdt.ok && sdt.message === "Unable to locate the containing TOC content control." ? prepareBareTocFieldReplacement(context, entry, instruction, tocBookmarkNames) : sdt;
+}
 function prepareBareTocReplacement(context, entry, instruction, tocBookmarkNames) {
   const prepared = prepareBareTocFieldReplacement(context, entry, instruction, tocBookmarkNames);
   if (!prepared.ok)
@@ -292568,18 +292729,112 @@ function prepareBareTocFieldReplacement(context, entry, instruction, tocBookmark
   }
   const xml = TD83.decode(bytes);
   const preservedTocPages = readPreservedTocPagesFromPartXml(xml);
-  const nextFieldXml = shouldUseV1EmptyTocSourceSet(instruction) ? buildComplexFieldXml(instruction, buildTextRunXml("No table of contents entries found.")) : buildTocFieldBodyXml(context, instruction, { currentField: entry, preservedTocPages, tocBookmarkNames });
+  const result = buildTocFieldResult(context, instruction, { currentField: entry, preservedTocPages, tocBookmarkNames });
+  const nextFieldXml = buildComplexFieldXml(instruction, result.xml);
+  const fieldStartChar = TD83.decode(bytes.subarray(0, entry.descriptor.byteStart)).length;
+  const fieldEndChar = TD83.decode(bytes.subarray(0, entry.descriptor.byteEnd)).length;
+  const paragraphStart = findEnclosingParagraphStart(xml, fieldStartChar, 0);
+  const paragraphOpenEnd = paragraphStart >= 0 ? findXmlTagEnd4(xml, paragraphStart + 1) : -1;
+  const paragraphCloseStart = xml.indexOf("</w:p>", fieldStartChar);
+  const paragraphPropertiesStart = paragraphOpenEnd >= 0 ? skipXmlWhitespace(xml, paragraphOpenEnd) : -1;
+  const paragraphProperties = paragraphOpenEnd >= 0 ? matchLeadingElement(xml.slice(paragraphPropertiesStart, fieldStartChar), "pPr") : "";
+  const ownsFirstParagraph = entry.descriptor.complete && paragraphOpenEnd >= 0 && paragraphCloseStart >= fieldStartChar && readTocParagraphLevel(paragraphProperties) != null && xml.slice(paragraphPropertiesStart + paragraphProperties.length, fieldStartChar).trim() === "" && (fieldEndChar >= paragraphCloseStart || xml.slice(fieldEndChar, paragraphCloseStart).trim() === "");
+  const replaceParagraphProperties = ownsFirstParagraph && result.firstParagraphProperties != null;
+  const byteStart = replaceParagraphProperties ? encodeXml(xml.slice(0, paragraphOpenEnd)).length : entry.descriptor.byteStart;
+  const nextParagraphProperties = replaceParagraphProperties ? preserveTocOwnerProperties(result.firstParagraphProperties, paragraphProperties) : "";
+  const afterXml = nextParagraphProperties + nextFieldXml;
+  const nextXml = TD83.decode(spliceBytes3(bytes, byteStart, entry.descriptor.byteEnd, encodeXml(afterXml)));
+  if (collectXmlElementRanges(nextXml).errors.length > 0) {
+    return {
+      ok: false,
+      code: "CAPABILITY_UNAVAILABLE",
+      message: "The bare TOC replacement crosses unsupported XML boundaries."
+    };
+  }
   return {
     ok: true,
     bytes,
-    byteStart: entry.descriptor.byteStart,
+    byteStart,
     byteEnd: entry.descriptor.byteEnd,
-    beforeXml: TD83.decode(bytes.subarray(entry.descriptor.byteStart, entry.descriptor.byteEnd)),
-    afterXml: nextFieldXml
+    beforeXml: TD83.decode(bytes.subarray(byteStart, entry.descriptor.byteEnd)),
+    afterXml
   };
 }
+function findDirectChild(xml, localName2) {
+  return scanDirectElementChildren(xml).find((child) => xmlLocalName(child.qname) === localName2);
+}
+function removeTocOwnerPropertiesFromTemplate(xml) {
+  const properties = matchLeadingElement(xml, "pPr") || findDirectChild(xml, "pPr")?.xml;
+  if (!properties)
+    return xml;
+  for (const child of scanDirectElementChildren(properties)) {
+    if (["rPr", "sectPr", "pPrChange"].includes(xmlLocalName(child.qname))) {
+      xml = xml.replace(child.xml, "");
+    }
+  }
+  return xml;
+}
+function preserveTocOwnerProperties(template, ownerProperties) {
+  const properties = removeTocOwnerPropertiesFromTemplate(template);
+  const retained = ["rPr", "sectPr", "pPrChange"].map((name) => {
+    const child = findDirectChild(ownerProperties, name);
+    return child ? inheritRunNamespaceDeclarations(child.xml, ownerProperties, ownerProperties.indexOf(child.xml), ownerProperties.slice(0, findXmlTagEnd4(ownerProperties, 1))) : "";
+  }).join("");
+  const insertAt = properties.lastIndexOf("</");
+  return properties.slice(0, insertAt) + retained + properties.slice(insertAt);
+}
+function removeTocSectionBoundaryFromTemplate(xml) {
+  const properties = matchLeadingElement(xml, "pPr") || findDirectChild(xml, "pPr")?.xml;
+  if (!properties)
+    return xml;
+  const section = findDirectChild(properties, "sectPr");
+  return section ? xml.replace(section.xml, "") : xml;
+}
+function readTocContinuationSectionPlacement(paragraphs, entryCount) {
+  const byEntryIndex = new Map;
+  const carriers = [];
+  for (const [index, paragraph2] of paragraphs.entries()) {
+    if (index === 0)
+      continue;
+    const properties = findDirectChild(paragraph2, "pPr");
+    if (!properties || !findDirectChild(properties.xml, "sectPr"))
+      continue;
+    if (index === paragraphs.length - 1) {
+      const lastEntryIndex = entryCount - 1;
+      if (readTocParagraphTemplateText(paragraph2) && lastEntryIndex > 0 && !byEntryIndex.has(lastEntryIndex) && carriers.length === 0) {
+        byEntryIndex.set(lastEntryIndex, paragraph2);
+      } else {
+        carriers.push(paragraph2);
+      }
+    } else if (index < entryCount) {
+      byEntryIndex.set(index, paragraph2);
+    } else {
+      carriers.push(paragraph2);
+    }
+  }
+  return { byEntryIndex, carriers };
+}
+function buildTocSectionOwnerParagraphOpen(template, owner) {
+  const openEnd = findXmlTagEnd4(template, 1);
+  const properties = inheritRunNamespaceDeclarations(template.slice(openEnd) || "<w:pPr></w:pPr>", template, openEnd, template.slice(0, openEnd));
+  const ownerProperties = findDirectChild(owner, "pPr").xml;
+  const retainedProperties = inheritRunNamespaceDeclarations(ownerProperties, owner, owner.indexOf(ownerProperties), readParagraphOpenTag(owner));
+  return readParagraphOpenTag(owner) + preserveTocOwnerProperties(properties, retainedProperties);
+}
+function preserveTocContinuationSectionOpen(template, index, sectionOwners, usedParaIds) {
+  const owner = sectionOwners.get(index);
+  const open2 = removeTocSectionBoundaryFromTemplate(template);
+  if (!owner)
+    return open2 === template ? open2 : removeTocOwnerPropertiesFromTemplate(template);
+  for (const id of collectParaIdsInXml(readParagraphOpenTag(owner)))
+    usedParaIds.delete(id);
+  return buildTocSectionOwnerParagraphOpen(open2, owner);
+}
+function buildTocSectionCarrierXml(owner) {
+  return buildTocSectionOwnerParagraphOpen("<w:p><w:pPr></w:pPr>", owner) + "</w:p>";
+}
 function shouldUseV1EmptyTocSourceSet(instruction) {
-  return parseQuotedSwitch(instruction, "t") != null && parseNumericSwitchRange(instruction, "o") == null && !/\\u\b/i.test(instruction) && parseQuotedSwitch(instruction, "f") == null && parseNumericSwitchRange(instruction, "l") == null;
+  return parseQuotedSwitch(instruction, "t") != null && parseNumericSwitchRange(instruction, "o") == null && !/\\u\b/i.test(instruction) && !parseTocTcSourceSelection(instruction).enabled;
 }
 function findLastSdtStart(xmlPrefix2) {
   let start = -1;
@@ -292873,6 +293128,104 @@ function resolveBookmarkSpanInParagraph(context, entry) {
     text: map3.visibleText().slice(startOffset, endOffset)
   };
 }
+function buildParagraphBookmarkMarkers(paragraph2, insertion, id) {
+  const namespace = insertion.fieldSource || paragraph2.namespaceBindings?.w !== WORDPROCESSINGML_NAMESPACE5 ? ` xmlns:w="${WORDPROCESSINGML_NAMESPACE5}"` : "";
+  return {
+    startXml: `<w:bookmarkStart${namespace} w:id="${xmlEscapeAttr(String(id))}" w:name="${xmlEscapeAttr(insertion.name)}"${insertion.tableColumn ? ` w:colFirst="${insertion.tableColumn.colFirst}" w:colLast="${insertion.tableColumn.colLast}"` : ""}/>`,
+    endXml: `<w:bookmarkEnd${namespace} w:id="${xmlEscapeAttr(String(id))}"/>`
+  };
+}
+function readBookmarkInsertionNamespaceBindings(paragraph2, insertion) {
+  if (!insertion.fieldSource)
+    return new Map(Object.entries(paragraph2.namespaceBindings ?? {}));
+  const relativeByte = insertion.fieldSource.byteStart - paragraph2.byteStart;
+  const charStart = TD83.decode(encodeXml(paragraph2.rawXml).subarray(0, relativeByte)).length;
+  const parsed = collectXmlElementRanges(paragraph2.rawXml, {
+    fragment: true,
+    additionalNamespaces: paragraph2.namespaceBindings
+  });
+  const parent = parsed.ranges.filter((range) => !range.tag.isSelfClosing && range.openEnd <= charStart && range.closeStart > charStart).sort((left, right) => right.start - left.start)[0];
+  return parsed.errors.length || !parent ? null : new Map(Object.entries(parent.namespaceBindings));
+}
+function canPlaceBookmarkAtFieldSource(paragraph2, fieldSource) {
+  return prepareBookmarkParagraphGroups([paragraph2], [{
+    blockId: paragraph2.blockId,
+    name: "_TocPlacement",
+    fieldSource,
+    startXml: `<w:bookmarkStart xmlns:w="${WORDPROCESSINGML_NAMESPACE5}" w:id="0" w:name="_TocPlacement"/>`,
+    endXml: `<w:bookmarkEnd xmlns:w="${WORDPROCESSINGML_NAMESPACE5}" w:id="0"/>`
+  }]) != null;
+}
+function prepareBookmarkParagraphGroups(paragraphs, insertions) {
+  const paragraphsById = new Map;
+  for (const paragraph2 of paragraphs) {
+    paragraphsById.set(paragraph2.blockId, paragraphsById.has(paragraph2.blockId) ? null : paragraph2);
+  }
+  const groups = new Map;
+  for (const insertion of insertions) {
+    if (!paragraphsById.get(insertion.blockId))
+      return null;
+    const group = groups.get(insertion.blockId) ?? [];
+    group.push(insertion);
+    groups.set(insertion.blockId, group);
+  }
+  const result = [];
+  for (const [blockId, group] of groups) {
+    const paragraph2 = paragraphsById.get(blockId);
+    const generic = group.filter((insertion) => !insertion.fieldSource);
+    if (generic.length > 1)
+      return null;
+    const parsed = collectXmlElementRanges(paragraph2.rawXml, {
+      fragment: true,
+      additionalNamespaces: paragraph2.namespaceBindings
+    });
+    const root = parsed.ranges.find((range) => range.start === 0 && range.end === paragraph2.rawXml.length);
+    if (parsed.errors.length || !root || root.tag.localName !== "p" || root.tag.namespaceUri !== WORDPROCESSINGML_NAMESPACE5)
+      return null;
+    const fields = group.filter((insertion) => insertion.fieldSource).sort((left, right) => right.fieldSource.byteStart - left.fieldSource.byteStart);
+    const original = encodeXml(paragraph2.rawXml);
+    let next = original;
+    let previousStart = paragraph2.byteEnd;
+    const keys = new Set;
+    for (const insertion of fields) {
+      const source = insertion.fieldSource;
+      if (keys.has(source.key) || !Number.isInteger(source.byteStart) || !Number.isInteger(source.byteEnd) || source.byteStart < paragraph2.byteStart || source.byteEnd > previousStart || source.byteEnd <= source.byteStart)
+        return null;
+      keys.add(source.key);
+      const start = source.byteStart - paragraph2.byteStart;
+      const end = source.byteEnd - paragraph2.byteStart;
+      const startChar = TD83.decode(original.subarray(0, start)).length;
+      const endChar = TD83.decode(original.subarray(0, end)).length;
+      if (encodeXml(paragraph2.rawXml.slice(0, startChar)).length !== start || encodeXml(paragraph2.rawXml.slice(0, endChar)).length !== end)
+        return null;
+      const first = parsed.ranges.find((range) => range.start === startChar && range.tag.namespaceUri === WORDPROCESSINGML_NAMESPACE5 && (range.tag.localName === "r" || range.tag.localName === "fldSimple"));
+      const last = parsed.ranges.find((range) => range.end === endChar && range.tag.namespaceUri === WORDPROCESSINGML_NAMESPACE5 && range.tag.localName === first?.tag.localName);
+      const parent = (range) => parsed.ranges.filter((candidate2) => candidate2.start < range.start && candidate2.end > range.end).sort((a, b) => b.start - a.start)[0];
+      if (!first || !last || first.start < root.openEnd || last.end > root.closeStart || parent(first)?.start !== parent(last)?.start || first.tag.localName === "fldSimple" && first !== last)
+        return null;
+      if (first.tag.localName === "r") {
+        const hasMarker = (run, kind) => parsed.ranges.some((range) => range.start >= run.start && range.end <= run.end && range.tag.namespaceUri === WORDPROCESSINGML_NAMESPACE5 && range.tag.localName === "fldChar" && range.tag.attributes.some((attribute) => attribute.namespaceUri === WORDPROCESSINGML_NAMESPACE5 && attribute.localName === "fldCharType" && attribute.value === kind));
+        if (!hasMarker(first, "begin") || !hasMarker(last, "end"))
+          return null;
+      }
+      next = spliceBytes3(next, end, end, encodeXml(insertion.endXml));
+      next = spliceBytes3(next, start, start, encodeXml(insertion.startXml));
+      previousStart = source.byteStart;
+    }
+    let xml = TD83.decode(next);
+    if (generic[0]) {
+      const withStart = injectParagraphPrefix(xml, generic[0].startXml);
+      const withEnd = withStart && injectParagraphSuffix(withStart, generic[0].endXml);
+      if (!withEnd)
+        return null;
+      xml = withEnd;
+    }
+    if (collectXmlElementRanges(xml, { fragment: true, additionalNamespaces: paragraph2.namespaceBindings }).errors.length)
+      return null;
+    result.push({ paragraph: paragraph2, xml });
+  }
+  return result;
+}
 function insertBookmarksIntoParagraphs(context, insertions, txIdPrefix) {
   if (insertions.length === 0) {
     return {
@@ -292881,59 +293234,46 @@ function insertBookmarksIntoParagraphs(context, insertions, txIdPrefix) {
       message: "At least one bookmark insertion is required."
     };
   }
-  const paragraphsByBlockId = new Map;
-  for (const paragraph2 of readBodyParagraphs(context)) {
-    paragraphsByBlockId.set(paragraph2.blockId, paragraphsByBlockId.has(paragraph2.blockId) ? null : paragraph2);
+  const paragraphs = readBodyParagraphs(context);
+  const paragraphGroups = new Map;
+  for (const paragraph2 of paragraphs) {
+    const group = paragraphGroups.get(paragraph2.blockId) ?? [];
+    group.push(paragraph2);
+    paragraphGroups.set(paragraph2.blockId, group);
   }
   const existingNames = new Set(readBookmarkEntries(context).map((entry) => entry.name));
-  const requestedBlockIds = new Set;
   const requestedNames = new Set;
-  const replacementsByPart = new Map;
-  const storyIds = new Set;
   const bookmarkIds = [];
   let nextBookmarkId = nextBookmarkNumericId(context);
+  const markers = [];
   for (const insertion of insertions) {
-    if (requestedBlockIds.has(insertion.blockId)) {
-      return {
-        ok: false,
-        code: "INVALID_TARGET",
-        message: `Paragraph "${insertion.blockId}" was requested more than once.`
-      };
-    }
     if (existingNames.has(insertion.name) || requestedNames.has(insertion.name)) {
-      return {
-        ok: false,
-        code: "INVALID_TARGET",
-        message: `Bookmark name "${insertion.name}" already exists.`
-      };
+      return { ok: false, code: "INVALID_TARGET", message: `Bookmark name "${insertion.name}" already exists.` };
     }
-    const paragraph2 = paragraphsByBlockId.get(insertion.blockId);
-    if (!paragraph2) {
+    const targets = paragraphGroups.get(insertion.blockId);
+    if (targets?.length !== 1)
       return {
         ok: false,
         code: "TARGET_NOT_FOUND",
         message: `Paragraph "${insertion.blockId}" was not found or is ambiguous.`
       };
-    }
     const bookmarkId = String(nextBookmarkId++);
-    const startFragment = `<w:bookmarkStart w:id="${xmlEscapeAttr(bookmarkId)}" w:name="${xmlEscapeAttr(insertion.name)}"${insertion.tableColumn ? ` w:colFirst="${insertion.tableColumn.colFirst}" w:colLast="${insertion.tableColumn.colLast}"` : ""}/>`;
-    const endFragment = `<w:bookmarkEnd w:id="${xmlEscapeAttr(bookmarkId)}"/>`;
-    const withStart = injectParagraphPrefix(paragraph2.rawXml, startFragment);
-    const withEnd = withStart ? injectParagraphSuffix(withStart, endFragment) : null;
-    if (!withEnd) {
-      return {
-        ok: false,
-        code: "INTERNAL_ERROR",
-        message: `Unable to inject bookmark markup into paragraph "${insertion.blockId}".`
-      };
-    }
+    markers.push({ ...insertion, ...buildParagraphBookmarkMarkers(targets[0], insertion, bookmarkId) });
+    bookmarkIds.push(bookmarkId);
+    requestedNames.add(insertion.name);
+  }
+  const prepared = prepareBookmarkParagraphGroups(paragraphs, markers);
+  if (!prepared)
+    return { ok: false, code: "INVALID_TARGET", message: "Bookmark targets have unavailable or unsupported paragraph or field boundaries." };
+  const replacementsByPart = new Map;
+  const storyIds = new Set;
+  const requestedBlockIds = new Set;
+  for (const { paragraph: paragraph2, xml } of prepared) {
     const replacements = replacementsByPart.get(paragraph2.partUri) ?? [];
-    replacements.push({ paragraph: paragraph2, bytes: encodeXml(withEnd) });
+    replacements.push({ paragraph: paragraph2, bytes: encodeXml(xml) });
     replacementsByPart.set(paragraph2.partUri, replacements);
     storyIds.add(paragraph2.storyId);
-    bookmarkIds.push(bookmarkId);
-    requestedBlockIds.add(insertion.blockId);
-    requestedNames.add(insertion.name);
+    requestedBlockIds.add(paragraph2.blockId);
   }
   const perPart = {};
   for (const [partUri, replacements] of replacementsByPart) {
@@ -293390,6 +293730,34 @@ function parseQuotedSwitch(instruction, flag) {
   const re = new RegExp(`\\\\${escapeRegExp15(flag)}\\s+"([^"]*)"`);
   return re.exec(instruction)?.[1];
 }
+function parseTocFieldIdentifier(instruction) {
+  return parseTocTcSourceSelection(instruction).identifier;
+}
+function parseTocTcSourceSelection(instruction) {
+  const tokens = instruction.match(/"[^"]*"|[^\s"]+/g) ?? [];
+  const fieldIndex = tokens.findIndex((token) => token.toLowerCase() === "\\f");
+  const levelIndex = tokens.findIndex((token) => token.toLowerCase() === "\\l");
+  const argument = (index) => {
+    const value2 = index < 0 ? undefined : tokens[index + 1];
+    if (value2 == null || value2.startsWith("\\"))
+      return;
+    return value2.startsWith('"') ? value2.slice(1, -1) : value2;
+  };
+  const identifier = argument(fieldIndex);
+  const levelArgument = argument(levelIndex);
+  const range = /^(\d+)-(\d+)$/.exec(levelArgument ?? "");
+  return {
+    enabled: fieldIndex >= 0 || levelIndex >= 0,
+    hasFieldSwitch: fieldIndex >= 0,
+    hasLevelSwitch: levelIndex >= 0,
+    ...identifier != null ? { identifier } : {},
+    ...levelArgument != null ? { levelArgument } : {},
+    ...range ? { levels: { from: Number(range[1]), to: Number(range[2]) } } : {}
+  };
+}
+function matchesTocTcSourceSelection(selection, entry) {
+  return selection.enabled && entry.text.length > 0 && (selection.identifier == null || (entry.tableIdentifier ?? "C") === selection.identifier) && (selection.levels == null || entry.level >= selection.levels.from && entry.level <= selection.levels.to);
+}
 function parseNumericSwitchRange(instruction, flag) {
   const re = new RegExp(`\\\\${escapeRegExp15(flag)}\\s+"?(\\d+)-(\\d+)"?`);
   const match = re.exec(instruction);
@@ -293771,16 +294139,26 @@ function buildTocResultRunsXml(instruction, entries) {
     return chunks.join("");
   }).join("");
 }
-function buildTocResultXmlPreservingParagraphs(context, instruction, entries, currentField) {
-  if (entries.length === 0)
-    return buildTextRunXml("");
+function buildTocResultXmlPreservingParagraphs(context, instruction, sourceEntries, currentField, emptyText = "") {
   const sourceParagraphs = readCurrentTocParagraphXmls(context, currentField, true);
-  const paragraphTemplates = buildTocParagraphTemplatesFromParagraphXml(sourceParagraphs.join(""));
+  const sectionPlacement = readTocContinuationSectionPlacement(sourceParagraphs, sourceEntries.length);
+  const sectionOwners = sectionPlacement.byEntryIndex;
+  if (sourceEntries.length === 0) {
+    const carriers = sectionPlacement.carriers.map(buildTocSectionCarrierXml);
+    return { xml: buildTextRunXml(emptyText) + (carriers.length ? `</w:p>${carriers.join("").slice(0, -6)}` : "") };
+  }
+  const paragraphTemplates = buildTocParagraphTemplatesFromParagraphXml([
+    removeTocOwnerPropertiesFromTemplate(sourceParagraphs[0] ?? ""),
+    ...sourceParagraphs.slice(1)
+  ].join(""));
   const entryRunPropertiesTemplates = readTocEntryRunPropertiesTemplates(context, currentField);
-  const entryRunProperties = resolveTocEntryRunProperties(entries, entryRunPropertiesTemplates);
+  const entryRunProperties = resolveTocEntryRunProperties(sourceEntries, entryRunPropertiesTemplates);
+  const entryParagraphOpens = resolveTocEntryParagraphOpens(sourceEntries, entryRunProperties, entryRunPropertiesTemplates, sourceParagraphs[0]);
+  const entries = sourceEntries.map((entry, index) => applyCachedTcEntrySeparator(entry, entryRunProperties[index]));
+  const withPageTab = createTocPageTabFallback(context, instruction, currentField.descriptor.byteStart);
   const documentParaIds = collectDocumentParaIds(context);
   const reusableParaIds = collectParaIdsInXml(sourceParagraphs.slice(1).join(""));
-  for (const id of collectParaIdsInXml(sourceParagraphs[0] ?? ""))
+  for (const id of collectParaIdsInXml((sourceParagraphs[0] ?? "") + [...sectionOwners.values(), ...sectionPlacement.carriers].join("")))
     reusableParaIds.delete(id);
   const usedParaIds = new Set(documentParaIds);
   const nextParaId = createUniqueParaIdAllocator(documentParaIds);
@@ -293797,31 +294175,47 @@ function buildTocResultXmlPreservingParagraphs(context, instruction, entries, cu
   }
   let xml = buildTocEntryRunsXml(instruction, entries[0], entryRunProperties[0]);
   for (const [index, entry] of entries.slice(1).entries()) {
-    const retained = remainingTemplates.get(`${normalizeTocLevel(entry.level)}:${normalizeTocEntryText(entry.text)}`)?.pop();
+    const retained = entryParagraphOpens[index + 1] ?? remainingTemplates.get(`${normalizeTocLevel(entry.level)}:${normalizeTocEntryText(entry.cachedParagraphText ?? entry.text)}`)?.pop();
     if (retained) {
       for (const id of collectParaIdsInXml(retained)) {
         if (reusableParaIds.delete(id))
           usedParaIds.delete(id);
       }
     }
-    xml += `</w:p>${dedupeParagraphOpenParaId(retained ?? buildTocContinuationParagraphOpen(entry, paragraphTemplates), usedParaIds, nextParaId)}` + buildTocEntryRunsXml(instruction, entry, entryRunProperties[index + 1]);
+    xml += `</w:p>${dedupeParagraphOpenParaId(preserveTocContinuationSectionOpen(withPageTab(retained ?? buildTocContinuationParagraphOpen(entry, paragraphTemplates), entry), index + 1, sectionOwners, usedParaIds), usedParaIds, nextParaId)}` + buildTocEntryRunsXml(instruction, entry, entryRunProperties[index + 1]);
   }
-  return xml;
+  for (const owner of sectionPlacement.carriers) {
+    xml += `</w:p>${buildTocSectionCarrierXml(owner).slice(0, -6)}`;
+  }
+  const firstParagraphOpen = removeTocSectionBoundaryFromTemplate(withPageTab(entryParagraphOpens[0] ?? buildTocContinuationParagraphOpen(entries[0], paragraphTemplates), entries[0]));
+  const firstParagraphOpenEnd = findXmlTagEnd4(firstParagraphOpen, 1);
+  return {
+    xml,
+    firstParagraphProperties: inheritRunNamespaceDeclarations(firstParagraphOpen.slice(firstParagraphOpenEnd), firstParagraphOpen, firstParagraphOpenEnd, firstParagraphOpen.slice(0, firstParagraphOpenEnd))
+  };
 }
-function buildNewTocFieldContentXml(context, instruction, seedParagraph, currentField, preservedTocPages, reservedParaIds, tocBookmarkNames) {
+function buildNewTocFieldContentXml(context, instruction, seedParagraph, currentField, preservedTocPages, reservedParaIds, tocBookmarkNames, insertionByteStart) {
   const useEmptyPlaceholder = shouldUseV1EmptyTocSourceSet(instruction);
   const paragraphs = readBodyParagraphs(context, { includeListState: false });
-  const entries = useEmptyPlaceholder ? [] : buildTocEntries(context, instruction, currentField, preservedTocPages, tocBookmarkNames, paragraphs);
-  const paragraphTemplates = readDocumentTocParagraphTemplates(paragraphs);
+  const sourceEntries = useEmptyPlaceholder ? [] : buildTocEntries(context, instruction, currentField, preservedTocPages, tocBookmarkNames, paragraphs);
+  const paragraphTemplates = readDocumentTocParagraphTemplates(paragraphs, currentField?.blockId);
   const entryRunPropertiesTemplates = readTocEntryRunPropertiesTemplates(context, currentField);
-  const entryRunProperties = resolveTocEntryRunProperties(entries, entryRunPropertiesTemplates);
+  const entryRunProperties = resolveTocEntryRunProperties(sourceEntries, entryRunPropertiesTemplates);
+  const entryParagraphOpens = resolveTocEntryParagraphOpens(sourceEntries, entryRunProperties, entryRunPropertiesTemplates, seedParagraph?.rawXml);
+  const entries = sourceEntries.map((entry, index) => applyCachedTcEntrySeparator(entry, entryRunProperties[index]));
+  const withPageTab = createTocPageTabFallback(context, instruction, currentField?.descriptor.byteStart ?? insertionByteStart ?? seedParagraph?.byteStart ?? 0);
+  const sectionPlacement = readTocContinuationSectionPlacement(currentField ? readCurrentTocParagraphXmls(context, currentField, true) : [], entries.length);
+  const sectionOwners = sectionPlacement.byEntryIndex;
+  const carriers = sectionPlacement.carriers.map(buildTocSectionCarrierXml);
   if (entries.length === 0) {
-    return buildGeneratedTocParagraphOpen(1, seedParagraph, paragraphTemplates) + '<w:r><w:fldChar w:fldCharType="begin" /></w:r>' + buildInstructionRunXml(instruction) + '<w:r><w:fldChar w:fldCharType="separate" /></w:r>' + buildTextRunXml(useEmptyPlaceholder ? "No table of contents entries found." : "") + '<w:r><w:fldChar w:fldCharType="end" /></w:r>' + "</w:p>";
+    return buildGeneratedTocParagraphOpen(1, seedParagraph, paragraphTemplates, undefined, currentField != null) + '<w:r><w:fldChar w:fldCharType="begin" /></w:r>' + buildInstructionRunXml(instruction) + '<w:r><w:fldChar w:fldCharType="separate" /></w:r>' + buildTextRunXml(useEmptyPlaceholder ? "No table of contents entries found." : "") + (carriers.length ? `</w:p>${carriers.join("").slice(0, -6)}` : "") + '<w:r><w:fldChar w:fldCharType="end" /></w:r>' + "</w:p>";
   }
   const documentParaIds = collectDocumentParaIds(context);
   const usedParaIds = new Set(reservedParaIds ?? []);
+  for (const id of collectParaIdsInXml([...sectionOwners.values(), ...sectionPlacement.carriers].join("")))
+    usedParaIds.add(id);
   const nextParaId = createUniqueParaIdAllocator(documentParaIds);
-  return entries.map((entry, index) => `${dedupeParagraphOpenParaId(index === 0 ? buildGeneratedTocParagraphOpen(entry.level, seedParagraph, paragraphTemplates, entry.text) : buildTocContinuationParagraphOpen(entry, paragraphTemplates), usedParaIds, nextParaId)}` + (index === 0 ? '<w:r><w:fldChar w:fldCharType="begin" /></w:r>' + buildInstructionRunXml(instruction) + '<w:r><w:fldChar w:fldCharType="separate" /></w:r>' : "") + buildTocEntryRunsXml(instruction, entry, entryRunProperties[index]) + (index === entries.length - 1 ? '<w:r><w:fldChar w:fldCharType="end" /></w:r>' : "") + "</w:p>").join("");
+  return entries.map((entry, index) => `${dedupeParagraphOpenParaId(withPageTab(index === 0 ? buildGeneratedTocParagraphOpen(entry.level, seedParagraph, paragraphTemplates, entry.cachedParagraphText ?? entry.text, currentField != null, entryParagraphOpens[index]) : currentField ? preserveTocContinuationSectionOpen(entryParagraphOpens[index] ?? buildTocContinuationParagraphOpen(entry, paragraphTemplates), index, sectionOwners, usedParaIds) : entryParagraphOpens[index] ?? buildTocContinuationParagraphOpen(entry, paragraphTemplates), entry), usedParaIds, nextParaId)}` + (index === 0 ? '<w:r><w:fldChar w:fldCharType="begin" /></w:r>' + buildInstructionRunXml(instruction) + '<w:r><w:fldChar w:fldCharType="separate" /></w:r>' : "") + buildTocEntryRunsXml(instruction, entry, entryRunProperties[index]) + (index === entries.length - 1 ? (carriers.length ? `</w:p>${carriers.join("").slice(0, -6)}` : "") + '<w:r><w:fldChar w:fldCharType="end" /></w:r>' : "") + "</w:p>").join("");
 }
 function collectDocumentParaIds(context) {
   const existing = new Set;
@@ -293889,7 +294283,8 @@ function buildTocEntryRunsXml(instruction, entry, entryRunProperties) {
 function buildTocEntries(context, instruction, currentField, preservedTocPages, tocBookmarkNames, paragraphs = readBodyParagraphs(context, { includeListState: false })) {
   const pages = estimateDocumentPages(context);
   const numberingMarkers = buildBodyParagraphNumberReferenceMap(context, paragraphs);
-  const tocBookmarks = buildBodyTocBookmarkMap(context);
+  const bodyBookmarks = readBookmarkEntries(context);
+  const tocBookmarks = buildBodyTocBookmarkMap(bodyBookmarks);
   if (tocBookmarkNames)
     for (const [key2, name] of tocBookmarkNames)
       tocBookmarks.set(key2, name);
@@ -293911,6 +294306,7 @@ function buildTocEntries(context, instruction, currentField, preservedTocPages,
     const bookmarkKey = bookmarkName ? normalizeTocBookmarkKey(bookmarkName) : undefined;
     const preservedPage = (bookmarkKey ? preservedPagesByBookmark.get(bookmarkKey) : undefined) ?? readPreservedTocPageByText(preservedPages, text);
     return {
+      sourceByteStart: paragraph2.byteStart,
       text,
       page: preservedPage ?? String(pages.displayPageByBlockId.get(paragraph2.blockId) ?? 1),
       level: derivedLevel,
@@ -293922,17 +294318,30 @@ function buildTocEntries(context, instruction, currentField, preservedTocPages,
       ...bookmarkName ? { bookmarkName } : {}
     };
   }).filter((entry) => entry != null).filter((entry) => entry.text.length > 0);
-  const tcIdentifier = parseQuotedSwitch(instruction, "f");
-  const tcLevels = parseNumericSwitchRange(instruction, "l");
-  const tcEntries = listCanonicalFieldEntries(context).filter((entry) => instructionKeyword(entry.descriptor.instructionText) === "TC").map((entry) => ({ entry, parsed: parseTocEntryInstruction(entry.descriptor.instructionText) })).filter(({ parsed }) => (tcIdentifier == null || parsed.tableIdentifier === tcIdentifier) && (tcLevels == null || parsed.level >= tcLevels.from && parsed.level <= tcLevels.to)).map(({ entry, parsed }) => {
-    const preservedPage = readPreservedTocPageByText(preservedPages, parsed.text);
+  const tcSelection = parseTocTcSourceSelection(instruction);
+  const bodyParagraphs = new Map(paragraphs.map((paragraph2) => [`${paragraph2.storyId}:${paragraph2.blockId}`, paragraph2]));
+  const tcFields = listCanonicalFieldEntries(context).filter((entry) => instructionKeyword(entry.descriptor.instructionText) === "TC").filter((entry) => bodyParagraphs.has(`${entry.storyId}:${entry.blockId}`));
+  const tcBookmarkNames = resolveTocTcBookmarkNames(bodyBookmarks, paragraphs, tcFields);
+  const tcEntries = tcFields.map((entry) => ({ entry, parsed: parseTocEntryInstruction(entry.descriptor.instructionText) })).filter(({ parsed }) => matchesTocTcSourceSelection(tcSelection, parsed)).map(({ entry, parsed }) => {
+    const text = parsed.text;
+    const separatorIndex = text.indexOf("\t");
+    const marker = separatorIndex > 0 ? text.slice(0, separatorIndex) : undefined;
+    const title = separatorIndex > 0 ? text.slice(separatorIndex + 1) : undefined;
+    const fieldKey = tocTcFieldSourceKey(entry);
+    const bookmarkName = tocBookmarkNames?.get(fieldKey) ?? tcBookmarkNames.get(fieldKey);
+    const bookmarkKey = bookmarkName ? normalizeTocBookmarkKey(bookmarkName) : undefined;
+    const preservedPage = (bookmarkKey ? preservedPagesByBookmark.get(bookmarkKey) : undefined) ?? readPreservedTocPageByText(preservedPages, text);
     return {
-      text: parsed.text,
+      sourceByteStart: entry.descriptor.byteStart,
+      text,
       page: preservedPage ?? String(pages.displayPageByBlockId.get(entry.blockId) ?? 1),
-      level: parsed.level
+      level: parsed.level,
+      isTcEntry: true,
+      ...marker && title ? { marker, title, markerSeparator: "tab" } : {},
+      ...bookmarkName ? { bookmarkName } : {}
     };
-  }).filter((entry) => entry.text.length > 0);
-  return [...headings, ...tcEntries];
+  });
+  return [...headings, ...tcEntries].sort((left, right) => left.sourceByteStart - right.sourceByteStart).map(({ sourceByteStart: _sourceByteStart, ...entry }) => entry);
 }
 function parseTocCustomStyles(instruction) {
   const raw = parseQuotedSwitch(instruction, "t");
@@ -293952,18 +294361,19 @@ function parseTocCustomStyles(instruction) {
 function normalizeStyleId(value2) {
   return value2.replace(/\s+/g, "").trim().toLowerCase();
 }
-function readDocumentTocParagraphTemplates(paragraphs) {
+function readDocumentTocParagraphTemplates(paragraphs, ownerBlockId) {
   const templates = emptyTocParagraphTemplates();
   for (const paragraph2 of paragraphs) {
     const level = readTocParagraphLevel(paragraph2.rawXml);
     if (level == null)
       continue;
-    const open2 = buildTocParagraphTemplateOpen(paragraph2.rawXml);
+    const open2 = buildTocParagraphTemplateOpen(paragraph2.blockId === ownerBlockId ? removeTocOwnerPropertiesFromTemplate(paragraph2.rawXml) : paragraph2.rawXml);
     if (!templates.byLevel.has(level))
       templates.byLevel.set(level, open2);
     const entryText = readTocParagraphTemplateText(paragraph2.rawXml);
-    if (entryText && !templates.byText.has(entryText))
-      templates.byText.set(entryText, open2);
+    const key2 = `${level}:${entryText}`;
+    if (entryText && !templates.byLevelAndText.has(key2))
+      templates.byLevelAndText.set(key2, open2);
   }
   return templates;
 }
@@ -293971,7 +294381,8 @@ function readTocEntryRunPropertiesTemplates(context, currentField) {
   const templates = {
     byBookmark: new Map,
     byText: new Map,
-    byLevel: new Map
+    byLevel: new Map,
+    paragraphByRunTemplate: new Map
   };
   if (!currentField)
     return templates;
@@ -293986,12 +294397,18 @@ function readTocEntryRunPropertiesTemplates(context, currentField) {
     const { runProperties } = visibleEntry;
     if (runProperties.length === 0)
       continue;
+    templates.paragraphByRunTemplate.set(runProperties, {
+      level,
+      open: buildTocParagraphTemplateOpen(paragraphXml)
+    });
     const hyperlinkXml = findFirstElement(paragraphXml, "hyperlink")?.xml ?? "";
     const hyperlinkBookmark = readXmlAttributeByLocalName(hyperlinkXml, "anchor");
     const bookmark = hyperlinkBookmark ? decodeXmlEntities2(hyperlinkBookmark) : readTocPageReferenceBookmarkName(paragraphXml);
     const bookmarkKey = bookmark ? normalizeTocBookmarkKey(bookmark) : "";
-    if (bookmarkKey && !templates.byBookmark.has(bookmarkKey)) {
-      templates.byBookmark.set(bookmarkKey, runProperties);
+    if (bookmarkKey) {
+      const byBookmark = templates.byBookmark.get(bookmarkKey) ?? [];
+      byBookmark.push(runProperties);
+      templates.byBookmark.set(bookmarkKey, byBookmark);
     }
     const entryText = readTocParagraphTemplateText(visibleEntry);
     if (entryText) {
@@ -294255,24 +294672,54 @@ function hasEnabledWebHidden(xml) {
 }
 function resolveTocEntryRunProperties(entries, templates) {
   const usedTemplates = new Set;
+  const bookmarkEntryCounts = new Map;
+  for (const entry of entries) {
+    if (!entry.bookmarkName)
+      continue;
+    const key2 = normalizeTocBookmarkKey(entry.bookmarkName);
+    bookmarkEntryCounts.set(key2, (bookmarkEntryCounts.get(key2) ?? 0) + 1);
+  }
   const byTextQueues = new Map([...templates.byText].map(([text, matches]) => [text, [...matches]]));
-  const takeByText = (text) => {
+  const takeByText = (text, accept) => {
     const queue = byTextQueues.get(text);
-    while (queue?.length) {
-      const candidate2 = queue.shift();
-      if (candidate2 && !usedTemplates.has(candidate2))
-        return candidate2;
-    }
-    return;
+    const index = queue?.findIndex((candidate2) => !usedTemplates.has(candidate2) && (!accept || accept(candidate2))) ?? -1;
+    return index >= 0 ? queue?.splice(index, 1)[0] : undefined;
   };
   const resolved = entries.map((entry) => {
     const bookmarkKey = entry.bookmarkName ? normalizeTocBookmarkKey(entry.bookmarkName) : "";
-    const byBookmark = bookmarkKey ? templates.byBookmark.get(bookmarkKey) : undefined;
-    const byText = byBookmark ? undefined : takeByText(normalizeTocEntryText(entry.text));
-    const match = byBookmark ?? byText;
-    if (match)
-      usedTemplates.add(match);
-    return match;
+    const bookmarkTemplates = bookmarkKey ? templates.byBookmark.get(bookmarkKey) : undefined;
+    const byBookmark = bookmarkEntryCounts.get(bookmarkKey) === 1 && bookmarkTemplates?.length === 1 ? bookmarkTemplates[0] : undefined;
+    if (byBookmark)
+      usedTemplates.add(byBookmark);
+    return byBookmark;
+  });
+  entries.forEach((entry, index) => {
+    if (resolved[index] || !entry.isTcEntry)
+      return;
+    const levelTemplates = templates.byLevel.get(normalizeTocLevel(entry.level));
+    const byText = takeByText(normalizeTocEntryText(entry.text), (template) => levelTemplates?.includes(template) === true && !template.some((run) => run.separator === "tab"));
+    if (!byText)
+      return;
+    resolved[index] = byText;
+    usedTemplates.add(byText);
+  });
+  entries.forEach((entry, index) => {
+    if (resolved[index] || !entry.isTcEntry)
+      return;
+    const cachedSeparatorTemplate = templates.byLevel.get(normalizeTocLevel(entry.level))?.find((template) => !usedTemplates.has(template) && applyCachedTcEntrySeparator(entry, template) !== entry);
+    if (!cachedSeparatorTemplate)
+      return;
+    resolved[index] = cachedSeparatorTemplate;
+    usedTemplates.add(cachedSeparatorTemplate);
+  });
+  entries.forEach((entry, index) => {
+    if (resolved[index])
+      return;
+    const byText = takeByText(normalizeTocEntryText(entry.text));
+    if (!byText)
+      return;
+    resolved[index] = byText;
+    usedTemplates.add(byText);
   });
   for (const level of new Set(entries.map((entry) => normalizeTocLevel(entry.level)))) {
     const entryIndexes = entries.map((entry, index) => normalizeTocLevel(entry.level) === level ? index : -1).filter((index) => index >= 0);
@@ -294308,6 +294755,49 @@ function resolveTocEntryRunProperties(entries, templates) {
   }
   return resolved;
 }
+function resolveTocEntryParagraphOpens(entries, runTemplates, templates, ownerParagraphXml) {
+  const ownerOpen = ownerParagraphXml ? buildTocParagraphTemplateOpen(ownerParagraphXml) : undefined;
+  return entries.map((entry, index) => {
+    const runs = runTemplates[index];
+    const paired = runs && templates.paragraphByRunTemplate.get(runs);
+    if (!paired || paired.level !== normalizeTocLevel(entry.level))
+      return;
+    return paired.open === ownerOpen ? removeTocOwnerPropertiesFromTemplate(paired.open) : paired.open;
+  });
+}
+function applyCachedTcEntrySeparator(entry, template) {
+  if (!entry.isTcEntry || !template || entry.text.includes("\t"))
+    return entry;
+  const separatorIndex = template.findIndex((run) => run.separator === "tab");
+  if (separatorIndex <= 0 || template.slice(separatorIndex + 1).some((run) => run.separator === "tab"))
+    return entry;
+  const cachedLabel = template.map((run) => run.separator === "tab" ? "\t" : run.text).join("");
+  const compactLabel = normalizeCompactTocEntryText(cachedLabel).replace(/\.$/, "");
+  if (compactLabel !== normalizeCompactTocEntryText(entry.text).replace(/\.$/, ""))
+    return entry;
+  const marker = normalizeTocEntryText(template.slice(0, separatorIndex).map((run) => run.text).join(""));
+  const compactMarker = normalizeCompactTocEntryText(marker);
+  if (!compactMarker || !normalizeCompactTocEntryText(entry.text).startsWith(compactMarker))
+    return entry;
+  let markerEnd = 0;
+  let remainingMarkerLength = compactMarker.length;
+  while (markerEnd < entry.text.length && remainingMarkerLength > 0) {
+    if (!/\s/.test(entry.text[markerEnd]))
+      remainingMarkerLength -= 1;
+    markerEnd += 1;
+  }
+  const title = entry.text.slice(markerEnd).trim();
+  if (!title)
+    return entry;
+  return {
+    ...entry,
+    text: joinMarkerAndText(marker, title),
+    marker,
+    title,
+    markerSeparator: "tab",
+    cachedParagraphText: cachedLabel
+  };
+}
 function readUnanimousTocTextTemplate(matchingTemplates) {
   const template = matchingTemplates?.[0];
   if (!template)
@@ -294340,16 +294830,61 @@ function readUniformTocLevelRunProperties(siblingTemplates) {
   return uniformRunProperties;
 }
 function buildTocContinuationParagraphOpen(entry, templates) {
-  return resolveTocParagraphOpen(entry.level, templates, entry.text);
+  return resolveTocParagraphOpen(entry.level, templates, entry.cachedParagraphText ?? entry.text);
+}
+function createTocPageTabFallback(context, instruction, fieldByteStart) {
+  if (/\\n\b/.test(instruction) || parseQuotedSwitch(instruction, "p") != null)
+    return (paragraphOpen) => paragraphOpen;
+  let model;
+  let position;
+  return (paragraphOpen, entry) => {
+    if (entry.markerSeparator === "tab" || entry.text.includes("\t"))
+      return paragraphOpen;
+    const properties = findDirectChild(paragraphOpen + "</w:p>", "pPr");
+    if (!properties || findDirectChild(properties.xml, "tabs") || findDirectChild(properties.xml, "AlternateContent"))
+      return paragraphOpen;
+    model ?? (model = compileWordStyleModel({
+      stylesXml: readStyleDefinitionsPartBytes(context),
+      settingsXml: readPartBytes2(context, "/word/settings.xml"),
+      numberingXml: readPartBytes2(context, "/word/numbering.xml")
+    }));
+    const style = findDirectChild(properties.xml, "pStyle");
+    const styleId = style ? readXmlAttributeByLocalName(style.xml, "val") : undefined;
+    if (model.resolveParagraph({ inlineProps: { styleId } }).tabStops?.length)
+      return paragraphOpen;
+    const container = parseContainerXml(properties.xml.replace(/\/>$/, `></${properties.qname}>`), "pPr");
+    if (!container)
+      return paragraphOpen;
+    if (position == null) {
+      const sections = readLiveSectionSignals(context);
+      const section = sections.find((candidate2) => fieldByteStart < candidate2.sectPr.rawXmlByteEnd) ?? sections.at(-1);
+      const setup = section?.pageSetup;
+      const width = (setup?.pageSize.widthTwips ?? 12240) - (setup?.margins.leftTwips ?? 1440) - (setup?.margins.rightTwips ?? 1440) - (setup?.margins.gutterTwips ?? 0);
+      const count = Math.max(1, section?.columns?.count ?? 1);
+      const columnWidth = section?.columns?.columns[0]?.widthTwips ?? (width - (count - 1) * (section?.columns?.spaceTwips ?? 720)) / count;
+      position = Math.max(0, Math.floor(columnWidth) - 10);
+    }
+    const prefix = container.prefix;
+    const tabs2 = `<${prefix}:tabs><${prefix}:tab ${prefix}:val="right" ${prefix}:leader="dot" ${prefix}:pos="${position}"/></${prefix}:tabs>`;
+    const children2 = setParagraphPropertyChild(parseTopLevelChildrenPreservingTrivia(container.inner), "tabs", tabs2);
+    return paragraphOpen.replace(properties.xml, () => container.open + serializeTopLevelChildren(children2) + container.close);
+  };
 }
-function buildGeneratedTocParagraphOpen(level, seedParagraph, templates, entryText) {
-  const template = resolveTocParagraphTemplate(level, templates, entryText);
-  if (template)
+function buildGeneratedTocParagraphOpen(level, seedParagraph, templates, entryText, retainOwner = false, pairedTemplate) {
+  const template = pairedTemplate ?? resolveTocParagraphTemplate(level, templates, entryText);
+  if (template && !(retainOwner && seedParagraph))
     return template;
   const normalizedLevel = normalizeTocLevel(level);
   if (!seedParagraph)
     return `<w:p><w:pPr><w:pStyle w:val="TOC${normalizedLevel}"/></w:pPr>`;
-  return `${readParagraphOpenTag(seedParagraph.rawXml)}<w:pPr><w:pStyle w:val="TOC${normalizedLevel}"/></w:pPr>`;
+  const ownerOpenTag = readParagraphOpenTag(seedParagraph.rawXml);
+  if (!retainOwner)
+    return `${ownerOpenTag}<w:pPr><w:pStyle w:val="TOC${normalizedLevel}"/></w:pPr>`;
+  const templateOpenEnd = template ? findXmlTagEnd4(template, 1) : -1;
+  const properties = template ? inheritRunNamespaceDeclarations(template.slice(templateOpenEnd), template, templateOpenEnd, template.slice(0, templateOpenEnd)) : `<w:pPr><w:pStyle w:val="TOC${normalizedLevel}"/></w:pPr>`;
+  const ownerPropertiesStart = skipXmlWhitespace(seedParagraph.rawXml, ownerOpenTag.length);
+  const ownerProperties = matchLeadingElement(seedParagraph.rawXml.slice(ownerPropertiesStart), "pPr");
+  return ownerOpenTag + preserveTocOwnerProperties(properties, ownerProperties);
 }
 function readParagraphOpenTag(paragraphXml) {
   const match = /^<w:p\b([^>]*?)(?:\/>|>)/s.exec(paragraphXml);
@@ -294360,6 +294895,9 @@ function normalizeTocLevel(level) {
 }
 function buildTocEntryTextRuns(entry, runProperties, includeHyperlinks) {
   const buildLabelRun = (text, template) => {
+    if (entry.isTcEntry && text.includes("\t")) {
+      return text.split("\t").map((part, index) => (index > 0 ? "<w:r><w:tab/></w:r>" : "") + (part ? buildLabelRun(part, template) : "")).join("");
+    }
     const sanitized = template ? sanitizeTocLabelRunProperties(template.runProperties, includeHyperlinks) : "";
     if (!sanitized)
       return buildTextRunXml(text);
@@ -294388,7 +294926,7 @@ function buildTocEntryTextRuns(entry, runProperties, includeHyperlinks) {
   }
   const cachedFirstRunText = runProperties?.[0]?.text;
   const matchesCompleteMarkerBoundary = cachedFirstRunText === entry.marker || entry.markerSeparator === "space" && cachedFirstRunText?.startsWith(`${entry.marker} `);
-  if (markerSeparatorIndex < 0 && matchesCompleteMarkerBoundary) {
+  if (markerSeparatorIndex < 0 && entry.markerSeparator !== "tab" && matchesCompleteMarkerBoundary) {
     return buildLabelRuns(entry.text, runProperties);
   }
   if (markerSeparatorIndex < 0 && entry.markerSeparator === "space" && runProperties?.[0]) {
@@ -294408,8 +294946,28 @@ function buildTocEntryTextRuns(entry, runProperties, includeHyperlinks) {
       }
     }
   }
-  const markerTemplates = markerSeparatorIndex >= 0 ? runProperties?.slice(0, markerSeparatorIndex) : runProperties?.slice(0, 1);
-  const titleTemplates = markerSeparatorIndex >= 0 ? runProperties?.slice(markerSeparatorIndex + 1) : runProperties && runProperties.length > 1 ? runProperties.slice(1) : runProperties;
+  let markerTemplates = markerSeparatorIndex >= 0 ? runProperties?.slice(0, markerSeparatorIndex) : runProperties?.slice(0, 1);
+  let titleTemplates = markerSeparatorIndex >= 0 ? runProperties?.slice(markerSeparatorIndex + 1) : runProperties && runProperties.length > 1 ? runProperties.slice(1) : runProperties;
+  if (markerSeparatorIndex < 0 && entry.markerSeparator === "tab" && runProperties) {
+    const cachedLabel = runProperties.map((template) => template.text).join("");
+    const markerEnd = entry.marker.length;
+    const titleStart = markerEnd + /^\s*/.exec(cachedLabel.slice(markerEnd))[0].length;
+    if (cachedLabel.startsWith(entry.marker) && cachedLabel.slice(titleStart) === entry.title) {
+      markerTemplates = [];
+      titleTemplates = [];
+      let offset = 0;
+      for (const template of runProperties) {
+        const end = offset + template.text.length;
+        if (offset < markerEnd) {
+          markerTemplates.push({ ...template, text: template.text.slice(0, markerEnd - offset) });
+        }
+        if (end > titleStart) {
+          titleTemplates.push({ ...template, text: template.text.slice(Math.max(0, titleStart - offset)) });
+        }
+        offset = end;
+      }
+    }
+  }
   const markerRuns = buildLabelRuns(entry.marker, markerTemplates);
   if (entry.markerSeparator === "tab") {
     return [...markerRuns, "<w:r><w:tab/></w:r>", ...buildLabelRuns(entry.title, titleTemplates)];
@@ -294426,9 +294984,42 @@ function sanitizeTocLabelRunProperties(runPropertiesXml, includeHyperlinks) {
     return runPropertiesXml;
   return runPropertiesXml.replace(/<(?:[\w.-]+:)?rStyle\b(?=[^>]*\b(?:[\w.-]+:)?val=(["'])Hyperlink\1)[^>]*(?:\/>|>\s*<\/(?:[\w.-]+:)?rStyle\s*>)/gi, "");
 }
-function buildBodyTocBookmarkMap(context) {
+function tocTcFieldSourceKey(field) {
+  return `tc:${field.storyId}:${field.stableFieldId}`;
+}
+function resolveTocTcBookmarkNames(bookmarks, paragraphs, fields) {
+  if (fields.length === 0)
+    return new Map;
+  const sourceKeys = new Set(fields.map((field) => `${field.storyId}:${field.blockId}`));
+  const sourceParagraphs = paragraphs.filter((paragraph2) => sourceKeys.has(`${paragraph2.storyId}:${paragraph2.blockId}`));
+  const paragraphBookmarks = buildBodyTocBookmarkMap(bookmarks);
+  const paragraphsByKey = new Map(sourceParagraphs.map((paragraph2) => [`${paragraph2.storyId}:${paragraph2.blockId}`, paragraph2]));
+  const ranges = buildBodyTocBookmarkRangeMap(bookmarks, sourceParagraphs);
+  const siblings = new Map;
+  for (const field of fields) {
+    const key2 = `${field.storyId}:${field.blockId}`;
+    const group = siblings.get(key2) ?? [];
+    group.push(field);
+    siblings.set(key2, group);
+  }
+  const names = new Map;
+  for (const field of fields) {
+    const paragraphKey = `${field.storyId}:${field.blockId}`;
+    const bookmarkRanges = ranges.get(paragraphKey);
+    const paragraphBookmark = paragraphBookmarks.get(paragraphKey);
+    const fallbackRange = bookmarkRanges?.find((bookmark) => bookmark.name === paragraphBookmark);
+    const belongsToSibling = fallbackRange && siblings.get(paragraphKey)?.some((sibling) => sibling.stableFieldId !== field.stableFieldId && (fallbackRange.start >= sibling.descriptor.byteStart && fallbackRange.end <= sibling.descriptor.byteEnd || fallbackRange.start <= sibling.descriptor.byteStart && fallbackRange.end >= sibling.descriptor.byteEnd));
+    const paragraph2 = paragraphsByKey.get(paragraphKey);
+    const coversCrossParagraphStart = paragraph2 && fallbackRange && field.descriptor.byteEnd > paragraph2.byteEnd && fallbackRange.start <= field.descriptor.byteStart && fallbackRange.end > field.descriptor.byteStart;
+    const name = bookmarkRanges?.find((bookmark) => bookmark.start >= field.descriptor.byteStart && bookmark.end <= field.descriptor.byteEnd)?.name ?? bookmarkRanges?.find((bookmark) => bookmark.start <= field.descriptor.byteStart && bookmark.end >= field.descriptor.byteEnd)?.name ?? (belongsToSibling && !coversCrossParagraphStart ? undefined : paragraphBookmark);
+    if (name)
+      names.set(tocTcFieldSourceKey(field), name);
+  }
+  return names;
+}
+function buildBodyTocBookmarkMap(entries) {
   const bookmarks = new Map;
-  for (const entry of readBookmarkEntries(context)) {
+  for (const entry of entries) {
     if (!entry.name.startsWith("_Toc"))
       continue;
     const key2 = `${entry.storyId}:${entry.blockId}`;
@@ -294437,6 +295028,43 @@ function buildBodyTocBookmarkMap(context) {
   }
   return bookmarks;
 }
+function buildBodyTocBookmarkRangeMap(bookmarks, paragraphs) {
+  if (paragraphs.length === 0)
+    return new Map;
+  const paragraphsByKey = new Map(paragraphs.map((paragraph2) => [`${paragraph2.storyId}:${paragraph2.blockId}`, paragraph2]));
+  const scans = new Map;
+  const ranges = new Map;
+  for (const bookmark of bookmarks) {
+    if (!bookmark.name.startsWith("_Toc"))
+      continue;
+    const key2 = `${bookmark.storyId}:${bookmark.blockId}`;
+    const paragraph2 = paragraphsByKey.get(key2);
+    if (!paragraph2)
+      continue;
+    if (!scans.has(key2))
+      scans.set(key2, readBookmarkMarkerSpans(paragraph2.rawXml, paragraph2.namespaceBindings));
+    const scan = scans.get(key2);
+    if (!scan || scan.invalidBookmarkIds.has(bookmark.bookmarkId))
+      continue;
+    const endMarker = scan.markers.find((marker) => marker.kind === "end" && marker.bookmarkId === bookmark.bookmarkId);
+    if (!endMarker)
+      continue;
+    const range = {
+      name: bookmark.name,
+      start: bookmark.markerByteStart,
+      end: paragraph2.byteStart + encodeXml(paragraph2.rawXml.slice(0, endMarker.start)).length
+    };
+    if (range.end < range.start)
+      continue;
+    const paragraphRanges = ranges.get(key2) ?? [];
+    paragraphRanges.push(range);
+    ranges.set(key2, paragraphRanges);
+  }
+  for (const paragraphRanges of ranges.values()) {
+    paragraphRanges.sort((left, right) => left.end - left.start - (right.end - right.start));
+  }
+  return ranges;
+}
 function buildTocPageReferenceRunsXml(bookmarkName, page, separator) {
   return buildTocPageSeparatorRunsXml(separator) + buildWebHiddenFieldCharRunXml("begin") + buildWebHiddenInstructionRunXml(` PAGEREF ${bookmarkName} \\h `) + buildWebHiddenEmptyRunXml() + buildWebHiddenFieldCharRunXml("separate") + buildWebHiddenTextRunXml(page) + buildWebHiddenFieldCharRunXml("end");
 }
@@ -294466,7 +295094,7 @@ function buildWebHiddenEmptyRunXml() {
 function emptyTocParagraphTemplates() {
   return {
     byLevel: new Map,
-    byText: new Map
+    byLevelAndText: new Map
   };
 }
 function buildTocParagraphTemplatesFromParagraphXml(xml) {
@@ -294480,18 +295108,20 @@ function buildTocParagraphTemplatesFromParagraphXml(xml) {
     if (!templates.byLevel.has(level))
       templates.byLevel.set(level, open2);
     const entryText = readTocParagraphTemplateText(paragraphXml);
-    if (entryText && !templates.byText.has(entryText))
-      templates.byText.set(entryText, open2);
+    const key2 = `${level}:${entryText}`;
+    if (entryText && !templates.byLevelAndText.has(key2))
+      templates.byLevelAndText.set(key2, open2);
   }
   return templates;
 }
 function buildTocParagraphTemplateOpen(paragraphXml) {
   const openTag = /^<w:p\b[^>]*>/s.exec(paragraphXml)?.[0] ?? "";
-  const pPrXml = openTag ? matchLeadingElement(paragraphXml.slice(openTag.length), "pPr") : "";
+  const pPrXml = openTag ? matchLeadingElement(paragraphXml.slice(skipXmlWhitespace(paragraphXml, openTag.length)), "pPr") : "";
   return `${readParagraphOpenTag(paragraphXml)}${pPrXml}`;
 }
 function readTocParagraphLevel(paragraphXml) {
-  const paragraphStyle = findFirstElement(paragraphXml, "pStyle");
+  const propertiesXml = matchLeadingElement(paragraphXml, "pPr") || findDirectChild(paragraphXml, "pPr")?.xml;
+  const paragraphStyle = propertiesXml ? findDirectChild(propertiesXml, "pStyle") : undefined;
   const style = paragraphStyle ? /^TOC(\d+)$/.exec(readXmlAttributeByLocalName(paragraphStyle.xml, "val") ?? "")?.[1] : undefined;
   if (!style)
     return null;
@@ -294514,13 +295144,14 @@ function resolveTocParagraphOpen(level, templates, entryText) {
   return `<w:p><w:pPr><w:pStyle w:val="TOC${normalizedLevel}"/></w:pPr>`;
 }
 function resolveTocParagraphTemplate(level, templates, entryText) {
+  const normalizedLevel = normalizeTocLevel(level);
   const normalizedText = entryText ? normalizeTocEntryText(entryText) : "";
   if (normalizedText.length > 0) {
-    const byText = templates.byText.get(normalizedText);
-    if (byText)
-      return byText;
+    const byLevelAndText = templates.byLevelAndText.get(`${normalizedLevel}:${normalizedText}`);
+    if (byLevelAndText)
+      return byLevelAndText;
   }
-  return templates.byLevel.get(normalizeTocLevel(level));
+  return templates.byLevel.get(normalizedLevel);
 }
 function readPreservedTocPagesByText(context, currentField, paragraphs = readBodyParagraphs(context, { includeListState: false })) {
   const preserved = new Map;
@@ -295210,7 +295841,7 @@ function joinMarkerAndText(marker, text) {
   return text.length > 0 ? `${marker} ${text}` : marker;
 }
 function parseTocEntryInstruction(instruction) {
-  const tableIdentifier = parseQuotedSwitch(instruction, "f") ?? parseQuotedSwitch(instruction, "t");
+  const tableIdentifier = parseTocFieldIdentifier(instruction) ?? parseQuotedSwitch(instruction, "t");
   return {
     text: parseFirstQuotedValue(instruction) ?? "",
     level: Number(parseNumericSwitchValue(instruction, "l") ?? "1"),
@@ -295319,6 +295950,10 @@ var init_runtime2 = __esm(() => {
   init_registry3();
   init_stories();
   init_section_xml();
+  init_src6();
+  init_part();
+  init_common();
+  init_paragraph_property_order();
   init_scalar_evaluation();
   init_bookmark_insertion();
   init_xml();
@@ -340500,10 +341135,18 @@ class V2ContentControlsAdapter {
     if (controlPlacement(part.xml, control2) !== control2.info.kind) {
       throw operationError("CAPABILITY_UNAVAILABLE", "Row and cell controls are not supported adjacent insertion targets.");
     }
-    let fragment4 = buildAdjacentContent(input.content ?? "", control2.info.kind, createParaIdAllocator(this.context));
+    const allocator = createParaIdAllocator(this.context);
+    let createdBlockId = null;
+    const captureParaId = () => {
+      const id = allocator();
+      if (createdBlockId == null)
+        createdBlockId = id;
+      return id;
+    };
+    let fragment4 = buildAdjacentContent(input.content ?? "", control2.info.kind, captureParaId);
     let commitOptions = {
       partUri: part.partUri,
-      storySurface: { family: "storyBlocks", contentControlRewrite: true, targetBlockIds: [] },
+      storySurface: { family: "storyBlocks", contentControlRewrite: true, changeMode: "direct", targetBlockIds: [] },
       preserveRenderCommit: true
     };
     if (options?.changeMode === "tracked") {
@@ -340529,7 +341172,7 @@ class V2ContentControlsAdapter {
       return this.validateDryRun(input, options, control2.target);
     const index2 = placement3 === "before" ? control2.start : control2.end;
     const nextXml = `${part.xml.slice(0, index2)}${fragment4}${part.xml.slice(index2)}`;
-    return this.commitDocument(nextXml, `content-control-insert-${placement3}`, input, options, control2.target, commitOptions);
+    return this.commitDocument(nextXml, `content-control-insert-${placement3}`, input, options, control2.target, { ...commitOptions, ...createdBlockId != null ? { createdBlockId } : {} });
   }
   mutatePr(input, options, transform2) {
     return this.mutateControl(input.target, input, options, (control2) => {
@@ -340920,6 +341563,7 @@ class V2ContentControlsAdapter {
     if (!documentProtectionAllowsXmlRewrite(this.context, partUri, before, nextXml)) {
       return { success: false, failure: { code: "PERMISSION_DENIED", message: DOCUMENT_PROTECTION_MESSAGE } };
     }
+    let remappedCreatedBlockId = commitOptions.createdBlockId;
     if (commitOptions.storySurface?.contentControlRewrite && this.context.isCollaborativeSession()) {
       const existingIds = new Set(this.load().parts.flatMap((part) => Array.from(part.xml.matchAll(/\bw14:paraId="([^"]+)"/g), (match) => match[1])));
       const newIds = [...new Set(Array.from(nextXml.matchAll(/\bw14:paraId="([^"]+)"/g), (match) => match[1]))].filter((id) => !existingIds.has(id));
@@ -340929,6 +341573,9 @@ class V2ContentControlsAdapter {
           return { success: false, failure: { code: "PRECONDITION_FAILED", message: "Could not reserve content-control paragraph identities." } };
         const remap = new Map(newIds.map((id, index2) => [id, allocated[index2]]));
         nextXml = nextXml.replace(/\bw14:paraId="([^"]+)"/g, (attribute, id) => remap.has(id) ? `w14:paraId="${remap.get(id)}"` : attribute);
+        if (remappedCreatedBlockId != null) {
+          remappedCreatedBlockId = remap.get(remappedCreatedBlockId) ?? remappedCreatedBlockId;
+        }
       }
     }
     const committed = commitWholePartUpdates(this.context, prefix, { [partUri]: encodeXml(nextXml) }, {
@@ -340953,7 +341600,8 @@ class V2ContentControlsAdapter {
       contentControl: target,
       ...commitOptions.updatedRef ? { updatedRef: commitOptions.updatedRef } : {},
       affectedStories: [...commitOptions.affectedStories ?? [target.story ?? { kind: "story", storyType: "body" }]],
-      ...trackedChangeRefs && trackedChangeRefs.length > 0 ? { trackedChangeRefs } : {}
+      ...trackedChangeRefs && trackedChangeRefs.length > 0 ? { trackedChangeRefs } : {},
+      ...remappedCreatedBlockId != null ? { createdBlockId: remappedCreatedBlockId } : {}
     };
     if (commitOptions.preserveRenderCommit) {
       const renderCommit = getSDRenderCommitEnvelope(committed);
@@ -343099,10 +343747,12 @@ function regenerateTrackedToc(context, entry, instruction, dryRun) {
   }));
   if (missing2.some((bookmark) => !bookmark.paragraph))
     return unavailable4("A TOC heading target is unavailable.");
-  const names = new Map(missing2.map((bookmark) => [
-    `${bookmark.paragraph.storyId}:${bookmark.blockId}`,
-    bookmark.name
-  ]));
+  const names = new Map;
+  for (const bookmark of missing2) {
+    names.set(bookmark.fieldSource?.key ?? `${bookmark.paragraph.storyId}:${bookmark.blockId}`, bookmark.name);
+    for (const key2 of bookmark.fieldSourceKeys ?? [])
+      names.set(key2, bookmark.name);
+  }
   const sdt = prepareTocSdtReplacement(context, entry, instruction, names);
   const rendered = !sdt.ok && sdt.message === "Unable to locate the containing TOC content control." ? prepareBareTocReplacement(context, entry, instruction, names) : sdt;
   if (!rendered.ok)
@@ -343141,16 +343791,18 @@ function regenerateTrackedToc(context, entry, instruction, dryRun) {
     ];
     let count = content3.wordIds.length;
     let bookmarkId = nextBookmarkNumericId(context);
+    const bookmarkMarkers = [];
     for (const bookmark of missing2) {
       const paragraph4 = bookmark.paragraph;
-      const markers = [
-        `<w:bookmarkStart w:id="${bookmarkId}" w:name="${xmlEscapeAttr(bookmark.name)}"/>`,
-        `<w:bookmarkEnd w:id="${bookmarkId++}"/>`
-      ].map((xml2) => {
+      const markerBindings = readBookmarkInsertionNamespaceBindings(paragraph4, bookmark);
+      if (!markerBindings)
+        return null;
+      const fragments = buildParagraphBookmarkMarkers(paragraph4, bookmark, bookmarkId++);
+      const markers = [fragments.startXml, fragments.endXml].map((xml) => {
         const marker = prepareTrackedInlineXmlReplacement({
           beforeXml: "",
-          afterXml: xml2,
-          namespaceBindings: new Map(Object.entries(paragraph4.namespaceBindings ?? {})),
+          afterXml: xml,
+          namespaceBindings: markerBindings,
           stamp: {
             ...stamp,
             revisionId: revisionIds?.[count] ?? count,
@@ -343163,10 +343815,12 @@ function regenerateTrackedToc(context, entry, instruction, dryRun) {
       });
       if (!markers[0] || !markers[1])
         return null;
-      const start = injectParagraphPrefix(paragraph4.rawXml, markers[0].xml);
-      const xml = start && injectParagraphSuffix(start, markers[1].xml);
-      if (!xml)
-        return null;
+      bookmarkMarkers.push({ ...bookmark, startXml: markers[0].xml, endXml: markers[1].xml });
+    }
+    const grouped = prepareBookmarkParagraphGroups(paragraphs, bookmarkMarkers);
+    if (!grouped)
+      return null;
+    for (const { paragraph: paragraph4, xml } of grouped) {
       edits.push({
         partUri: paragraph4.partUri,
         storyId: paragraph4.storyId,
@@ -343202,6 +343856,8 @@ function regenerateTrackedToc(context, entry, instruction, dryRun) {
     return unavailable4("This TOC rebuild requires unsupported existing field, paragraph, or heading boundaries.");
   if (dryRun)
     return { ok: true };
+  if (context.isCollaborativeSession())
+    return { ok: false, code: "INVALID_CONTEXT", message: "toc-regenerate-tracked: unsupported-context" };
   const ids = reserveTrackedReferenceRevisionIds(context, preview.count, false);
   if (!ids)
     return unavailable4("The TOC rebuild could not reserve its complete revision identity batch.");
@@ -344461,9 +345117,11 @@ class V2TocAdapter {
     }
     if (options?.dryRun)
       return success3(input.target.nodeId);
+    if (this.context.isCollaborativeSession())
+      return failure6("INVALID_CONTEXT", "toc-configure: unsupported-context");
     let refreshed = entry;
     if (!usesV1EmptyTocSourceSet(nextInstruction)) {
-      const seeded = seedMissingTocBookmarks(this.context, nextInstruction);
+      const seeded = seedMissingTocBookmarks(this.context, nextInstruction, entry.field);
       if (!seeded.ok)
         return failure6(seeded.code, seeded.message);
       const seededEntry = findTocBlock(this.context, input.target.nodeId);
@@ -344495,9 +345153,11 @@ class V2TocAdapter {
     }
     if (options?.dryRun)
       return success3(input.target.nodeId);
+    if (this.context.isCollaborativeSession())
+      return failure6("INVALID_CONTEXT", "toc-update: unsupported-context");
     let refreshed = entry;
     if (!usesV1EmptyTocSourceSet(entry.field.descriptor.instructionText)) {
-      const seeded = seedMissingTocBookmarks(this.context, entry.field.descriptor.instructionText);
+      const seeded = seedMissingTocBookmarks(this.context, entry.field.descriptor.instructionText, entry.field);
       if (!seeded.ok)
         return failure6(seeded.code, seeded.message);
       const seededEntry = findTocBlock(this.context, input.target.nodeId);
@@ -344679,6 +345339,9 @@ function listTocBlocks(context) {
 function findTocBlock(context, nodeId) {
   return listTocBlocks(context).find((entry) => entry.field.blockId === nodeId) ?? null;
 }
+function guardTocBookmarkInsertion(context, instruction, operation) {
+  return guardTocContentMutation(context, null, instruction, operation);
+}
 function guardTocContentMutation(context, field, instruction, operation) {
   const unavailable4 = () => ({ code: "CAPABILITY_UNAVAILABLE", message: `${operation}: the TOC source is unavailable.` });
   const decoder7 = new TextDecoder;
@@ -344698,15 +345361,28 @@ function guardTocContentMutation(context, field, instruction, operation) {
     });
     return true;
   };
-  if (!add(field.partUri, field.descriptor.byteStart, field.descriptor.byteEnd))
+  if (field && !add(field.partUri, field.descriptor.byteStart, field.descriptor.byteEnd))
     return unavailable4();
   const missing2 = planMissingTocBookmarks(context, instruction);
   if (missing2.length) {
     const paragraphs = new Map(readBodyParagraphs(context, { includeListState: false }).map((paragraph4) => [paragraph4.blockId, paragraph4]));
+    const aliasedFields = missing2.some((bookmark) => bookmark.fieldSourceKeys?.length) ? new Map(listCanonicalFieldEntries(context).map((source) => [tocTcFieldSourceKey(source), source])) : null;
     for (const bookmark of missing2) {
       const paragraph4 = paragraphs.get(bookmark.blockId);
-      if (!paragraph4 || !add(paragraph4.partUri, paragraph4.byteStart, paragraph4.byteStart + 1))
+      if (!paragraph4)
         return unavailable4();
+      const start = bookmark.fieldSource?.byteStart ?? paragraph4.byteStart;
+      const end = bookmark.fieldSource?.byteEnd ?? paragraph4.byteStart;
+      if (!add(paragraph4.partUri, start, start + 1) || bookmark.fieldSource && !add(paragraph4.partUri, end - 1, end))
+        return unavailable4();
+      for (const key2 of bookmark.fieldSourceKeys ?? []) {
+        const source = aliasedFields?.get(key2);
+        if (!source?.descriptor.complete)
+          continue;
+        const fieldSource = { key: key2, byteStart: source.descriptor.byteStart, byteEnd: source.descriptor.byteEnd };
+        if (canPlaceBookmarkAtFieldSource(paragraph4, fieldSource) && (!add(source.partUri, fieldSource.byteStart, fieldSource.byteStart + 1) || !add(source.partUri, fieldSource.byteEnd - 1, fieldSource.byteEnd)))
+          return unavailable4();
+      }
     }
   }
   for (const part of parts.values()) {
@@ -344714,6 +345390,20 @@ function guardTocContentMutation(context, field, instruction, operation) {
     if (locked)
       return locked;
   }
+  if (missing2.length) {
+    const paragraphs = readBodyParagraphs(context, { includeListState: false });
+    const byId = new Map(paragraphs.map((paragraph4) => [paragraph4.blockId, paragraph4]));
+    let id = nextBookmarkNumericId(context);
+    const markers = missing2.map((bookmark) => ({
+      ...bookmark,
+      ...buildParagraphBookmarkMarkers(byId.get(bookmark.blockId), bookmark, id++)
+    }));
+    if (!prepareBookmarkParagraphGroups(paragraphs, markers))
+      return {
+        code: "CAPABILITY_UNAVAILABLE",
+        message: `${operation}: TOC bookmark targets have unsupported paragraph or field boundaries.`
+      };
+  }
   return null;
 }
 function paragraphOverlapsSpan(entry, span) {
@@ -344797,10 +345487,11 @@ function projectTocInlineDomain(entry) {
   };
 }
 function projectTocSourceConfig(instruction) {
+  const tcSelection = parseTocTcSourceSelection(instruction);
   return {
     ...parseNumericSwitchRange(instruction, "o") ? { outlineLevels: parseNumericSwitchRange(instruction, "o") } : {},
-    ...parseQuotedSwitch(instruction, "f") ? { tcFieldIdentifier: parseQuotedSwitch(instruction, "f") } : {},
-    ...parseNumericSwitchRange(instruction, "l") ? { tcFieldLevels: parseNumericSwitchRange(instruction, "l") } : {},
+    ...tcSelection.identifier ? { tcFieldIdentifier: tcSelection.identifier } : {},
+    ...tcSelection.levels ? { tcFieldLevels: tcSelection.levels } : {},
     ...instruction.includes("\\u") ? { useAppliedOutlineLevel: true } : {}
   };
 }
@@ -344828,23 +345519,22 @@ function countGeneratedTocEntries(context, instruction, sourceConfig) {
   const outline = sourceConfig.outlineLevels ?? { from: 1, to: 3 };
   const customStyles = parseTocCustomStyles2(parseQuotedSwitch(instruction, "t") ?? "");
   const includeOutlineEntries = customStyles.length === 0 || sourceConfig.outlineLevels != null;
-  const headings = readBodyParagraphs(context, { includeListState: false }).filter((paragraph4) => {
+  const paragraphs = readBodyParagraphs(context, { includeListState: false });
+  const bodyParagraphs = new Set(paragraphs.map((paragraph4) => `${paragraph4.storyId}:${paragraph4.blockId}`));
+  const headings = paragraphs.filter((paragraph4) => {
     const matchesCustomStyle = paragraph4.styleId != null && customStyles.some((entry) => normalizeStyleId2(entry.styleName) === normalizeStyleId2(paragraph4.styleId ?? ""));
     const matchesOutline = includeOutlineEntries && paragraph4.headingLevel >= outline.from && paragraph4.headingLevel <= outline.to;
     return matchesCustomStyle || matchesOutline;
   }).length;
-  const tcEntries = listTocInlineEntries(context).filter((entry) => {
+  const tcSelection = parseTocTcSourceSelection(instruction);
+  const tcEntries = listTocInlineEntries(context).filter((entry) => bodyParagraphs.has(`${entry.field.storyId}:${entry.field.blockId}`)).filter((entry) => {
     const parsed = parseTocEntryInstruction(entry.field.descriptor.instructionText);
-    if (sourceConfig.tcFieldIdentifier && parsed.tableIdentifier !== sourceConfig.tcFieldIdentifier)
-      return false;
-    if (sourceConfig.tcFieldLevels && (parsed.level < sourceConfig.tcFieldLevels.from || parsed.level > sourceConfig.tcFieldLevels.to))
-      return false;
-    return true;
+    return matchesTocTcSourceSelection(tcSelection, parsed);
   }).length;
   return headings + tcEntries;
 }
 function usesV1EmptyTocSourceSet(instruction) {
-  return parseQuotedSwitch(instruction, "t") != null && parseNumericSwitchRange(instruction, "o") == null && !/\\u\b/i.test(instruction) && parseQuotedSwitch(instruction, "f") == null && parseNumericSwitchRange(instruction, "l") == null;
+  return parseQuotedSwitch(instruction, "t") != null && parseNumericSwitchRange(instruction, "o") == null && !/\\u\b/i.test(instruction) && !parseTocTcSourceSelection(instruction).enabled;
 }
 function countMaterializedTocResultParagraphs(context, field) {
   if (field.descriptor.resultText.length === 0)
@@ -344867,6 +345557,7 @@ function isTocResultParagraph(rawXml) {
   return /<[\w.-]+:pStyle\b[^>]*\b(?:[\w.-]+:)?val="TOC[1-9]"/.test(rawXml);
 }
 function applyTocPatch(instruction, patch) {
+  const tcSelection = parseTocTcSourceSelection(instruction);
   const nextParts = ["TOC"];
   const outlineLevels = patch.outlineLevels ?? parseNumericSwitchRange(instruction, "o");
   if (outlineLevels)
@@ -344883,12 +345574,17 @@ function applyTocPatch(instruction, patch) {
     nextParts.push(`\\p "${separator}"`);
   if ((patch.useAppliedOutlineLevel ?? instruction.includes("\\u")) === true)
     nextParts.push("\\u");
-  const tcIdentifier = patch.tcFieldIdentifier ?? parseQuotedSwitch(instruction, "f");
+  const tcIdentifier = patch.tcFieldIdentifier ?? tcSelection.identifier;
   if (tcIdentifier != null)
     nextParts.push(`\\f "${tcIdentifier}"`);
-  const tcLevels = patch.tcFieldLevels ?? parseNumericSwitchRange(instruction, "l");
+  else if (tcSelection.hasFieldSwitch)
+    nextParts.push("\\f");
+  const tcLevels = patch.tcFieldLevels ?? tcSelection.levels;
   if (tcLevels)
     nextParts.push(`\\l "${tcLevels.from}-${tcLevels.to}"`);
+  else if (tcSelection.hasLevelSwitch) {
+    nextParts.push(tcSelection.levelArgument == null ? "\\l" : `\\l "${tcSelection.levelArgument}"`);
+  }
   return [...nextParts, ...readPreservedTocSwitchFragments(instruction)].join(" ");
 }
 function serializeTocEntryInstruction(text4, level, tableIdentifier, omitPageNumber) {
@@ -344986,9 +345682,19 @@ function parseTocCustomStyles2(value2) {
 function normalizeStyleId2(value2) {
   return value2.replace(/\s+/g, "").trim().toLowerCase();
 }
-function seedMissingTocBookmarks(context, instruction) {
+function seedMissingTocBookmarks(context, instruction, field) {
   const insertions = planMissingTocBookmarks(context, instruction);
   if (insertions.length > 0) {
+    const paragraphs = new Map(readBodyParagraphs(context, { includeListState: false }).map((paragraph4) => [paragraph4.blockId, paragraph4]));
+    const names = new Map;
+    for (const bookmark of insertions) {
+      names.set(bookmark.fieldSource?.key ?? `${paragraphs.get(bookmark.blockId).storyId}:${bookmark.blockId}`, bookmark.name);
+      for (const key2 of bookmark.fieldSourceKeys ?? [])
+        names.set(key2, bookmark.name);
+    }
+    const prepared = prepareTocReplacement(context, field, instruction, names);
+    if (!prepared.ok)
+      return prepared;
     const committed = insertBookmarksIntoParagraphs(context, insertions, "toc-bookmark-seed");
     if (!committed.ok)
       return committed;
@@ -344998,44 +345704,91 @@ function seedMissingTocBookmarks(context, instruction) {
 function planMissingTocBookmarks(context, instruction) {
   if (usesV1EmptyTocSourceSet(instruction))
     return [];
-  const existing = new Map;
-  const existingNames = new Set;
-  for (const bookmark of readBookmarkEntries(context)) {
-    existingNames.add(bookmark.name);
-    if (!bookmark.name.startsWith("_Toc"))
-      continue;
-    const key2 = `${bookmark.storyId}:${bookmark.blockId}`;
-    if (!existing.has(key2))
-      existing.set(key2, bookmark.name);
-  }
+  const bookmarks = readBookmarkEntries(context);
+  const existingNames = new Set(bookmarks.map((bookmark) => bookmark.name));
+  const existingParagraphs = new Set(bookmarks.filter((bookmark) => bookmark.name.startsWith("_Toc")).map((bookmark) => `${bookmark.storyId}:${bookmark.blockId}`));
+  const paragraphs = readBodyParagraphs(context, { includeListState: false });
+  const bodyKeys = new Set(paragraphs.map((paragraph4) => `${paragraph4.storyId}:${paragraph4.blockId}`));
+  const canonicalFields = listCanonicalFieldEntries(context);
+  const tcFields = canonicalFields.filter((field) => instructionKeyword(field.descriptor.instructionText) === "TC" && bodyKeys.has(`${field.storyId}:${field.blockId}`));
+  const incompleteFields = canonicalFields.filter((field) => !field.descriptor.complete);
+  const tcBookmarkNames = resolveTocTcBookmarkNames(bookmarks, paragraphs, tcFields);
   let nextOrdinal = nextTocBookmarkOrdinal(existingNames);
   const insertions = [];
-  for (const paragraph4 of listIncludedTocParagraphs(context, instruction)) {
-    const key2 = `${paragraph4.storyId}:${paragraph4.blockId}`;
-    if (existing.has(key2))
-      continue;
-    let name = buildTocBookmarkName(nextOrdinal);
-    while (existingNames.has(name)) {
-      nextOrdinal += 1;
-      name = buildTocBookmarkName(nextOrdinal);
-    }
-    insertions.push({ blockId: paragraph4.blockId, name });
-    existing.set(key2, name);
+  const genericByParagraph = new Map;
+  const paragraphsByKey = new Map(paragraphs.map((paragraph4) => [`${paragraph4.storyId}:${paragraph4.blockId}`, paragraph4]));
+  const allocateName = () => {
+    let name = buildTocBookmarkName(nextOrdinal++);
+    while (existingNames.has(name))
+      name = buildTocBookmarkName(nextOrdinal++);
     existingNames.add(name);
-    nextOrdinal += 1;
-  }
-  return insertions;
-}
-function listIncludedTocParagraphs(context, instruction) {
+    return name;
+  };
   const customStyles = parseTocCustomStyles2(parseQuotedSwitch(instruction, "t") ?? "");
   const explicitOutlineRange = parseNumericSwitchRange(instruction, "o");
   const outlineRange = explicitOutlineRange ?? { from: 1, to: 3 };
   const includeOutlineEntries = customStyles.length === 0 || explicitOutlineRange != null;
-  return readBodyParagraphs(context, { includeListState: false }).filter((paragraph4) => {
+  for (const paragraph4 of paragraphs) {
     const matchesCustomStyle = paragraph4.styleId != null && customStyles.some((entry) => normalizeStyleId2(entry.styleName) === normalizeStyleId2(paragraph4.styleId ?? ""));
     const matchesOutline = includeOutlineEntries && paragraph4.headingLevel >= outlineRange.from && paragraph4.headingLevel <= outlineRange.to;
-    return matchesCustomStyle || matchesOutline;
-  });
+    if ((matchesCustomStyle || matchesOutline) && !existingParagraphs.has(`${paragraph4.storyId}:${paragraph4.blockId}`)) {
+      const insertion = { blockId: paragraph4.blockId, name: allocateName() };
+      insertions.push(insertion);
+      genericByParagraph.set(`${paragraph4.storyId}:${paragraph4.blockId}`, insertion);
+    }
+  }
+  const selection = parseTocTcSourceSelection(instruction);
+  const missingFields = tcFields.filter((field) => matchesTocTcSourceSelection(selection, parseTocEntryInstruction(field.descriptor.instructionText)) && !tcBookmarkNames.has(tocTcFieldSourceKey(field))).map((field) => {
+    const key2 = tocTcFieldSourceKey(field);
+    const fieldSource = { key: key2, byteStart: field.descriptor.byteStart, byteEnd: field.descriptor.byteEnd };
+    const paragraphKey = `${field.storyId}:${field.blockId}`;
+    const paragraph4 = paragraphsByKey.get(paragraphKey);
+    const bytes = readPartBytes2(context, field.partUri);
+    const validCanonicalField = Boolean(field.descriptor.complete && Number.isInteger(fieldSource.byteStart) && Number.isInteger(fieldSource.byteEnd) && fieldSource.byteStart >= paragraph4.byteStart && fieldSource.byteEnd > fieldSource.byteStart && bytes && fieldSource.byteEnd <= bytes.length);
+    return { field, key: key2, fieldSource, paragraphKey, paragraph: paragraph4, validCanonicalField };
+  });
+  const fieldsByParagraph = new Map;
+  for (const source of missingFields) {
+    const group = fieldsByParagraph.get(source.paragraphKey) ?? [];
+    group.push(source);
+    fieldsByParagraph.set(source.paragraphKey, group);
+  }
+  const collidingKeys = new Set;
+  for (const group of fieldsByParagraph.values()) {
+    group.sort((left, right) => left.fieldSource.byteStart - right.fieldSource.byteStart);
+    let component = [];
+    let componentEnd = -1;
+    const finishComponent = () => {
+      if (component.length > 1 && component.every((source) => source.validCanonicalField) && !incompleteFields.some((field) => field.storyId === component[0].field.storyId && field.blockId === component[0].field.blockId && field.descriptor.byteStart >= component[0].fieldSource.byteStart && field.descriptor.byteStart < componentEnd)) {
+        for (const source of component)
+          collidingKeys.add(source.key);
+      }
+    };
+    for (const source of group) {
+      if (source.fieldSource.byteStart >= componentEnd) {
+        finishComponent();
+        component = [];
+        componentEnd = -1;
+      }
+      component.push(source);
+      componentEnd = Math.max(componentEnd, source.fieldSource.byteEnd);
+    }
+    finishComponent();
+  }
+  for (const { field, key: key2, fieldSource, paragraphKey, paragraph: paragraph4, validCanonicalField } of missingFields) {
+    if (validCanonicalField && (collidingKeys.has(key2) || !canPlaceBookmarkAtFieldSource(paragraph4, fieldSource))) {
+      let generic = genericByParagraph.get(paragraphKey);
+      if (!generic) {
+        generic = { blockId: field.blockId, name: allocateName() };
+        genericByParagraph.set(paragraphKey, generic);
+        insertions.push(generic);
+      }
+      (generic.fieldSourceKeys ?? (generic.fieldSourceKeys = [])).push(key2);
+    } else {
+      insertions.push({ blockId: field.blockId, name: allocateName(), fieldSource });
+    }
+  }
+  return insertions;
 }
 function nextTocBookmarkOrdinal(existingNames) {
   let largest = 0;
@@ -345134,14 +345887,17 @@ function insertTrackedToc(context, input) {
   }));
   if (missing2.some((bookmark) => !bookmark.paragraph))
     return unavailable4("A TOC heading target is unavailable.");
-  const names = new Map(missing2.map((bookmark) => [
-    `${bookmark.paragraph.storyId}:${bookmark.blockId}`,
-    bookmark.name
-  ]));
+  const names = new Map;
+  for (const bookmark of missing2) {
+    names.set(bookmark.fieldSource?.key ?? `${bookmark.paragraph.storyId}:${bookmark.blockId}`, bookmark.name);
+    for (const key2 of bookmark.fieldSourceKeys ?? [])
+      names.set(key2, bookmark.name);
+  }
   let tocXml = buildTocFieldXml(context, input.instruction, {
     bare: true,
     tocBookmarkNames: names,
-    reservedParaIds: occupied
+    reservedParaIds: occupied,
+    insertionByteStart: insertByte
   });
   tocXml = tocXml.replace(/<w:p\b[^>]*>/g, (open2) => /\sxmlns:w14\s*=/.test(open2) ? open2 : open2.replace("<w:p", '<w:p xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"'));
   const tocRanges = collectXmlElementRanges(tocXml, {
@@ -345153,17 +345909,8 @@ function insertTrackedToc(context, input) {
   const tocParagraphs = tocRanges.ranges.filter((range) => range.tag.namespaceUri === bindings.get("w") && range.tag.localName === "p");
   if (!tocParagraphs.length)
     return unavailable4("The generated TOC has no paragraphs.");
-  const coordinated = context.isCollaborativeSession() && !input.dryRun ? context.allocateCollaborativeStoryParaIds({
-    count: tocParagraphs.length,
-    inUse: [...occupied]
-  }) : null;
-  if (context.isCollaborativeSession() && !input.dryRun && (coordinated?.length !== tocParagraphs.length || new Set(coordinated.map((id) => id.toUpperCase())).size !== coordinated.length || coordinated.some((id) => !/^[0-9a-f]{8}$/i.test(id) || occupied.has(id.toUpperCase())))) {
-    return unavailable4("TOC insertion could not reserve its complete paragraph identity batch.");
-  }
   let nextParagraphId = 184549376;
-  const paragraphIds = tocParagraphs.map((_paragraph, index2) => {
-    if (coordinated)
-      return coordinated[index2];
+  const paragraphIds = tocParagraphs.map(() => {
     let id;
     do {
       id = (++nextParagraphId).toString(16).toUpperCase().padStart(8, "0");
@@ -345188,6 +345935,12 @@ function insertTrackedToc(context, input) {
   const preview = prepareTrackedTocInsertion({ xml: tocXml, namespaceBindings: bindings, stamp });
   if (!preview)
     return unavailable4("The generated TOC content cannot be represented by supported run revisions.");
+  if (context.isCollaborativeSession() && !input.dryRun)
+    return {
+      ok: false,
+      code: "INVALID_CONTEXT",
+      message: "create-table-of-contents-tracked: unsupported-context"
+    };
   const ids = reserveTrackedReferenceRevisionIds(context, preview.wordIds.length + missing2.length * 2, input.dryRun);
   if (!ids)
     return unavailable4("TOC insertion could not reserve its complete revision identity batch.");
@@ -345204,24 +345957,29 @@ function insertTrackedToc(context, input) {
   const storyIds = new Set([input.storyId]);
   let idIndex = preview.wordIds.length;
   let bookmarkId = nextBookmarkNumericId(context);
+  const bookmarkMarkers = [];
   for (const bookmark of missing2) {
     const paragraph4 = bookmark.paragraph;
-    const startXml = `<w:bookmarkStart w:id="${bookmarkId}" w:name="${xmlEscapeAttr(bookmark.name)}"/>`;
-    const endXml = `<w:bookmarkEnd w:id="${bookmarkId++}"/>`;
+    const markerBindings = readBookmarkInsertionNamespaceBindings(paragraph4, bookmark);
+    if (!markerBindings)
+      return unavailable4("TOC bookmark namespace context is unavailable.");
+    const { startXml, endXml } = buildParagraphBookmarkMarkers(paragraph4, bookmark, bookmarkId++);
     const markers = [startXml, endXml].map((xml) => prepareTrackedInlineXmlReplacement({
       beforeXml: "",
       afterXml: xml,
-      namespaceBindings: new Map(Object.entries(paragraph4.namespaceBindings ?? {})),
+      namespaceBindings: markerBindings,
       stamp: { ...stamp, revisionId: ids[idIndex], revisionIds: [ids[idIndex++]] }
     }));
     if (!markers[0] || !markers[1])
       return unavailable4("TOC bookmark markers cannot be revision marked.");
-    const withStart = injectParagraphPrefix(paragraph4.rawXml, markers[0].xml);
-    const withEnd = withStart && injectParagraphSuffix(withStart, markers[1].xml);
-    if (!withEnd)
-      return unavailable4("TOC bookmark markers could not be placed.");
+    bookmarkMarkers.push({ ...bookmark, startXml: markers[0].xml, endXml: markers[1].xml });
+  }
+  const grouped = prepareBookmarkParagraphGroups(paragraphs, bookmarkMarkers);
+  if (!grouped)
+    return unavailable4("TOC bookmark markers could not be placed.");
+  for (const { paragraph: paragraph4, xml } of grouped) {
     const perPart2 = edits.get(paragraph4.partUri) ?? [];
-    perPart2.push({ start: paragraph4.byteStart, end: paragraph4.byteEnd, bytes: encodeXml(withEnd) });
+    perPart2.push({ start: paragraph4.byteStart, end: paragraph4.byteEnd, bytes: encodeXml(xml) });
     edits.set(paragraph4.partUri, perPart2);
     storyIds.add(paragraph4.storyId);
   }
@@ -346189,10 +346947,14 @@ class V2CreateAdapter {
     return { success: true, section, ...trackedChangeRefs.length ? { trackedChangeRefs } : {} };
   }
   tableOfContents(input, options) {
+    const guard = beginCanonicalMutation(this.context, options, "create.tableOfContents");
+    if (guard)
+      return createFailure(guard.code, guard.message);
+    const instruction = buildEffectiveTocInstruction(input.instruction, input.config);
+    const locked = guardTocBookmarkInsertion(this.context, instruction, "create.tableOfContents");
+    if (locked)
+      return createFailure(locked.code, locked.message);
     if (options?.changeMode === "tracked") {
-      const guard = beginCanonicalMutation(this.context, options, "create.tableOfContents");
-      if (guard)
-        return createFailure(guard.code, guard.message);
       const paragraphInput = { at: input.at, text: "" };
       const story = resolveStoryTarget(this.context, effectiveStoryLocator(paragraphInput));
       if ("failure" in story)
@@ -346212,7 +346974,7 @@ class V2CreateAdapter {
         ...site,
         storyId: anchor.storyId,
         documentBoundary: input.at?.kind === "documentStart" || input.at?.kind === "documentEnd" ? input.at.kind : undefined,
-        instruction: buildEffectiveTocInstruction(input.instruction, input.config),
+        instruction,
         dryRun: options.dryRun
       });
       if (!inserted.ok)
@@ -346225,6 +346987,8 @@ class V2CreateAdapter {
         toc: { kind: "block", nodeType: "tableOfContents", nodeId: "(dry-run)" }
       };
     }
+    if (this.context.isCollaborativeSession())
+      return createFailure("INVALID_CONTEXT", "create-table-of-contents: unsupported-context");
     const created = this.paragraph({ at: input.at, text: "" }, options);
     if (!created.success) {
       return {
@@ -346233,7 +346997,6 @@ class V2CreateAdapter {
       };
     }
     const nodeId = created.paragraph.nodeId;
-    const instruction = buildEffectiveTocInstruction(input.instruction, input.config);
     const committed = prependTocFieldToGeneratedParagraph(this.context, nodeId, instruction, "create-table-of-contents", undefined, input.at?.kind === "documentStart" || input.at?.kind === "documentEnd" ? input.at.kind : undefined);
     if (!committed.ok)
       return createFailure(committed.code, committed.message);
@@ -346964,107 +347727,6 @@ var init_adapter14 = __esm(() => {
   VALUED_TOC_SWITCHES = new Set(["\\o", "\\n", "\\p", "\\f", "\\l"]);
 });
 
-// ../../../v2/document-api-v2-adapter/dist/formatting/paragraph-property-order.js
-function setParagraphPropertyChild(children2, localName2, xml) {
-  const parsed = parseSingleElement(xml);
-  const existingIndex = children2.findIndex((child) => child.localName === localName2);
-  if (existingIndex >= 0) {
-    const next = [...children2];
-    next[existingIndex] = parsed;
-    return next;
-  }
-  const targetRank = PARAGRAPH_PROPERTY_CHILD_RANK.get(localName2);
-  if (targetRank == null)
-    throw new Error(`Unknown paragraph property child: ${localName2}`);
-  let insertionIndex = 0;
-  for (const [index2, child] of children2.entries()) {
-    const childRank = paragraphPropertyRankRange(child);
-    if (!childRank)
-      continue;
-    if (childRank.minimum > targetRank) {
-      return [...children2.slice(0, index2), parsed, ...children2.slice(index2)];
-    }
-    if (childRank.maximum >= targetRank) {
-      throw new ParagraphPropertyMutationUnavailableError(`Cannot safely insert w:${localName2} within mc:AlternateContent paragraph properties`);
-    }
-    insertionIndex = index2 + 1;
-  }
-  return [...children2.slice(0, insertionIndex), parsed, ...children2.slice(insertionIndex)];
-}
-function paragraphPropertyRankRange(child) {
-  const directRank = PARAGRAPH_PROPERTY_CHILD_RANK.get(child.localName);
-  if (directRank != null)
-    return { minimum: directRank, maximum: directRank };
-  if (child.localName !== "AlternateContent")
-    return null;
-  const alternateContent = parseContainerXml(child.xml, "AlternateContent");
-  if (!alternateContent)
-    return null;
-  const ranks = parseTopLevelChildren(alternateContent.inner).flatMap((branch) => {
-    if (branch.localName !== "Choice" && branch.localName !== "Fallback")
-      return [];
-    const branchContainer = parseContainerXml(branch.xml, branch.localName);
-    if (!branchContainer)
-      return [];
-    return parseTopLevelChildren(branchContainer.inner).flatMap((candidate2) => {
-      const range = paragraphPropertyRankRange(candidate2);
-      return range ? [range.minimum, range.maximum] : [];
-    });
-  });
-  if (ranks.length === 0)
-    return null;
-  return { minimum: Math.min(...ranks), maximum: Math.max(...ranks) };
-}
-var PARAGRAPH_PROPERTY_CHILD_ORDER, PARAGRAPH_PROPERTY_CHILD_RANK, ParagraphPropertyMutationUnavailableError;
-var init_paragraph_property_order = __esm(() => {
-  init_common();
-  PARAGRAPH_PROPERTY_CHILD_ORDER = [
-    "pStyle",
-    "keepNext",
-    "keepLines",
-    "pageBreakBefore",
-    "framePr",
-    "widowControl",
-    "numPr",
-    "suppressLineNumbers",
-    "pBdr",
-    "shd",
-    "tabs",
-    "suppressAutoHyphens",
-    "kinsoku",
-    "wordWrap",
-    "overflowPunct",
-    "topLinePunct",
-    "autoSpaceDE",
-    "autoSpaceDN",
-    "bidi",
-    "adjustRightInd",
-    "snapToGrid",
-    "spacing",
-    "ind",
-    "contextualSpacing",
-    "mirrorIndents",
-    "suppressOverlap",
-    "jc",
-    "textDirection",
-    "textAlignment",
-    "textboxTightWrap",
-    "outlineLvl",
-    "divId",
-    "cnfStyle",
-    "rPr",
-    "sectPr",
-    "pPrChange"
-  ];
-  PARAGRAPH_PROPERTY_CHILD_RANK = new Map(PARAGRAPH_PROPERTY_CHILD_ORDER.map((name, index2) => [name, index2]));
-  ParagraphPropertyMutationUnavailableError = class ParagraphPropertyMutationUnavailableError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "ParagraphPropertyMutationUnavailableError";
-    }
-  };
-});
-
 // ../../../v2/document-api-v2-adapter/dist/formatting/paragraph.js
 function classifyParagraphNodeType(input) {
   if (input.headingLevel > 0)