@beyondwork/docx-react-component 1.0.135 → 1.0.136

package/dist/{chunk-GIFXKIM5.js → chunk-JZZKTL7K.js}

@@ -72,6 +72,7 @@ import {
   findTextWithStyleMatches,
   getListKind,
   inlineLengthForScopeCoordinates,
+  mergeFragmentNumberingCatalog,
   rebuildFieldRegistry,
   removeScopeMarkersFromBlockList,
   replaceParagraphChildrenAtPath,
@@ -83,7 +84,7 @@ import {
   sameScopeParagraphPath,
   serializeFragmentToWordML,
   setStartOverride
-} from "./chunk-5CCYF333.js";
+} from "./chunk-HUWZ7AHE.js";
 import {
   ISSUE_METADATA_ID,
   LAYOUT_ENGINE_VERSION,
@@ -1195,7 +1196,7 @@ function splitListParagraph(document, paragraphIndex, paragraphIsEmpty, context,
       action: "split"
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -1247,7 +1248,7 @@ function backspaceAtListStart(document, paragraphIndex, context, options = {}) {
       handled: false
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -1293,7 +1294,7 @@ function restartNumbering(document, paragraphIndex, context, startAt = 1, option
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -1315,8 +1316,13 @@ function restartNumbering(document, paragraphIndex, context, startAt = 1, option
   );
   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;
     }
@@ -1360,7 +1366,7 @@ function continueNumbering(document, paragraphIndex, context, options = {}) {
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -1389,8 +1395,13 @@ function continueNumbering(document, 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;
     }
@@ -1436,12 +1447,13 @@ function toggleListKind(document, 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 {
@@ -1451,7 +1463,8 @@ function toggleListKind(document, 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)
@@ -1482,10 +1495,11 @@ function adjustListLevels(document, 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;
     }
@@ -1505,17 +1519,21 @@ function normalizeListCommandTargets(options) {
 }
 function resolveListCommandParagraphIndexes(document, paragraphs, paragraphIndexes, context, editableTargets) {
   if (editableTargets.length === 0) {
-    return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, paragraphIndexes) };
+    return {
+      paragraphIndexes: normalizeParagraphIndexesForStory(
+        paragraphs,
+        paragraphIndexes,
+        context.activeStoryKey
+      )
+    };
   }
   const currentTargets = collectEditableTargetRefs(document, 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) {
@@ -1540,7 +1558,8 @@ function resolveListCommandParagraphIndexes(document, paragraphs, paragraphIndex
         }
       };
     }
-    const currentIndex = paragraphIndexByTargetKey.get(current.targetKey);
+    const currentIndex = paragraphIndexByAddress.get(`${current.storyKey}
+${current.blockPath}`);
     if (currentIndex === void 0) {
       return {
         paragraphIndexes: [],
@@ -1615,18 +1634,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 storyKey = paragraphs[fromIndex]?.storyKey;
   for (let index = fromIndex - 1; index >= 0; index -= 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== storyKey) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       continue;
     }
@@ -1645,7 +1674,14 @@ function cloneEnvelope(document, timestamp) {
 function captureEditableParagraphs(document) {
   if (isDocumentRoot(document.content)) {
     const paragraphs = [];
-    collectEditableParagraphs(document.content.children, paragraphs);
+    for (const context of collectStoryBlockContexts(document)) {
+      collectEditableParagraphs(
+        context.blocks,
+        paragraphs,
+        context.storyKey,
+        context.basePath
+      );
+    }
     return paragraphs;
   }
   const fallback = {
@@ -1653,23 +1689,39 @@ function captureEditableParagraphs(document) {
     children: [{ type: "paragraph", children: [] }]
   };
   document.content = fallback;
-  return fallback.children;
-}
-function collectEditableParagraphs(blocks, output) {
-  for (const block of blocks) {
+  return [{
+    paragraph: fallback.children[0],
+    storyKey: "main",
+    blockPath: "main/block[0]"
+  }];
+}
+function collectEditableParagraphs(blocks, output, storyKey, 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, 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,
+              storyKey,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`
+            );
           }
         }
         break;
       case "sdt":
-        collectEditableParagraphs(block.children, output);
+        collectEditableParagraphs(block.children, output, storyKey, blockPath);
         break;
       case "custom_xml":
         break;
@@ -1681,6 +1733,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, storyKey) {
+  if (storyKey === void 0) {
+    return normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+  }
+  const storyParagraphIndexes = [];
+  for (let index = 0; index < paragraphs.length; index += 1) {
+    if (paragraphs[index]?.storyKey === storyKey) {
+      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));
 }
@@ -1825,8 +1889,9 @@ function applyFragmentInsert(document, 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(
@@ -1838,7 +1903,11 @@ function applyFragmentInsert(document, 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,
@@ -1849,9 +1918,9 @@ function applyFragmentInsert(document, 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 {
@@ -1883,7 +1952,7 @@ function applyFragmentInsert(document, 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 = {
@@ -1891,7 +1960,7 @@ function applyFragmentInsert(document, selection, fragment, context) {
     children: splicedChildren
   };
   const nextDocument = {
-    ...splitResult.document,
+    ...preparedFragment.document,
     updatedAt: context.timestamp,
     content: nextRoot
   };
@@ -1903,14 +1972,47 @@ function applyFragmentInsert(document, selection, fragment, context) {
     mapping: createEmptyMapping()
   };
 }
-function cloneBlock(block) {
-  if (block.type === "paragraph") {
-    return {
-      ...block,
-      children: block.children.map((child) => ({ ...child }))
+function prepareFragmentNumberingForInsertion(document, fragment) {
+  if (!fragment.numbering) {
+    return { document, blocks: fragment.blocks };
+  }
+  const merged = mergeFragmentNumberingCatalog(document.numbering, fragment.numbering);
+  return {
+    document: {
+      ...document,
+      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(document, blockPath, fragmentBlocks) {
   const tokens = parseCanonicalBlockPath(blockPath);
@@ -7402,6 +7504,16 @@ function coerceIssueValue(value) {
 function insertScopeMarkers(document, params) {
   const { scopeId } = params;
   const root = document.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) {
@@ -7854,6 +7966,14 @@ function isRecord(value) {
 }
 
 // src/runtime/workflow/coordinator.ts
+function createScopeMarkerMutationMapping() {
+  return {
+    steps: [],
+    metadata: {
+      layoutNeutralScopeMarkers: true
+    }
+  };
+}
 var MODE_RESTRICTIVENESS = {
   edit: 0,
   suggest: 1,
@@ -8161,6 +8281,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)}`;
@@ -8203,6 +8377,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 };
@@ -8259,6 +8434,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) {
@@ -8276,6 +8529,7 @@ function createWorkflowCoordinator(deps) {
       deps.dispatch({
         type: "document.replace",
         document: nextDocument,
+        mapping: createScopeMarkerMutationMapping(),
         origin: { source: "api", at: clock() }
       });
     }
@@ -8669,6 +8923,7 @@ function createWorkflowCoordinator(deps) {
   }
   return {
     addScope,
+    addScopes,
     removeScope,
     addInvisibleScope,
     setScopeVisibility,
@@ -14871,6 +15126,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,
@@ -15028,6 +15294,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,
@@ -16057,6 +16334,9 @@ function createDocumentRuntime(options) {
     addScope(params) {
       return workflowCoordinator.addScope(params);
     },
+    addScopes(params) {
+      return workflowCoordinator.addScopes(params);
+    },
     getScope(scopeId) {
       return workflowCoordinator.getScope(scopeId);
     },
@@ -17040,6 +17320,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;
@@ -17068,6 +17351,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);
@@ -17116,9 +17404,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;
@@ -17487,6 +17778,39 @@ 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,
@@ -20403,6 +20727,56 @@ function stripStoryTarget(selection) {
 function isTopLevelMainStoryBlockPath(blockPath) {
   return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
 }
+function createListItemBoundaryJoinReplacement(input) {
+  const { command, document, 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(document, storyTarget);
+  const replacement = joinNumberedParagraphAtStoryPath(
+    storyBlocks,
+    editableTarget.blockPath,
+    storyTarget,
+    direction
+  );
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = replaceStoryBlocks({
+    ...document,
+    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, editableTarget, selection, storyTarget, targetResolution, timestamp } = input;
   if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
@@ -20450,6 +20824,152 @@ function removeNumberedParagraphAtStoryPath(blocks, 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;
@@ -20612,6 +21132,56 @@ function createSelectedListItemDeleteReplayCommand(input) {
     origin: command.origin
   };
 }
+function createListItemBoundaryJoinReplayCommand(input) {
+  const { command, document, 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,
+    selection,
+    surface,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+  });
+  const resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document,
+    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,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
+    selection,
+    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 parseStoryBlockPathTokens(blockPath, storyTarget) {
   if (!blockPath) {
     return null;