@beyondwork/docx-react-component 1.0.134 → 1.0.136

package/dist/runtime/document-runtime.cjs

@@ -11011,10 +11011,16 @@ var FormattingContextImpl = class {
   // surface-projection calls `resolveParagraphCascade` on the same
   // paragraph via `resolveParagraph` + numbering resolve + marker-rPr;
   // each of those re-walked the style catalog before.
-  paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  //
+  // Defaults to a per-context instance, but the runtime can supply a
+  // persistent `WeakMap` via `FormattingContextOptions.paragraphCascadeCache`
+  // so unchanged paragraphs don't re-cascade on every keystroke. See the
+  // contract on the option for invalidation semantics.
+  paragraphCascadeCache;
   constructor(doc, opts) {
     this.doc = doc;
     this.opts = opts;
+    this.paragraphCascadeCache = opts.paragraphCascadeCache ?? /* @__PURE__ */ new WeakMap();
     const canonicalTheme = doc.subParts?.canonicalTheme;
     this.theme = opts.themeResolver ?? (canonicalTheme ? new ThemeColorResolver(canonicalTheme) : void 0);
     this.numbering = opts.numberingPrefixResolver ?? createNumberingPrefixResolver(doc.numbering);
@@ -11580,7 +11586,8 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
   const formattingContext = createFormattingContext(document2, {
     ...options.revisionMarkupMode ? { revisionMarkupMode: options.revisionMarkupMode } : {},
     ...options.getEffectiveMarkupMode ? { getEffectiveMarkupMode: options.getEffectiveMarkupMode } : {},
-    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
+    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {},
+    ...options.paragraphCascadeCache ? { paragraphCascadeCache: options.paragraphCascadeCache } : {}
   });
   const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document2);
   const layoutIdentitiesByBlockPath = options.layoutIdentitiesByBlockPath;
@@ -19705,6 +19712,106 @@ function setStartOverride(catalog, numberingInstanceId, level, startAt) {
     overrides: mergeOverride(instance.overrides, { level, startAt })
   };
 }
+function mergeFragmentNumberingCatalog(target, fragment) {
+  const catalog = cloneNumberingCatalog(target);
+  const abstractIdMap = /* @__PURE__ */ new Map();
+  const instanceIdMap = /* @__PURE__ */ new Map();
+  const picBulletIdMap = /* @__PURE__ */ new Map();
+  if (!fragment) {
+    return { catalog, abstractIdMap, instanceIdMap, picBulletIdMap };
+  }
+  for (const [picBulletId, entry] of Object.entries(fragment.numPicBullets ?? {})) {
+    const mappedId = mapPicBulletId(catalog, picBulletId, entry);
+    picBulletIdMap.set(picBulletId, mappedId);
+  }
+  for (const [abstractId, definition] of Object.entries(fragment.abstractDefinitions)) {
+    const mappedId = mapAbstractDefinition(catalog, definition, picBulletIdMap);
+    abstractIdMap.set(abstractId, mappedId);
+  }
+  for (const [instanceId, instance] of Object.entries(fragment.instances)) {
+    const mappedAbstractId = abstractIdMap.get(instance.abstractNumberingId) ?? instance.abstractNumberingId;
+    const mappedId = mapNumberingInstance(
+      catalog,
+      instance,
+      mappedAbstractId,
+      picBulletIdMap
+    );
+    instanceIdMap.set(instanceId, mappedId);
+  }
+  return { catalog, abstractIdMap, instanceIdMap, picBulletIdMap };
+}
+function mapPicBulletId(catalog, picBulletId, entry) {
+  const existing = catalog.numPicBullets?.[picBulletId];
+  if (existing && existing.rawXml === entry.rawXml) return picBulletId;
+  const mappedId = existing ? nextNumericString(Object.keys(catalog.numPicBullets ?? {})) : picBulletId;
+  const numPicBullets = { ...catalog.numPicBullets ?? {} };
+  numPicBullets[mappedId] = {
+    ...stripSourceRef(structuredClone(entry)),
+    numPicBulletId: mappedId
+  };
+  catalog.numPicBullets = numPicBullets;
+  return mappedId;
+}
+function mapAbstractDefinition(catalog, definition, picBulletIdMap) {
+  const existing = catalog.abstractDefinitions[definition.abstractNumberingId];
+  if (existing && sameJson(comparableAbstract(existing), comparableAbstract(definition))) {
+    return definition.abstractNumberingId;
+  }
+  const mappedId = existing ? nextCanonicalNumericId("abstract-num:", Object.keys(catalog.abstractDefinitions)) : definition.abstractNumberingId;
+  catalog.abstractDefinitions[mappedId] = {
+    ...stripSourceRef(structuredClone(definition)),
+    abstractNumberingId: mappedId,
+    nsid: freshLongHex(catalog, mappedId, "nsid"),
+    tplc: freshLongHex(catalog, mappedId, "tmpl"),
+    levels: definition.levels.map((level) => remapLevelPicBullet(level, picBulletIdMap))
+  };
+  return mappedId;
+}
+function mapNumberingInstance(catalog, instance, abstractNumberingId, picBulletIdMap) {
+  const existing = catalog.instances[instance.numberingInstanceId];
+  const candidate = {
+    ...instance,
+    abstractNumberingId,
+    overrides: instance.overrides.map(
+      (override) => remapOverridePicBullet(override, picBulletIdMap)
+    )
+  };
+  if (existing && sameJson(comparableInstance(existing), comparableInstance(candidate))) {
+    return instance.numberingInstanceId;
+  }
+  const mappedId = existing ? nextCanonicalNumericId("num:", Object.keys(catalog.instances)) : instance.numberingInstanceId;
+  catalog.instances[mappedId] = {
+    ...stripSourceRef(structuredClone(instance)),
+    overrides: candidate.overrides.map((override) => stripOverrideSourceRefs(override)),
+    numberingInstanceId: mappedId,
+    abstractNumberingId
+  };
+  return mappedId;
+}
+function remapLevelPicBullet(level, picBulletIdMap) {
+  const cloned = stripSourceRef(structuredClone(level));
+  if (!level.picBulletId) return cloned;
+  return {
+    ...cloned,
+    picBulletId: picBulletIdMap.get(level.picBulletId) ?? level.picBulletId
+  };
+}
+function remapOverridePicBullet(override, picBulletIdMap) {
+  const cloned = stripOverrideSourceRefs(structuredClone(override));
+  if (!override.levelDefinition) return cloned;
+  return {
+    ...cloned,
+    levelDefinition: remapLevelPicBullet(override.levelDefinition, picBulletIdMap)
+  };
+}
+function stripOverrideSourceRefs(override) {
+  const cloned = stripSourceRef(override);
+  if (!override.levelDefinition) return cloned;
+  return {
+    ...cloned,
+    levelDefinition: stripSourceRef(override.levelDefinition)
+  };
+}
 function mergeOverride(overrides, nextOverride) {
   return [
     ...overrides.filter((override) => override.level !== nextOverride.level),
@@ -19776,6 +19883,28 @@ function hashLongHex(input) {
   }
   return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
 }
+function stripSourceRef(value) {
+  const { sourceRef: _sourceRef, ...rest } = value;
+  return rest;
+}
+function comparableAbstract(definition) {
+  return {
+    ...stripSourceRef(definition),
+    levels: definition.levels.map((level) => stripSourceRef(level))
+  };
+}
+function comparableInstance(instance) {
+  return {
+    ...stripSourceRef(instance),
+    overrides: instance.overrides.map((override) => ({
+      ...stripSourceRef(override),
+      ...override.levelDefinition ? { levelDefinition: stripSourceRef(override.levelDefinition) } : {}
+    }))
+  };
+}
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 
 // src/core/commands/list-commands.ts
 function toggleNumberedList(document2, paragraphIndexes, context, options = {}) {
@@ -19814,7 +19943,7 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -19836,8 +19965,13 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
   );
   setStartOverride(catalog, numberingInstanceId, target.numbering.level, startAt);
   const affectedParagraphIndexes = [];
+  const targetStoryKey = paragraphs[resolvedParagraphIndex]?.storyKey;
   for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== targetStoryKey) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       break;
     }
@@ -19881,7 +20015,7 @@ function continueNumbering(document2, paragraphIndex, context, options = {}) {
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -19910,8 +20044,13 @@ function continueNumbering(document2, paragraphIndex, context, options = {}) {
     };
   }
   const affectedParagraphIndexes = [];
+  const targetStoryKey = paragraphs[resolvedParagraphIndex]?.storyKey;
   for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== targetStoryKey) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       break;
     }
@@ -19957,12 +20096,13 @@ function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   }
   const catalog = cloneNumberingCatalog(working.numbering);
   const allAlreadyKind = normalizedIndexes.every((index) => {
-    const paragraph = paragraphs[index];
-    return paragraph.numbering ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind : false;
+    const paragraph = paragraphs[index]?.paragraph;
+    return paragraph?.numbering ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind : false;
   });
   if (allAlreadyKind) {
     for (const index of normalizedIndexes) {
-      delete paragraphs[index].numbering;
+      const paragraph = paragraphs[index]?.paragraph;
+      if (paragraph) delete paragraph.numbering;
     }
     working.numbering = catalog;
     return {
@@ -19972,7 +20112,8 @@ function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   }
   const numberingInstanceId = findAdjacentCompatibleInstance(paragraphs, catalog, normalizedIndexes[0], kind) ?? ensureDefaultListInstance(catalog, kind);
   for (const index of normalizedIndexes) {
-    const paragraph = paragraphs[index];
+    const paragraph = paragraphs[index]?.paragraph;
+    if (!paragraph) continue;
     paragraph.numbering = {
       numberingInstanceId,
       level: clampLevel(paragraph.numbering?.level ?? 0)
@@ -20003,10 +20144,11 @@ function adjustListLevels(document2, paragraphIndexes, delta, context, options)
     };
   }
   const affectedParagraphIndexes = resolved.paragraphIndexes.filter(
-    (index) => Boolean(paragraphs[index]?.numbering)
+    (index) => Boolean(paragraphs[index]?.paragraph.numbering)
   );
   for (const index of affectedParagraphIndexes) {
-    const paragraph = paragraphs[index];
+    const paragraph = paragraphs[index]?.paragraph;
+    if (!paragraph) continue;
     if (!paragraph.numbering) {
       continue;
     }
@@ -20026,17 +20168,21 @@ function normalizeListCommandTargets(options) {
 }
 function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphIndexes, context, editableTargets) {
   if (editableTargets.length === 0) {
-    return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, paragraphIndexes) };
+    return {
+      paragraphIndexes: normalizeParagraphIndexesForStory(
+        paragraphs,
+        paragraphIndexes,
+        context.activeStoryKey
+      )
+    };
   }
   const currentTargets = collectEditableTargetRefs(document2, context.editableTargetCache);
-  const paragraphIndexByTargetKey = /* @__PURE__ */ new Map();
-  let paragraphIndex = 0;
-  for (const target of currentTargets) {
-    if (!isParagraphTextTarget(target)) continue;
-    if (!paragraphIndexByTargetKey.has(target.targetKey)) {
-      paragraphIndexByTargetKey.set(target.targetKey, paragraphIndex);
-      paragraphIndex += 1;
-    }
+  const paragraphIndexByAddress = /* @__PURE__ */ new Map();
+  for (let index = 0; index < paragraphs.length; index += 1) {
+    const entry = paragraphs[index];
+    if (!entry) continue;
+    paragraphIndexByAddress.set(`${entry.storyKey}
+${entry.blockPath}`, index);
   }
   const resolvedIndexes = [];
   for (const target of editableTargets) {
@@ -20061,7 +20207,8 @@ function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphInde
         }
       };
     }
-    const currentIndex = paragraphIndexByTargetKey.get(current.targetKey);
+    const currentIndex = paragraphIndexByAddress.get(`${current.storyKey}
+${current.blockPath}`);
     if (currentIndex === void 0) {
       return {
         paragraphIndexes: [],
@@ -20136,18 +20283,28 @@ function sortJson(value) {
   return value;
 }
 function findAdjacentCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
+  const current = paragraphs[fromIndex];
   const previous = paragraphs[fromIndex - 1];
-  if (previous?.numbering) {
-    const previousKind = getListKind(catalog, previous.numbering.numberingInstanceId);
+  if (previous?.storyKey !== current?.storyKey) {
+    return void 0;
+  }
+  const previousParagraph = previous?.paragraph;
+  if (previousParagraph?.numbering) {
+    const previousKind = getListKind(catalog, previousParagraph.numbering.numberingInstanceId);
     if (previousKind === kind) {
-      return previous.numbering.numberingInstanceId;
+      return previousParagraph.numbering.numberingInstanceId;
     }
   }
   return void 0;
 }
 function findPreviousCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
+  const storyKey2 = paragraphs[fromIndex]?.storyKey;
   for (let index = fromIndex - 1; index >= 0; index -= 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== storyKey2) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       continue;
     }
@@ -20166,7 +20323,14 @@ function cloneEnvelope(document2, timestamp) {
 function captureEditableParagraphs(document2) {
   if (isDocumentRoot(document2.content)) {
     const paragraphs = [];
-    collectEditableParagraphs(document2.content.children, paragraphs);
+    for (const context of collectStoryBlockContexts(document2)) {
+      collectEditableParagraphs(
+        context.blocks,
+        paragraphs,
+        context.storyKey,
+        context.basePath
+      );
+    }
     return paragraphs;
   }
   const fallback = {
@@ -20174,23 +20338,39 @@ function captureEditableParagraphs(document2) {
     children: [{ type: "paragraph", children: [] }]
   };
   document2.content = fallback;
-  return fallback.children;
+  return [{
+    paragraph: fallback.children[0],
+    storyKey: "main",
+    blockPath: "main/block[0]"
+  }];
 }
-function collectEditableParagraphs(blocks, output) {
-  for (const block of blocks) {
+function collectEditableParagraphs(blocks, output, storyKey2, basePath) {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
     switch (block.type) {
       case "paragraph":
-        output.push(block);
+        output.push({ paragraph: block, storyKey: storyKey2, blockPath });
         break;
       case "table":
-        for (const row2 of block.rows) {
-          for (const cell of row2.cells) {
-            collectEditableParagraphs(cell.children, output);
+        for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+          const row2 = block.rows[rowIndex];
+          if (!row2) continue;
+          for (let cellIndex = 0; cellIndex < row2.cells.length; cellIndex += 1) {
+            const cell = row2.cells[cellIndex];
+            if (!cell) continue;
+            collectEditableParagraphs(
+              cell.children,
+              output,
+              storyKey2,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`
+            );
           }
         }
         break;
       case "sdt":
-        collectEditableParagraphs(block.children, output);
+        collectEditableParagraphs(block.children, output, storyKey2, blockPath);
         break;
       case "custom_xml":
         break;
@@ -20202,6 +20382,18 @@ function collectEditableParagraphs(blocks, output) {
 function normalizeParagraphIndexes(paragraphs, paragraphIndexes) {
   return [...new Set(paragraphIndexes)].filter((index) => Number.isInteger(index) && index >= 0 && index < paragraphs.length).sort((left, right) => left - right);
 }
+function normalizeParagraphIndexesForStory(paragraphs, paragraphIndexes, storyKey2) {
+  if (storyKey2 === void 0) {
+    return normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+  }
+  const storyParagraphIndexes = [];
+  for (let index = 0; index < paragraphs.length; index += 1) {
+    if (paragraphs[index]?.storyKey === storyKey2) {
+      storyParagraphIndexes.push(index);
+    }
+  }
+  return [...new Set(paragraphIndexes)].filter((index) => Number.isInteger(index) && index >= 0 && index < storyParagraphIndexes.length).map((index) => storyParagraphIndexes[index]).sort((left, right) => left - right);
+}
 function clampLevel(level) {
   return Math.max(0, Math.min(8, level));
 }
@@ -20883,8 +21075,9 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     workingDocument = collapseResult.document;
     workingSelection = collapseResult.selection;
     if (context.textTarget?.kind === "table-paragraph" || context.textTarget?.kind === "text-leaf") {
+      const { precomputedSurface: _precomputedSurface, ...contextWithoutPrecomputedSurface } = context;
       workingContext = {
-        ...context,
+        ...contextWithoutPrecomputedSurface,
         textTarget: {
           ...context.textTarget,
           paragraphEnd: Math.max(
@@ -20896,7 +21089,11 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     }
   }
   const splitResult = splitParagraph(workingDocument, workingSelection, workingContext);
-  const splitRoot = splitResult.document.content;
+  const preparedFragment = prepareFragmentNumberingForInsertion(
+    splitResult.document,
+    fragment
+  );
+  const splitRoot = preparedFragment.document.content;
   if (!splitRoot || splitRoot.type !== "doc") {
     return {
       changed: false,
@@ -20907,9 +21104,9 @@ function applyFragmentInsert(document2, selection, fragment, context) {
   const targetedBlockPath = workingContext.textTarget?.kind === "table-paragraph" || workingContext.textTarget?.kind === "text-leaf" ? workingContext.textTarget.blockPath : void 0;
   if (targetedBlockPath) {
     const targeted = insertFragmentBlocksAfterPath(
-      splitResult.document,
+      preparedFragment.document,
       targetedBlockPath,
-      fragment.blocks
+      preparedFragment.blocks
     );
     if (targeted) {
       return {
@@ -20941,7 +21138,7 @@ function applyFragmentInsert(document2, selection, fragment, context) {
   const rightHalfIndex = scope.blockIndex + 1;
   const splicedChildren = [
     ...splitRoot.children.slice(0, rightHalfIndex),
-    ...fragment.blocks.map((block) => cloneBlock(block)),
+    ...preparedFragment.blocks.map((block) => cloneBlock(block)),
     ...splitRoot.children.slice(rightHalfIndex)
   ];
   const nextRoot = {
@@ -20949,7 +21146,7 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     children: splicedChildren
   };
   const nextDocument = {
-    ...splitResult.document,
+    ...preparedFragment.document,
     updatedAt: context.timestamp,
     content: nextRoot
   };
@@ -20961,14 +21158,47 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     mapping: createEmptyMapping()
   };
 }
-function cloneBlock(block) {
-  if (block.type === "paragraph") {
-    return {
-      ...block,
-      children: block.children.map((child) => ({ ...child }))
+function prepareFragmentNumberingForInsertion(document2, fragment) {
+  if (!fragment.numbering) {
+    return { document: document2, blocks: fragment.blocks };
+  }
+  const merged = mergeFragmentNumberingCatalog(document2.numbering, fragment.numbering);
+  return {
+    document: {
+      ...document2,
+      numbering: merged.catalog
+    },
+    blocks: fragment.blocks.map((block) => cloneBlock(block, merged.instanceIdMap))
+  };
+}
+function cloneBlock(block, numberingInstanceIdMap) {
+  const cloned = structuredClone(block);
+  remapNumberingReferences(cloned, numberingInstanceIdMap);
+  return cloned;
+}
+function remapNumberingReferences(value, numberingInstanceIdMap) {
+  if (!numberingInstanceIdMap?.size || !value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      remapNumberingReferences(entry, numberingInstanceIdMap);
+    }
+    return;
+  }
+  const record = value;
+  if (record.numbering?.numberingInstanceId) {
+    const mappedId = numberingInstanceIdMap.get(record.numbering.numberingInstanceId) ?? record.numbering.numberingInstanceId;
+    record.numbering = {
+      ...record.numbering,
+      numberingInstanceId: mappedId
     };
   }
-  return JSON.parse(JSON.stringify(block));
+  remapNumberingReferences(record.children, numberingInstanceIdMap);
+  remapNumberingReferences(record.rows, numberingInstanceIdMap);
+  remapNumberingReferences(record.cells, numberingInstanceIdMap);
+  remapNumberingReferences(record.txbxBlocks, numberingInstanceIdMap);
+  remapNumberingReferences(record.content, numberingInstanceIdMap);
 }
 function insertFragmentBlocksAfterPath(document2, blockPath, fragmentBlocks) {
   const tokens = parseCanonicalBlockPath2(blockPath);
@@ -41526,6 +41756,8 @@ function buildSearchPattern(query, options = {}) {
 function findSearchMatches(text, query, options = {}) {
   const pattern = buildSearchPattern(query, options);
   if (!pattern) return [];
+  const limit = normalizeSearchLimit(options.limit);
+  if (limit === 0) return [];
   const results = [];
   let match;
   pattern.lastIndex = 0;
@@ -41536,12 +41768,21 @@ function findSearchMatches(text, query, options = {}) {
       text: match[0],
       index: results.length
     });
+    if (results.length >= limit) {
+      break;
+    }
     if (match[0].length === 0) {
       pattern.lastIndex += 1;
     }
   }
   return results;
 }
+function normalizeSearchLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, Math.floor(limit));
+}
 function createSearchExcerpt(text, from, to, radius = 24) {
   const safeFrom = Math.max(0, Math.min(from, text.length));
   const safeTo = Math.max(safeFrom, Math.min(to, text.length));
@@ -49174,6 +49415,16 @@ function coerceIssueValue2(value) {
 function insertScopeMarkers(document2, params) {
   const { scopeId } = params;
   const root = document2.content;
+  if (!Number.isFinite(params.from) || !Number.isFinite(params.to)) {
+    const from = Number.isFinite(params.from) ? params.from : 0;
+    const to = Number.isFinite(params.to) ? params.to : from;
+    return {
+      status: "non-finite-range",
+      scopeId,
+      from,
+      to
+    };
+  }
   const normalizedFrom = Math.min(params.from, params.to);
   const normalizedTo = Math.max(params.from, params.to);
   if (!root || root.type !== "doc" || root.children.length === 0) {
@@ -49626,6 +49877,14 @@ function isRecord3(value) {
 }
 
 // src/runtime/workflow/coordinator.ts
+function createScopeMarkerMutationMapping() {
+  return {
+    steps: [],
+    metadata: {
+      layoutNeutralScopeMarkers: true
+    }
+  };
+}
 var MODE_RESTRICTIVENESS = {
   edit: 0,
   suggest: 1,
@@ -49933,6 +50192,60 @@ function createWorkflowCoordinator(deps) {
       activeStory: deps.getActiveStory()
     };
   }
+  function createPlantFailureResult(input) {
+    const { scopeId, anchor, assoc, plantResult } = input;
+    return {
+      scopeId: "",
+      anchor: {
+        kind: "range",
+        from: anchor.from,
+        to: anchor.to,
+        assoc
+      },
+      plantStatus: {
+        planted: false,
+        reason: plantResult.status,
+        ...plantResult.status === "non-paragraph-target" ? {
+          blockIndex: plantResult.blockIndex,
+          blockKind: plantResult.blockKind
+        } : {},
+        ...plantResult.status === "range-out-of-bounds" ? { storyLength: plantResult.storyLength } : {},
+        requestedFrom: plantResult.from,
+        requestedTo: plantResult.to
+      }
+    };
+  }
+  function buildWorkflowScope(input) {
+    const { params, scopeId, publicAnchor } = input;
+    return {
+      scopeId,
+      mode: params.mode ?? "comment",
+      anchor: publicAnchor,
+      ...params.storyTarget ? { storyTarget: params.storyTarget } : {},
+      ...params.label ? { label: params.label } : {},
+      ...params.visibility ? { visibility: params.visibility } : {},
+      ...params.guardPolicy ? { guardPolicy: params.guardPolicy } : {},
+      ...params.scopeMetadataFields && params.scopeMetadataFields.length > 0 ? { metadata: [...params.scopeMetadataFields] } : {}
+    };
+  }
+  function buildWorkflowMetadataEntry(input) {
+    const { params, scopeId, publicAnchor } = input;
+    if (!params.persistence || params.persistence === "runtime-only") return null;
+    const requestedMetadata = params.metadata ?? {};
+    const entryPersistence = requestedMetadata.metadataPersistence ?? (params.persistence === "session" ? "external" : "internal");
+    return {
+      entryId: requestedMetadata.entryId ?? `scope-metadata-${scopeId}`,
+      metadataId: requestedMetadata.metadataId ?? "workflow.scope",
+      anchor: publicAnchor,
+      ...params.storyTarget ? { storyTarget: params.storyTarget } : {},
+      scopeId,
+      ...requestedMetadata.workItemId ? { workItemId: requestedMetadata.workItemId } : {},
+      ...requestedMetadata.value !== void 0 ? { value: requestedMetadata.value } : params.persistence === "document-metadata" && params.label ? { value: { label: params.label } } : {},
+      metadataPersistence: entryPersistence,
+      ...requestedMetadata.storageRef !== void 0 ? { storageRef: requestedMetadata.storageRef } : {},
+      ...requestedMetadata.metadataVersion !== void 0 ? { metadataVersion: requestedMetadata.metadataVersion } : {}
+    };
+  }
   function addScope(params) {
     const state = deps.getState();
     const scopeId = params.scopeId ?? `scope-${clock().replace(/[^0-9]/gu, "")}-${Math.floor(Math.random() * 1e6)}`;
@@ -49975,6 +50288,7 @@ function createWorkflowCoordinator(deps) {
     deps.dispatch({
       type: "document.replace",
       document: nextDocument,
+      mapping: createScopeMarkerMutationMapping(),
       origin: { source: "api", at: clock() }
     });
     const callerAssoc = params.anchor.kind === "range" ? params.anchor.assoc : { start: -1, end: 1 };
@@ -50031,6 +50345,84 @@ function createWorkflowCoordinator(deps) {
     }
     return { scopeId, anchor: publicAnchor };
   }
+  function addScopes(paramsList) {
+    if (paramsList.length === 0) return [];
+    let nextDocument = deps.getDocument();
+    let documentChanged = false;
+    const results = [];
+    const scopesToAdd = [];
+    const metadataEntriesToAdd = [];
+    const newScopeIds = /* @__PURE__ */ new Set();
+    for (const params of paramsList) {
+      const scopeId = params.scopeId ?? `scope-${clock().replace(/[^0-9]/gu, "")}-${Math.floor(Math.random() * 1e6)}`;
+      const anchor = params.anchor.kind === "range" ? { from: params.anchor.from, to: params.anchor.to } : null;
+      if (!anchor) {
+        results.push({ scopeId, anchor: params.anchor });
+        continue;
+      }
+      const callerAssoc = params.anchor.kind === "range" ? params.anchor.assoc : { start: -1, end: 1 };
+      const plantResult = insertScopeMarkers(nextDocument, {
+        scopeId,
+        from: anchor.from,
+        to: anchor.to
+      });
+      if (plantResult.status !== "planted") {
+        results.push(
+          createPlantFailureResult({
+            scopeId,
+            anchor,
+            assoc: callerAssoc,
+            plantResult
+          })
+        );
+        continue;
+      }
+      nextDocument = plantResult.document;
+      documentChanged = true;
+      const publicAnchor = {
+        kind: "range",
+        from: plantResult.plantedRange.from,
+        to: plantResult.plantedRange.to,
+        assoc: callerAssoc
+      };
+      newScopeIds.add(scopeId);
+      scopesToAdd.push(buildWorkflowScope({ params, scopeId, publicAnchor }));
+      const entry = buildWorkflowMetadataEntry({ params, scopeId, publicAnchor });
+      if (entry) metadataEntriesToAdd.push(entry);
+      results.push({ scopeId, anchor: publicAnchor });
+    }
+    if (documentChanged) {
+      deps.dispatch({
+        type: "document.replace",
+        document: nextDocument,
+        mapping: createScopeMarkerMutationMapping(),
+        origin: { source: "api", at: clock() }
+      });
+    }
+    if (scopesToAdd.length > 0) {
+      const currentOverlay = overlayStore.getOverlay() ?? {
+        overlayVersion: "workflow-overlay/1",
+        scopes: []
+      };
+      const existingScopes = currentOverlay.scopes.filter(
+        (existing) => !newScopeIds.has(existing.scopeId)
+      );
+      deps.dispatch({
+        type: "workflow.set-overlay",
+        overlay: { ...currentOverlay, scopes: [...existingScopes, ...scopesToAdd] },
+        origin: { source: "api", at: clock() }
+      });
+    }
+    if (metadataEntriesToAdd.length > 0) {
+      const priorEntries = overlayStore.getMetadataEntries();
+      deps.dispatch({
+        type: "workflow.set-metadata-entries",
+        entries: [...priorEntries, ...metadataEntriesToAdd],
+        origin: { source: "api", at: clock() }
+      });
+    }
+    return results;
+  }
   function removeScope(scopeId) {
     const overlay = overlayStore.getOverlay();
     if (overlay) {
@@ -50048,6 +50440,7 @@ function createWorkflowCoordinator(deps) {
       deps.dispatch({
         type: "document.replace",
         document: nextDocument,
+        mapping: createScopeMarkerMutationMapping(),
         origin: { source: "api", at: clock() }
       });
     }
@@ -50441,6 +50834,7 @@ function createWorkflowCoordinator(deps) {
   }
   return {
     addScope,
+    addScopes,
     removeScope,
     addInvisibleScope,
     setScopeVisibility,
@@ -56210,6 +56604,36 @@ function createDocumentRuntime(options) {
   let viewportBlockRanges = null;
   let viewportRangesKey = serializeViewportRanges(viewportBlockRanges);
   let viewportBlocksPerPageEstimate = null;
+  let fullSurfaceWarmupScheduled = false;
+  let fullSurfaceWarmupCompleted = false;
+  function scheduleFullSurfaceWarmupAfterCull() {
+    if (fullSurfaceWarmupScheduled || fullSurfaceWarmupCompleted) return;
+    fullSurfaceWarmupScheduled = true;
+    perfCounters.increment("surface.fullSurfaceWarmup.scheduled");
+    runOnIdle(() => {
+      fullSurfaceWarmupScheduled = false;
+      if (cachedFullSurface) {
+        perfCounters.increment("surface.fullSurfaceWarmup.alreadyCached");
+        fullSurfaceWarmupCompleted = true;
+        return;
+      }
+      const t0 = performance.now();
+      try {
+        getCachedFullSurface(state.document, activeStory);
+        fullSurfaceWarmupCompleted = true;
+        perfCounters.increment("surface.fullSurfaceWarmup.committed");
+      } catch (error) {
+        perfCounters.increment("surface.fullSurfaceWarmup.failed");
+        fullSurfaceWarmupCompleted = false;
+        void error;
+      } finally {
+        perfCounters.increment(
+          "surface.fullSurfaceWarmup.us",
+          Math.round((performance.now() - t0) * 1e3)
+        );
+      }
+    });
+  }
   const getRuntimeForLayoutFacet = () => {
     if (!runtimeRef) {
       throw new Error("Document runtime viewport methods are not initialized");
@@ -56402,6 +56826,15 @@ function createDocumentRuntime(options) {
   let cachedSurface;
   let cachedFullSurface;
   const editableTargetBlockCache = createEditableTargetBlockCache();
+  let paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  let paragraphCascadeCacheStylesRef = null;
+  function ensureParagraphCascadeCacheForStyles(nextStyles) {
+    if (paragraphCascadeCacheStylesRef !== nextStyles) {
+      paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+      paragraphCascadeCacheStylesRef = nextStyles;
+    }
+    return paragraphCascadeCache;
+  }
   let cachedEditableTargetMap = null;
   function getEditableTargetsByBlockPath(document2) {
     if (cachedEditableTargetMap !== null && cachedEditableTargetMap.document === document2) {
@@ -56455,6 +56888,7 @@ function createDocumentRuntime(options) {
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: null,
       editableTargetsByBlockPath: getEditableTargetsByBlockPath(document2),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -56495,6 +56929,7 @@ function createDocumentRuntime(options) {
         activeStoryKey,
         surfaceViewportRanges
       ),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -56706,7 +57141,17 @@ function createDocumentRuntime(options) {
     }
   }
   function tryPatchNestedLocalTextSurface(previousSurface, editFrom, editTo, insertedText) {
-    const shiftBudget = estimateLocalTextPatchShiftBudget(previousSurface.blocks, 0);
+    const containerIndex = previousSurface.blocks.findIndex(
+      (block) => editFrom >= block.from && editTo <= block.to
+    );
+    if (containerIndex < 0) {
+      perfCounters.increment("surface.localText.patchMiss");
+      return null;
+    }
+    const shiftBudget = estimateLocalTextPatchShiftBudget(
+      previousSurface.blocks,
+      containerIndex + 1
+    );
     perfCounters.increment("surface.localText.shiftedBlocks", shiftBudget.shiftedBlocks);
     perfCounters.increment("surface.localText.shiftedNodes", shiftBudget.shiftedNodes);
     if (!shiftBudget.withinBudget) {
@@ -56786,19 +57231,9 @@ function createDocumentRuntime(options) {
     for (let index = startIndex; index < blocks.length; index += 1) {
       const shiftedBlockNodes = countSurfaceShiftNodesUpTo(
         blocks[index],
-        Math.min(
-          policy.maxShiftedNodesPerBlock,
-          policy.maxShiftedSurfaceNodes - shiftedNodes
-        ) + 1
+        policy.maxShiftedSurfaceNodes - shiftedNodes + 1
       );
       shiftedNodes += shiftedBlockNodes;
-      if (shiftedBlockNodes > policy.maxShiftedNodesPerBlock) {
-        return {
-          shiftedBlocks,
-          shiftedNodes,
-          withinBudget: false
-        };
-      }
       if (shiftedNodes > policy.maxShiftedSurfaceNodes) {
         return {
           shiftedBlocks,
@@ -57470,6 +57905,9 @@ function createDocumentRuntime(options) {
         viewportBlockRangesOverride: firstSurfaceViewportBlockRanges
       }) : getCachedSurface(state.document, activeStory)
     );
+    if (firstSurfaceViewportBlockRanges) {
+      scheduleFullSurfaceWarmupAfterCull();
+    }
     const snapshot = {
       documentId: state.documentId,
       sessionId: state.sessionId,
@@ -57583,6 +58021,9 @@ function createDocumentRuntime(options) {
           activeStoryKey,
           viewportBlockRanges
         ),
+        paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(
+          state.document.styles
+        ),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
@@ -58234,6 +58675,17 @@ function createDocumentRuntime(options) {
           };
           resolvedReplayTextTarget = prepared.textTarget;
         } else {
+          const listBoundaryJoinCommand = createListItemBoundaryJoinReplayCommand({
+            command,
+            document: replayState.document,
+            selection: replayState.selection,
+            surface: replaySnapshot.surface?.blocks ?? [],
+            storyTarget: replayStory,
+            timestamp: context.timestamp
+          });
+          if (listBoundaryJoinCommand) {
+            executableCommand = listBoundaryJoinCommand;
+          }
           const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
             command,
             document: replayState.document,
@@ -58391,6 +58843,17 @@ function createDocumentRuntime(options) {
             };
             resolvedReplayTextTarget = prepared.textTarget;
           } else {
+            const listBoundaryJoinCommand = createListItemBoundaryJoinReplayCommand({
+              command,
+              document: stateForCommand.document,
+              selection: stateForCommand.selection,
+              surface: snapshotForCommand.surface?.blocks ?? [],
+              storyTarget: replayStory,
+              timestamp: context.timestamp
+            });
+            if (listBoundaryJoinCommand) {
+              executableCommand = listBoundaryJoinCommand;
+            }
             const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
               command,
               document: stateForCommand.document,
@@ -59420,6 +59883,9 @@ function createDocumentRuntime(options) {
     addScope(params) {
       return workflowCoordinator.addScope(params);
     },
+    addScopes(params) {
+      return workflowCoordinator.addScopes(params);
+    },
     getScope(scopeId) {
       return workflowCoordinator.getScope(scopeId);
     },
@@ -60403,6 +60869,9 @@ function createDocumentRuntime(options) {
     if (transaction.mapping.metadata?.scopeTagTouches) return false;
     return getLocalTextPatchMetadata(transaction.mapping) !== null;
   }
+  function isLayoutNeutralScopeMarkerCommit(previous, next, transaction) {
+    return transaction.markDirty && previous.document !== next.document && transaction.mapping.steps.length === 0 && transaction.mapping.metadata?.layoutNeutralScopeMarkers === true;
+  }
   function applyTransactionToState(transaction, options2 = {}) {
     const effects = transaction.effects;
     const selectionUnchanged = transaction.nextState.selection === state.selection;
@@ -60431,6 +60900,11 @@ function createDocumentRuntime(options) {
       transaction,
       transaction.effects
     );
+    const layoutNeutralScopeMarkerCommit = isLayoutNeutralScopeMarkerCommit(
+      previous,
+      state,
+      transaction
+    );
     perfCounters.increment("commit.refreshClassify.us", Math.round((performance.now() - tClassify0) * 1e3));
     const tOverlay0 = performance.now();
     const skipOverlaySync = useLocalTextCommitSnapshot && canSkipOverlaySyncForLocalText(transaction);
@@ -60479,9 +60953,12 @@ function createDocumentRuntime(options) {
         ...detachedWorkflowScopeWarnings.cleared
       ]
     };
-    if (!useLocalTextCommitSnapshot && transaction.markDirty && previous.document !== state.document) {
+    if (!useLocalTextCommitSnapshot && !layoutNeutralScopeMarkerCommit && transaction.markDirty && previous.document !== state.document) {
       applyViewportRanges(getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface));
     }
+    if (layoutNeutralScopeMarkerCommit && viewportBlockRanges !== null) {
+      getCachedFullSurface(state.document, activeStory);
+    }
     const tValidation0 = performance.now();
     const patchSourceSurface = getReusableCachedFullSurface(previous.document, activeStory) ?? cachedRenderSnapshot.surface;
     const patchedFullLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(patchSourceSurface, transaction.mapping) : null;
@@ -60850,15 +61327,49 @@ function createDocumentRuntime(options) {
     const preSelection = selection;
     const preActiveStory = activeStory;
     const priorDocument = state.document;
+    const listBoundaryJoin = createListItemBoundaryJoinReplacement({
+      command: commandForDispatch,
+      document: state.document,
+      editableTarget,
+      selection,
+      storyTarget: activeStory,
+      targetResolution,
+      timestamp
+    });
+    if (listBoundaryJoin && context.documentMode !== "suggesting") {
+      const replacementCommand = {
+        type: "document.replace",
+        document: listBoundaryJoin.document,
+        selection: listBoundaryJoin.selection,
+        mapping: listBoundaryJoin.mapping,
+        protectionSelection: selection,
+        origin: commandForDispatch.origin
+      };
+      const transaction = executeEditorCommand(baseState, replacementCommand, context);
+      commit(transaction);
+      options.onCommandApplied?.(commandForDispatch, transaction, context, {
+        preSelection,
+        activeStory: preActiveStory,
+        priorDocument
+      });
+      return completeDispatch(classifyAck({
+        command: commandForDispatch,
+        opId,
+        priorState: baseState,
+        transaction,
+        newRevisionToken: state.revisionToken
+      }));
+    }
     const selectedListItemDelete = createSelectedListItemDeleteReplacement({
       command: commandForDispatch,
       document: state.document,
       editableTarget,
       selection,
+      storyTarget: activeStory,
       targetResolution,
       timestamp
     });
-    if (selectedListItemDelete && activeStory.kind === "main" && context.documentMode !== "suggesting") {
+    if (selectedListItemDelete && context.documentMode !== "suggesting") {
       const replacementCommand = {
         type: "document.replace",
         document: selectedListItemDelete.document,
@@ -61123,6 +61634,9 @@ function createDocumentRuntime(options) {
     });
   }
   function scheduleIdleContextAnalytics(callback) {
+    runOnIdle(callback);
+  }
+  function runOnIdle(callback) {
     const requestIdle = globalThis.requestIdleCallback;
     if (typeof requestIdle === "function") {
       requestIdle(callback, { timeout: 250 });
@@ -63762,8 +64276,58 @@ function stripStoryTarget(selection) {
 function isTopLevelMainStoryBlockPath(blockPath) {
   return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
 }
+function createListItemBoundaryJoinReplacement(input) {
+  const { command, document: document2, editableTarget, selection, storyTarget, targetResolution, timestamp } = input;
+  const direction = listItemBoundaryJoinDirection(command, selection, targetResolution);
+  if (!direction || editableTarget?.listAddress?.operationScope !== "list-text" || targetResolution?.kind !== "accepted") {
+    return null;
+  }
+  const storyBlocks = getStoryBlocks(document2, storyTarget);
+  const replacement = joinNumberedParagraphAtStoryPath(
+    storyBlocks,
+    editableTarget.blockPath,
+    storyTarget,
+    direction
+  );
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = replaceStoryBlocks({
+    ...document2,
+    updatedAt: timestamp
+  }, storyTarget, replacement.blocks);
+  const deletedFrom = direction === "backward" ? Math.max(0, selection.anchor - 1) : selection.anchor;
+  const deletedTo = direction === "backward" ? selection.anchor : selection.anchor + 1;
+  const nextAnchor = direction === "backward" ? deletedFrom : selection.anchor;
+  return {
+    document: nextDocument,
+    selection: createSelectionSnapshot(nextAnchor, nextAnchor),
+    mapping: {
+      steps: [{
+        from: deletedFrom,
+        to: deletedTo,
+        insertSize: 0
+      }],
+      metadata: {
+        invalidatesStructures: true
+      }
+    }
+  };
+}
+function listItemBoundaryJoinDirection(command, selection, targetResolution) {
+  if (selection.isCollapsed !== true || targetResolution?.kind !== "accepted") {
+    return null;
+  }
+  if (command.type === "text.delete-backward" && selection.anchor === targetResolution.range.from) {
+    return "backward";
+  }
+  if (command.type === "text.delete-forward" && selection.anchor === targetResolution.range.to) {
+    return "forward";
+  }
+  return null;
+}
 function createSelectedListItemDeleteReplacement(input) {
-  const { command, document: document2, editableTarget, selection, targetResolution, timestamp } = input;
+  const { command, document: document2, editableTarget, selection, storyTarget, targetResolution, timestamp } = input;
   if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
     return null;
   }
@@ -63775,20 +64339,19 @@ function createSelectedListItemDeleteReplacement(input) {
   if (selectionFrom !== targetResolution.range.from || selectionTo !== targetResolution.range.to) {
     return null;
   }
-  const root = document2.content;
-  const replacement = removeNumberedParagraphAtMainStoryPath(root.children, editableTarget.blockPath);
+  const storyBlocks = getStoryBlocks(document2, storyTarget);
+  const replacement = removeNumberedParagraphAtStoryPath(storyBlocks, editableTarget.blockPath, storyTarget);
   if (!replacement) {
     return null;
   }
-  const nextDocument = {
+  const nextDocument = replaceStoryBlocks({
     ...document2,
-    updatedAt: timestamp,
-    content: {
-      ...root,
-      children: replacement.blocks
-    }
-  };
-  const nextStorySize = parseTextStory(nextDocument.content).size;
+    updatedAt: timestamp
+  }, storyTarget, replacement.blocks);
+  const nextStorySize = parseTextStory({
+    type: "doc",
+    children: [...getStoryBlocks(nextDocument, storyTarget)]
+  }).size;
   const nextAnchor = Math.min(selectionFrom, nextStorySize);
   return {
     document: nextDocument,
@@ -63805,11 +64368,157 @@ function createSelectedListItemDeleteReplacement(input) {
     }
   };
 }
-function removeNumberedParagraphAtMainStoryPath(blocks, blockPath) {
-  const tokens = parseMainStoryBlockPathTokens(blockPath);
+function removeNumberedParagraphAtStoryPath(blocks, blockPath, storyTarget) {
+  const tokens = parseStoryBlockPathTokens(blockPath, storyTarget);
   if (!tokens) return null;
   return removeNumberedParagraphFromBlocks(blocks, tokens);
 }
+function joinNumberedParagraphAtStoryPath(blocks, blockPath, storyTarget, direction) {
+  const tokens = parseStoryBlockPathTokens(blockPath, storyTarget);
+  if (!tokens) return null;
+  return joinNumberedParagraphFromBlocks(blocks, tokens, direction);
+}
+function joinNumberedParagraphFromBlocks(blocks, tokens, direction) {
+  const [token, ...rest] = tokens;
+  if (!token || token.kind !== "block") return null;
+  const block = blocks[token.index];
+  if (!block) return null;
+  if (rest.length === 0) {
+    return joinAdjacentNumberedParagraphs(blocks, token.index, direction);
+  }
+  const next = rest[0];
+  if (block.type === "table" && next?.kind === "row") {
+    const updatedTable = joinNumberedParagraphInTable(block, rest, direction);
+    if (!updatedTable) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedTable,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  if ((block.type === "sdt" || block.type === "custom_xml") && next?.kind === "block") {
+    const updatedChildren = joinNumberedParagraphFromBlocks(block.children, rest, direction);
+    if (!updatedChildren) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        { ...block, children: updatedChildren.blocks },
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  if (block.type === "paragraph" && next?.kind === "inline") {
+    const updatedParagraph = joinNumberedParagraphInTextBoxInline(block, rest, direction);
+    if (!updatedParagraph) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedParagraph,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function joinAdjacentNumberedParagraphs(blocks, targetIndex, direction) {
+  const target = blocks[targetIndex];
+  if (target?.type !== "paragraph" || !target.numbering) {
+    return null;
+  }
+  if (direction === "backward") {
+    const previousIndex = targetIndex - 1;
+    const previous = blocks[previousIndex];
+    if (previous?.type !== "paragraph" || !previous.numbering) {
+      return null;
+    }
+    const merged2 = {
+      ...previous,
+      children: [...previous.children, ...target.children]
+    };
+    return {
+      blocks: [
+        ...blocks.slice(0, previousIndex),
+        merged2,
+        ...blocks.slice(targetIndex + 1)
+      ]
+    };
+  }
+  const nextIndex = targetIndex + 1;
+  const next = blocks[nextIndex];
+  if (next?.type !== "paragraph" || !next.numbering) {
+    return null;
+  }
+  const merged = {
+    ...target,
+    children: [...target.children, ...next.children]
+  };
+  return {
+    blocks: [
+      ...blocks.slice(0, targetIndex),
+      merged,
+      ...blocks.slice(nextIndex + 1)
+    ]
+  };
+}
+function joinNumberedParagraphInTable(table, tokens, direction) {
+  const [rowToken, cellToken, ...childTokens] = tokens;
+  if (rowToken?.kind !== "row" || cellToken?.kind !== "cell" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const row2 = table.rows[rowToken.index];
+  const cell = row2?.cells[cellToken.index];
+  if (!row2 || !cell) return null;
+  const updatedChildren = joinNumberedParagraphFromBlocks(cell.children, childTokens, direction);
+  if (!updatedChildren) return null;
+  const nextCells = [
+    ...row2.cells.slice(0, cellToken.index),
+    { ...cell, children: updatedChildren.blocks },
+    ...row2.cells.slice(cellToken.index + 1)
+  ];
+  const nextRows = [
+    ...table.rows.slice(0, rowToken.index),
+    { ...row2, cells: nextCells },
+    ...table.rows.slice(rowToken.index + 1)
+  ];
+  return { ...table, rows: nextRows };
+}
+function joinNumberedParagraphInTextBoxInline(paragraph, tokens, direction) {
+  const [inlineToken, textBoxToken, ...childTokens] = tokens;
+  if (inlineToken?.kind !== "inline" || textBoxToken?.kind !== "txbx" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const inline = paragraph.children[inlineToken.index];
+  if (!inline) return null;
+  const updatedInline = joinNumberedParagraphInInlineTextBox(inline, childTokens, direction);
+  if (!updatedInline) return null;
+  return {
+    ...paragraph,
+    children: [
+      ...paragraph.children.slice(0, inlineToken.index),
+      updatedInline,
+      ...paragraph.children.slice(inlineToken.index + 1)
+    ]
+  };
+}
+function joinNumberedParagraphInInlineTextBox(inline, tokens, direction) {
+  if (inline.type === "shape" && inline.txbxBlocks) {
+    const updatedBlocks = joinNumberedParagraphFromBlocks(inline.txbxBlocks, tokens, direction);
+    return updatedBlocks ? { ...inline, txbxBlocks: updatedBlocks.blocks } : null;
+  }
+  if (inline.type === "drawing_frame" && inline.content.type === "shape" && inline.content.txbxBlocks) {
+    const updatedBlocks = joinNumberedParagraphFromBlocks(inline.content.txbxBlocks, tokens, direction);
+    return updatedBlocks ? {
+      ...inline,
+      content: {
+        ...inline.content,
+        txbxBlocks: updatedBlocks.blocks
+      }
+    } : null;
+  }
+  return null;
+}
 function removeNumberedParagraphFromBlocks(blocks, tokens) {
   const [token, ...rest] = tokens;
   if (!token || token.kind !== "block") return null;
@@ -63852,6 +64561,52 @@ function removeNumberedParagraphFromBlocks(blocks, tokens) {
       ]
     };
   }
+  if (block.type === "paragraph" && next?.kind === "inline") {
+    const updatedParagraph = removeNumberedParagraphFromTextBoxInline(block, rest);
+    if (!updatedParagraph) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedParagraph,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function removeNumberedParagraphFromTextBoxInline(paragraph, tokens) {
+  const [inlineToken, textBoxToken, ...childTokens] = tokens;
+  if (inlineToken?.kind !== "inline" || textBoxToken?.kind !== "txbx" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const inline = paragraph.children[inlineToken.index];
+  if (!inline) return null;
+  const updatedInline = removeNumberedParagraphFromInlineTextBox(inline, childTokens);
+  if (!updatedInline) return null;
+  return {
+    ...paragraph,
+    children: [
+      ...paragraph.children.slice(0, inlineToken.index),
+      updatedInline,
+      ...paragraph.children.slice(inlineToken.index + 1)
+    ]
+  };
+}
+function removeNumberedParagraphFromInlineTextBox(inline, tokens) {
+  if (inline.type === "shape" && inline.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.txbxBlocks, tokens);
+    return updatedBlocks ? { ...inline, txbxBlocks: updatedBlocks.blocks } : null;
+  }
+  if (inline.type === "drawing_frame" && inline.content.type === "shape" && inline.content.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.content.txbxBlocks, tokens);
+    return updatedBlocks ? {
+      ...inline,
+      content: {
+        ...inline.content,
+        txbxBlocks: updatedBlocks.blocks
+      }
+    } : null;
+  }
   return null;
 }
 function removeNumberedParagraphFromTable(table, tokens) {
@@ -63892,15 +64647,79 @@ function createSelectedListItemDeleteReplayCommand(input) {
     target: editableTarget,
     activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
   });
+  const resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document: document2,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+    commandFamilies: ["text-leaf"]
+  }) : null;
+  const selectedRange = {
+    from: Math.min(selection.anchor, selection.head),
+    to: Math.max(selection.anchor, selection.head)
+  };
   const replacement = createSelectedListItemDeleteReplacement({
     command,
     document: document2,
-    editableTarget,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
     selection,
-    targetResolution,
+    storyTarget,
+    targetResolution: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? {
+      kind: "accepted",
+      range: selectedRange
+    } : targetResolution,
+    timestamp
+  });
+  if (!replacement) {
+    return null;
+  }
+  return {
+    type: "document.replace",
+    document: replacement.document,
+    selection: replacement.selection,
+    mapping: replacement.mapping,
+    protectionSelection: selection,
+    origin: command.origin
+  };
+}
+function createListItemBoundaryJoinReplayCommand(input) {
+  const { command, document: document2, selection, surface, storyTarget, timestamp } = input;
+  if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
+    return null;
+  }
+  const editableTarget = command.editableTarget;
+  if (!editableTarget) {
+    return null;
+  }
+  const targetResolution = resolveEditableTextTarget({
+    document: document2,
+    selection,
+    surface,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+  });
+  const resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document: document2,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+    commandFamilies: ["text-leaf"]
+  }) : null;
+  const selectedRange = {
+    from: Math.min(selection.anchor, selection.head),
+    to: Math.max(selection.anchor, selection.head)
+  };
+  const replacement = createListItemBoundaryJoinReplacement({
+    command,
+    document: document2,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
+    selection,
+    storyTarget,
+    targetResolution: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? {
+      kind: "accepted",
+      range: selectedRange
+    } : targetResolution,
     timestamp
   });
-  if (!replacement || storyTarget.kind !== "main") {
+  if (!replacement) {
     return null;
   }
   return {
@@ -63912,22 +64731,49 @@ function createSelectedListItemDeleteReplayCommand(input) {
     origin: command.origin
   };
 }
-function parseMainStoryBlockPathTokens(blockPath) {
-  const parts = blockPath?.split("/") ?? [];
-  if (parts[0] !== "main" || parts.length < 2) {
+function parseStoryBlockPathTokens(blockPath, storyTarget) {
+  if (!blockPath) {
+    return null;
+  }
+  const firstTokenMatch = /\/(?:block|row|cell)\[\d+\]/u.exec(blockPath);
+  if (!firstTokenMatch?.index) {
+    return null;
+  }
+  const storyPrefix = blockPath.slice(0, firstTokenMatch.index);
+  if (!blockPathBelongsToStoryTarget(storyPrefix, storyTarget)) {
     return null;
   }
+  const parts = blockPath.slice(firstTokenMatch.index + 1).split("/");
   const tokens = [];
-  for (const part of parts.slice(1)) {
-    const match = /^(block|row|cell)\[(\d+)\]$/u.exec(part);
+  for (const part of parts) {
+    if (part === "txbx") {
+      tokens.push({ kind: "txbx" });
+      continue;
+    }
+    const match = /^(block|row|cell|inline)\[(\d+)\]$/u.exec(part);
     if (!match) return null;
+    const kind = match[1];
     tokens.push({
-      kind: match[1],
+      kind,
       index: Number.parseInt(match[2], 10)
     });
   }
   return tokens;
 }
+function blockPathBelongsToStoryTarget(storyPrefix, storyTarget) {
+  switch (storyTarget.kind) {
+    case "main":
+      return storyPrefix === "main" || storyPrefix.startsWith("main/");
+    case "header":
+      return storyPrefix.startsWith("header:");
+    case "footer":
+      return storyPrefix.startsWith("footer:");
+    case "footnote":
+      return storyPrefix === `footnote:${storyTarget.noteId}` || storyPrefix.startsWith(`footnote:${storyTarget.noteId}/`);
+    case "endnote":
+      return storyPrefix === `endnote:${storyTarget.noteId}` || storyPrefix.startsWith(`endnote:${storyTarget.noteId}/`);
+  }
+}
 function toInternalSelectionSnapshot2(selection) {
   return {
     anchor: selection.anchor,