@beyondwork/docx-react-component 1.0.125 → 1.0.127

package/dist/index.cjs

@@ -22001,19 +22001,19 @@ function clamp(value, min, max) {
 }
 
 // src/core/commands/list-commands.ts
-function toggleNumberedList(document2, paragraphIndexes, context) {
-  return toggleListKind(document2, paragraphIndexes, "numbered", context);
+function toggleNumberedList(document2, paragraphIndexes, context, options = {}) {
+  return toggleListKind(document2, paragraphIndexes, "numbered", context, options);
 }
-function toggleBulletedList(document2, paragraphIndexes, context) {
-  return toggleListKind(document2, paragraphIndexes, "bulleted", context);
+function toggleBulletedList(document2, paragraphIndexes, context, options = {}) {
+  return toggleListKind(document2, paragraphIndexes, "bulleted", context, options);
 }
-function indentListItems(document2, paragraphIndexes, context) {
-  return adjustListLevels(document2, paragraphIndexes, 1, context);
+function indentListItems(document2, paragraphIndexes, context, options = {}) {
+  return adjustListLevels(document2, paragraphIndexes, 1, context, options);
 }
-function outdentListItems(document2, paragraphIndexes, context) {
-  return adjustListLevels(document2, paragraphIndexes, -1, context);
+function outdentListItems(document2, paragraphIndexes, context, options = {}) {
+  return adjustListLevels(document2, paragraphIndexes, -1, context, options);
 }
-function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context) {
+function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context, options = {}) {
   if (!paragraphIsEmpty) {
     return {
       document: document2,
@@ -22023,7 +22023,30 @@ function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context
   }
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      action: "blocked",
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      action: "split"
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -22038,21 +22061,44 @@ function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context
     };
     return {
       document: working,
-      affectedParagraphIndexes: [paragraphIndex],
+      affectedParagraphIndexes: [resolvedParagraphIndex],
       action: "outdented"
     };
   }
   delete target.numbering;
   return {
     document: working,
-    affectedParagraphIndexes: [paragraphIndex],
+    affectedParagraphIndexes: [resolvedParagraphIndex],
     action: "removed"
   };
 }
-function backspaceAtListStart(document2, paragraphIndex, context) {
+function backspaceAtListStart(document2, paragraphIndex, context, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      handled: true,
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      handled: false
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -22070,14 +22116,35 @@ function backspaceAtListStart(document2, paragraphIndex, context) {
   }
   return {
     document: working,
-    affectedParagraphIndexes: [paragraphIndex],
+    affectedParagraphIndexes: [resolvedParagraphIndex],
     handled: true
   };
 }
-function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
+function restartNumbering(document2, paragraphIndex, context, startAt = 1, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: []
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -22102,7 +22169,7 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
     })
   };
   const affectedParagraphIndexes = [];
-  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+  for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
     const paragraph = paragraphs[index];
     if (!paragraph?.numbering) {
       break;
@@ -22123,10 +22190,31 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1) {
     createdNumberingInstanceId: numberingInstanceId
   };
 }
-function continueNumbering(document2, paragraphIndex, context) {
+function continueNumbering(document2, paragraphIndex, context, options = {}) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const target = paragraphs[paragraphIndex];
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    [paragraphIndex],
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const resolvedParagraphIndex = resolved.paragraphIndexes[0];
+  if (resolvedParagraphIndex === void 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: []
+    };
+  }
+  const target = paragraphs[resolvedParagraphIndex];
   if (!target?.numbering) {
     return {
       document: working,
@@ -22145,7 +22233,7 @@ function continueNumbering(document2, paragraphIndex, context) {
   const compatibleInstanceId = findPreviousCompatibleInstance(
     paragraphs,
     catalog,
-    paragraphIndex,
+    resolvedParagraphIndex,
     currentKind
   );
   if (!compatibleInstanceId || compatibleInstanceId === currentInstanceId) {
@@ -22155,7 +22243,7 @@ function continueNumbering(document2, paragraphIndex, context) {
     };
   }
   const affectedParagraphIndexes = [];
-  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+  for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
     const paragraph = paragraphs[index];
     if (!paragraph?.numbering) {
       break;
@@ -22176,10 +22264,24 @@ function continueNumbering(document2, paragraphIndex, context) {
     createdNumberingInstanceId: compatibleInstanceId
   };
 }
-function toggleListKind(document2, paragraphIndexes, kind, context) {
+function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const normalizedIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    paragraphIndexes,
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const normalizedIndexes = resolved.paragraphIndexes;
   if (normalizedIndexes.length === 0) {
     return {
       document: working,
@@ -22216,10 +22318,24 @@ function toggleListKind(document2, paragraphIndexes, kind, context) {
     createdNumberingInstanceId: numberingInstanceId
   };
 }
-function adjustListLevels(document2, paragraphIndexes, delta, context) {
+function adjustListLevels(document2, paragraphIndexes, delta, context, options) {
   const working = cloneEnvelope(document2, context.timestamp);
   const paragraphs = captureEditableParagraphs(working);
-  const affectedParagraphIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes).filter(
+  const resolved = resolveListCommandParagraphIndexes(
+    working,
+    paragraphs,
+    paragraphIndexes,
+    context,
+    normalizeListCommandTargets(options)
+  );
+  if (resolved.blockedReason) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      blockedReason: resolved.blockedReason
+    };
+  }
+  const affectedParagraphIndexes = resolved.paragraphIndexes.filter(
     (index) => Boolean(paragraphs[index]?.numbering)
   );
   for (const index of affectedParagraphIndexes) {
@@ -22237,6 +22353,121 @@ function adjustListLevels(document2, paragraphIndexes, delta, context) {
     affectedParagraphIndexes
   };
 }
+function normalizeListCommandTargets(options) {
+  if (options.editableTargets !== void 0) return options.editableTargets;
+  return options.editableTarget ? [options.editableTarget] : [];
+}
+function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphIndexes, context, editableTargets) {
+  if (editableTargets.length === 0) {
+    return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, paragraphIndexes) };
+  }
+  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 resolvedIndexes = [];
+  for (const target of editableTargets) {
+    const blockedReason = validateListCommandTarget(target, currentTargets, context);
+    if (blockedReason) return { paragraphIndexes: [], blockedReason };
+    const current = findCurrentListCommandTarget(target, currentTargets);
+    if (!current) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_not_found",
+          message: "List editable target no longer resolves in the current canonical document."
+        }
+      };
+    }
+    if (!sameResolvedListCommandTarget(target, current)) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_stale",
+          message: "List editable target is stale for the current canonical document."
+        }
+      };
+    }
+    const currentIndex = paragraphIndexByTargetKey.get(current.targetKey);
+    if (currentIndex === void 0) {
+      return {
+        paragraphIndexes: [],
+        blockedReason: {
+          code: "list_target_position_unavailable",
+          message: "List editable target resolved but could not be mapped to a current paragraph."
+        }
+      };
+    }
+    resolvedIndexes.push(currentIndex);
+  }
+  return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, resolvedIndexes) };
+}
+function validateListCommandTarget(target, currentTargets, context) {
+  const shapeIssues = validateEditableTargetRef(target);
+  if (shapeIssues.length > 0) {
+    return {
+      code: "list_target_malformed",
+      message: `List editable target is malformed: ${shapeIssues[0]?.path ?? "$"}.`
+    };
+  }
+  if (context.activeStoryKey !== void 0 && target.storyKey !== context.activeStoryKey) {
+    return {
+      code: "list_target_wrong_story",
+      message: "List editable target does not belong to the active story."
+    };
+  }
+  if (target.commandFamily !== "text-leaf" || target.listAddress === void 0) {
+    return {
+      code: "list_target_required",
+      message: "List commands require a validated list item editable target."
+    };
+  }
+  if (target.editability !== "editable" || target.posture.blockers.length > 0) {
+    return {
+      code: "list_target_non_editable",
+      message: target.posture.blockers.length > 0 ? `List editable target is not editable: ${target.posture.blockers.join(", ")}.` : "List editable target is not editable."
+    };
+  }
+  if (!findCurrentListCommandTarget(target, currentTargets)) {
+    return {
+      code: "list_target_not_found",
+      message: "List editable target no longer resolves in the current canonical document."
+    };
+  }
+  return void 0;
+}
+function findCurrentListCommandTarget(target, currentTargets) {
+  return currentTargets.find(
+    (candidate) => isParagraphTextTarget(candidate) && candidate.listAddress !== void 0 && (candidate.targetKey === target.targetKey || candidate.listAddress.addressKey === target.listAddress?.addressKey)
+  );
+}
+function sameResolvedListCommandTarget(left, right) {
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.blockType === right.staleCheck.blockType && left.listAddress?.addressKey === right.listAddress?.addressKey && left.listAddress?.resolver?.staleHash === right.listAddress?.resolver?.staleHash && jsonStable(left.sourceRef) === jsonStable(right.sourceRef);
+}
+function isParagraphTextTarget(target) {
+  return target.commandFamily === "text-leaf" && target.staleCheck.blockType === "paragraph" && target.leafPath.endsWith("/inline");
+}
+function jsonStable(value) {
+  return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (value && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+      sorted[key] = sortJson(record[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
 function ensureDefaultInstance(catalog, kind) {
   const existing = Object.values(catalog.instances).find(
     (instance) => getListKind(catalog, instance.numberingInstanceId) === kind
@@ -22402,7 +22633,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = indentListItems(
         context.localDocument,
         [paragraphContext.paragraphIndex],
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return createListMutationResult(result, context.localSnapshot.selection, deps);
     }
@@ -22410,7 +22642,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = outdentListItems(
         context.localDocument,
         [paragraphContext.paragraphIndex],
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return createListMutationResult(result, context.localSnapshot.selection, deps);
     }
@@ -22421,7 +22654,8 @@ function applyListAwareTextCommand(context, command, deps) {
       const result = backspaceAtListStart(
         context.localDocument,
         paragraphContext.paragraphIndex,
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
       return result.handled ? createListMutationResult(result, context.localSnapshot.selection, deps) : null;
     }
@@ -22433,14 +22667,30 @@ function applyListAwareTextCommand(context, command, deps) {
         context.localDocument,
         paragraphContext.paragraphIndex,
         true,
-        { timestamp: context.timestamp }
+        listCommandContext(context),
+        listCommandTargetOptions(context, paragraphContext)
       );
+      if (result.blockedReason) {
+        return createListMutationResult(result, context.localSnapshot.selection, deps);
+      }
       return result.action === "split" ? null : createListMutationResult(result, context.localSnapshot.selection, deps);
     }
     default:
       return null;
   }
 }
+function listCommandContext(context) {
+  return {
+    timestamp: context.timestamp,
+    ...context.activeStory.kind === "main" ? { activeStoryKey: "main" } : {}
+  };
+}
+function listCommandTargetOptions(context, paragraphContext) {
+  if (context.activeStory.kind !== "main" || !paragraphContext.paragraph.editableTarget) {
+    return {};
+  }
+  return { editableTargets: [paragraphContext.paragraph.editableTarget] };
+}
 function createListMutationResult(result, selection, deps) {
   return {
     changed: result.affectedParagraphIndexes.length > 0,
@@ -27824,6 +28074,9 @@ function splitParagraph(document2, selection, context) {
   if (scope?.kind !== "top-level") {
     return result;
   }
+  if (context.preserveNumberingOnSplit && scope.paragraph.numbering) {
+    return result;
+  }
   const originalStyleId = scope.paragraph.styleId;
   const nextStyleId = originalStyleId !== void 0 ? resolveNextStyle(originalStyleId, document2.styles) : void 0;
   if (nextStyleId !== void 0) {
@@ -33882,6 +34135,13 @@ function withCommandTextTarget(context, command) {
     textTarget: command.textTarget
   };
 }
+function listCommandContext2(context) {
+  return {
+    timestamp: context.timestamp,
+    ...context.activeStoryKey !== void 0 ? { activeStoryKey: context.activeStoryKey } : {},
+    ...context.editableTargetCache !== void 0 ? { editableTargetCache: context.editableTargetCache } : {}
+  };
+}
 function executeEditorCommand(state, command, context) {
   switch (command.type) {
     case "selection.set":
@@ -34523,7 +34783,17 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.toggle": {
-      const result = command.kind === "bulleted" ? toggleBulletedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp }) : toggleNumberedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = command.kind === "bulleted" ? toggleBulletedList(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      ) : toggleNumberedList(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34531,7 +34801,12 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.indent": {
-      const result = indentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = indentListItems(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34539,7 +34814,12 @@ function executeEditorCommand(state, command, context) {
       });
     }
     case "list.outdent": {
-      const result = outdentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      const result = outdentListItems(
+        state.document,
+        command.paragraphIndexes ?? [],
+        listCommandContext2(context),
+        { editableTargets: command.editableTargets }
+      );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
         document: result.document,
@@ -34549,9 +34829,10 @@ function executeEditorCommand(state, command, context) {
     case "list.restart-numbering": {
       const result = restartNumbering(
         state.document,
-        command.paragraphIndex,
-        { timestamp: context.timestamp },
-        command.startAt
+        command.paragraphIndex ?? -1,
+        listCommandContext2(context),
+        command.startAt,
+        { editableTarget: command.editableTarget }
       );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
@@ -34562,8 +34843,9 @@ function executeEditorCommand(state, command, context) {
     case "list.continue-numbering": {
       const result = continueNumbering(
         state.document,
-        command.paragraphIndex,
-        { timestamp: context.timestamp }
+        command.paragraphIndex ?? -1,
+        listCommandContext2(context),
+        { editableTarget: command.editableTarget }
       );
       return buildDocumentReplaceTransaction(state, context, {
         changed: result.affectedParagraphIndexes.length > 0,
@@ -51813,7 +52095,52 @@ function compileReplacement(inputs) {
 
 // src/runtime/scopes/replacement/apply.ts
 function documentHash2(doc) {
-  return JSON.stringify(doc.content);
+  let hash = 2166136261;
+  const mix = (value) => {
+    for (let i = 0; i < value.length; i += 1) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+  };
+  const visit = (value) => {
+    if (value === null) {
+      mix("null");
+      return;
+    }
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+        mix(`${typeof value}:${String(value)}`);
+        return;
+      case "undefined":
+        mix("undefined");
+        return;
+      case "object":
+        if (Array.isArray(value)) {
+          mix(`[${value.length}`);
+          for (const item of value) visit(item);
+          mix("]");
+          return;
+        }
+        {
+          const record = value;
+          const keys = Object.keys(record).sort();
+          mix(`{${keys.length}`);
+          for (const key of keys) {
+            mix(key);
+            visit(record[key]);
+          }
+          mix("}");
+        }
+        return;
+      default:
+        mix(typeof value);
+    }
+  };
+  visit(doc.content);
+  return (hash >>> 0).toString(36).padStart(7, "0");
 }
 function compileScopeById(document2, overlay, scopeId) {
   const paragraphIndexByBlockIndex = buildParagraphIndexMap(document2);
@@ -66716,7 +67043,8 @@ function rejectCommand(code, message) {
   };
 }
 function sameResolvedTarget2(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && sameTextTargetStaleCheck(left, right) && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && jsonStable(left.staleCheck.sourceRef) === jsonStable(right.staleCheck.sourceRef) && jsonStable(left.sourceRef) === jsonStable(right.sourceRef) && jsonStable(left.table) === jsonStable(right.table) && jsonStable(left.editableOwner) === jsonStable(right.editableOwner);
+  const textTargetLengthDrift = hasTextTargetLengthDrift(left, right);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && sameTextTargetStaleCheck(left, right) && left.staleCheck.inlineCount === right.staleCheck.inlineCount && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.targetTextLength === right.staleCheck.targetTextLength && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && left.staleCheck.wordParaId === right.staleCheck.wordParaId && left.staleCheck.wordTextId === right.staleCheck.wordTextId && (textTargetLengthDrift || jsonStable2(left.staleCheck.sourceRef) === jsonStable2(right.staleCheck.sourceRef)) && (textTargetLengthDrift || jsonStable2(left.sourceRef) === jsonStable2(right.sourceRef)) && jsonStable2(left.table) === jsonStable2(right.table) && jsonStable2(left.editableOwner) === jsonStable2(right.editableOwner);
 }
 function sameTextTargetStaleCheck(left, right) {
   if (left.staleCheck.paragraphTextHash === right.staleCheck.paragraphTextHash && left.staleCheck.paragraphTextLength === right.staleCheck.paragraphTextLength) {
@@ -66724,6 +67052,9 @@ function sameTextTargetStaleCheck(left, right) {
   }
   return left.commandFamily === "text-leaf" && left.staleCheck.paragraphTextLength !== void 0 && right.staleCheck.paragraphTextLength !== void 0 && left.staleCheck.paragraphTextLength !== right.staleCheck.paragraphTextLength;
 }
+function hasTextTargetLengthDrift(left, right) {
+  return left.commandFamily === "text-leaf" && left.staleCheck.paragraphTextLength !== void 0 && right.staleCheck.paragraphTextLength !== void 0 && left.staleCheck.paragraphTextLength !== right.staleCheck.paragraphTextLength;
+}
 function locateTargetRange(document2, surface, target) {
   if (target.kind === "hyperlink-text") {
     return locateHyperlinkDisplayRange(document2, surface, target);
@@ -67015,7 +67346,7 @@ function resolveBlockPathInSurfaceBlocks2(blocks, tokens, tokenIndex, hasVertica
     hasVerticalMergeContinuation || cell.verticalMerge === "continue"
   );
 }
-function jsonStable(value) {
+function jsonStable2(value) {
   return value === void 0 ? "" : JSON.stringify(value);
 }
 
@@ -67152,20 +67483,20 @@ function tableAnchorCell(table) {
   };
 }
 function sameResolvedTableStructureTarget(left, right) {
-  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && jsonStable2(left.staleCheck.sourceRef) === jsonStable2(right.staleCheck.sourceRef) && jsonStable2(left.sourceRef) === jsonStable2(right.sourceRef) && jsonStable2(left.table) === jsonStable2(right.table);
+  return left.kind === right.kind && left.storyKey === right.storyKey && left.blockPath === right.blockPath && left.leafPath === right.leafPath && left.commandFamily === right.commandFamily && left.editability === right.editability && left.staleCheck.targetHash === right.staleCheck.targetHash && left.staleCheck.childCount === right.staleCheck.childCount && left.staleCheck.blockType === right.staleCheck.blockType && jsonStable3(left.staleCheck.sourceRef) === jsonStable3(right.staleCheck.sourceRef) && jsonStable3(left.sourceRef) === jsonStable3(right.sourceRef) && jsonStable3(left.table) === jsonStable3(right.table);
 }
-function jsonStable2(value) {
-  return JSON.stringify(sortJson(value));
+function jsonStable3(value) {
+  return JSON.stringify(sortJson2(value));
 }
-function sortJson(value) {
+function sortJson2(value) {
   if (Array.isArray(value)) {
-    return value.map(sortJson);
+    return value.map(sortJson2);
   }
   if (value && typeof value === "object") {
     const record = value;
     const sorted = {};
     for (const key of Object.keys(record).sort()) {
-      sorted[key] = sortJson(record[key]);
+      sorted[key] = sortJson2(record[key]);
     }
     return sorted;
   }
@@ -69247,6 +69578,8 @@ function createDocumentRuntime(options) {
           documentMode: workflowCoordinator.getEffectiveDocumentMode(commandSelection),
           defaultAuthorId: defaultAuthorId ?? void 0,
           renderSnapshot: cachedRenderSnapshot,
+          activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+          editableTargetCache: editableTargetBlockCache,
           ...resolvedFragmentTextTarget ? { textTarget: resolvedFragmentTextTarget } : {}
         };
         const preSelection = commandSelection;
@@ -71840,14 +72173,18 @@ function createDocumentRuntime(options) {
         blockedReasons: [blockedReason]
       });
     }
-    const textTarget = targetResolution?.kind === "accepted" ? targetResolution.textTarget : legacyTextTarget;
+    const listBoundaryDeleteUsesStoryText = targetResolution?.kind === "accepted" && editableTarget?.listAddress?.operationScope === "list-text" && isTopLevelMainStoryBlockPath(editableTarget.blockPath) && selection.isCollapsed && (commandForDispatch.type === "text.delete-backward" && selection.anchor === targetResolution.range.from || commandForDispatch.type === "text.delete-forward" && selection.anchor === targetResolution.range.to);
+    const textTarget = targetResolution?.kind === "accepted" && !listBoundaryDeleteUsesStoryText ? targetResolution.textTarget : legacyTextTarget;
     const context = {
       timestamp,
       documentMode: textOptions.documentModeOverride ?? workflowCoordinator.getEffectiveDocumentMode(selection),
       defaultAuthorId: defaultAuthorId ?? void 0,
       renderSnapshot: cachedRenderSnapshot,
+      activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+      editableTargetCache: editableTargetBlockCache,
       activeStorySize: cachedRenderSnapshot.surface?.storySize,
       textTarget,
+      preserveNumberingOnSplit: commandForDispatch.type === "paragraph.split" && targetResolution?.kind === "accepted" && editableTarget?.listAddress?.operationScope === "list-text",
       rejectTargetlessTableStructureInsert: true
     };
     const baseState = selection === state.selection ? state : {
@@ -72146,7 +72483,9 @@ function createDocumentRuntime(options) {
         timestamp: clock(),
         documentMode: workflowCoordinator.getEffectiveDocumentMode(state.selection),
         defaultAuthorId: defaultAuthorId ?? void 0,
-        renderSnapshot: cachedRenderSnapshot
+        renderSnapshot: cachedRenderSnapshot,
+        activeStoryKey: canonicalEditableTargetStoryKey(activeStory),
+        editableTargetCache: editableTargetBlockCache
       };
       try {
         const transaction = executeEditorCommand(
@@ -74694,6 +75033,9 @@ function stripStoryTarget2(selection) {
   const { storyTarget: _storyTarget, ...rest } = selection;
   return rest;
 }
+function isTopLevelMainStoryBlockPath(blockPath) {
+  return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
+}
 function toInternalSelectionSnapshot2(selection) {
   return {
     anchor: selection.anchor,
@@ -127618,6 +127960,18 @@ function createTableActionFamily(runtime) {
     }
   };
 }
+function findTableActionDescriptor(runtime, actionHandle) {
+  const document2 = runtime.getCanonicalDocument();
+  const seed = documentSeed(runtime);
+  const surface = runtime.getRenderSnapshot().surface?.blocks ?? [];
+  for (const target of collectEditableTargetRefs(document2)) {
+    if (!target.table || callableOperationsForScope(target.table.operationScope).length === 0 || tableActionHandle(seed, target.targetKey) !== actionHandle || !isResolvableCurrentTableActionTarget(runtime, surface, target)) {
+      continue;
+    }
+    return projectCurrentTableTarget(document2, seed, target);
+  }
+  return null;
+}
 function isSupportedTableActionEvidence(entry) {
   return isSupportedTableStructureEvidence(entry) || isSupportedTableTextEvidence(entry);
 }
@@ -127636,6 +127990,7 @@ function projectTableActionDescriptor(document2, seed, entry) {
   const callableOperations = callableOperationsForScope(scope);
   const supportedOperations = operationsForScope(scope);
   if (callableOperations.length === 0) return [];
+  const selectionRequiredOperations = selectionRequiredOperationsForScope(scope);
   return [
     {
       actionHandle: tableActionHandle(seed, entry.targetKey),
@@ -127644,6 +127999,7 @@ function projectTableActionDescriptor(document2, seed, entry) {
       relation: entry.relation,
       operationScope: scope,
       callableOperations,
+      ...selectionRequiredOperations.length > 0 ? { selectionRequiredOperations } : {},
       supportedOperations,
       ...scope === "text" ? { readback: tableTextReadback(readBlockPathText(document2, entry.blockPath)) } : {},
       reason: entry.runtimeCommand.reason
@@ -127655,6 +128011,7 @@ function projectCurrentTableTarget(document2, seed, target) {
   if (!table) return null;
   const callableOperations = callableOperationsForScope(table.operationScope);
   if (callableOperations.length === 0) return null;
+  const selectionRequiredOperations = selectionRequiredOperationsForScope(table.operationScope);
   return {
     actionHandle: tableActionHandle(seed, target.targetKey),
     family: table.operationScope === "text" ? "table-text" : "table-structure",
@@ -127662,6 +128019,7 @@ function projectCurrentTableTarget(document2, seed, target) {
     relation: "contained-by-scope",
     operationScope: table.operationScope,
     callableOperations,
+    ...selectionRequiredOperations.length > 0 ? { selectionRequiredOperations } : {},
     supportedOperations: operationsForScope(table.operationScope),
     ...table.operationScope === "text" ? { readback: tableTextReadback(readEditableTargetText(document2, target)) } : {},
     reason: table.operationScope === "text" ? "l07:table-text-target-supported" : "l07:table-structure-target-supported"
@@ -127739,11 +128097,14 @@ function callableOperationsForScope(scope) {
     case "text":
       return TEXT_TRANSFER_OPERATIONS;
     case "cell":
-      return [...CELL_STRUCTURE_OPERATIONS, "merge-cells"];
+      return CELL_STRUCTURE_OPERATIONS;
     default:
       return operationsForScope(scope);
   }
 }
+function selectionRequiredOperationsForScope(scope) {
+  return scope === "cell" ? ["merge-cells"] : [];
+}
 function operationsForScope(scope) {
   switch (scope) {
     case "text":
@@ -128170,9 +128531,6 @@ var DEFAULT_LOCATE_LIMIT = 20;
 var DEFAULT_REWRITE_ALL_LIMIT = 10;
 var DEFAULT_TABLE_TEXT_SCOPE_LIMIT = 3;
 var DEFAULT_PLAN_STEP_LIMIT = 20;
-function documentContentHash(runtime) {
-  return JSON.stringify(runtime.getCanonicalDocument().content);
-}
 function createActionsFamily(runtime) {
   const category = {
     discover(input) {
@@ -128645,10 +129003,10 @@ function runPlanStep(runtime, mode, step, plan) {
       ...before.readback ? { beforeReadback: before.readback } : {}
     };
   }
-  const documentHashBeforeApply = documentContentHash(runtime);
+  const documentBeforeApply = runtime.getCanonicalDocument();
   const applied = applyPlanStep(runtime, step, plan);
-  const documentHashAfterApply = documentContentHash(runtime);
-  const projectedApply = !applied.applied && documentHashAfterApply !== documentHashBeforeApply ? withSuspectMutationApplyResult(applied, step.id, applied.target ?? before.target) : applied;
+  const documentAfterApply = runtime.getCanonicalDocument();
+  const projectedApply = !applied.applied && documentAfterApply !== documentBeforeApply ? withSuspectMutationApplyResult(applied, step.id, applied.target ?? before.target) : applied;
   const after = step.kind === "flag" ? before : step.target ? readPlanTarget(runtime, step.target) : before;
   return {
     id: step.id,
@@ -128699,7 +129057,8 @@ function runPlanTableActionStep(runtime, mode, step, plan) {
       tableAction: tableAction2
     });
   }
-  if (!operationKind || !tableAction2.callableOperations.includes(operationKind)) {
+  const isSelectionRequiredOperation = step.kind === "tableSelection" && operationKind !== void 0 && (tableAction2.selectionRequiredOperations ?? []).includes(operationKind) && tableSelectionStepHasDescriptor(step.operation);
+  if (!operationKind || !tableAction2.callableOperations.includes(operationKind) && !isSelectionRequiredOperation) {
     return blockedPlanStepFromDetails(
       step.id,
       step.kind,
@@ -128963,7 +129322,7 @@ function applyRewrite(runtime, target, input) {
     );
   }
   const beforeText = target.scope.content.text;
-  const documentHashBeforeApply = documentContentHash(runtime);
+  const documentBeforeApply = runtime.getCanonicalDocument();
   const result = createReplacementFamily(runtime).applyReplacementScope({
     targetScopeId: target.handle.scopeId,
     operation: "replace",
@@ -128975,7 +129334,7 @@ function applyRewrite(runtime, target, input) {
     ...input.origin ? { origin: input.origin } : {},
     ...input.proposalId ? { proposalId: input.proposalId } : {}
   });
-  const documentMutated = documentContentHash(runtime) !== documentHashBeforeApply;
+  const documentMutated = runtime.getCanonicalDocument() !== documentBeforeApply;
   if (!result.applied) {
     return documentMutated ? withSuspectMutationApplyResult(
       projectApplyResult(result, target),
@@ -129232,19 +129591,7 @@ function findTableAction(runtime, actionHandle) {
   return action?.family === "table-text" ? action : null;
 }
 function findAnyTableAction(runtime, actionHandle) {
-  const compiler = createScopeCompilerService(runtime);
-  for (const scope of compiler.compileAllScopes()) {
-    if (scope.kind !== "table") continue;
-    const result = createTableActionFamily(runtime).listTableActions({
-      handle: scope.handle,
-      nowUtc: currentAuditTimestamp(runtime)
-    });
-    const action = result.actions.find(
-      (candidate) => candidate.actionHandle === actionHandle
-    );
-    if (action) return action;
-  }
-  return null;
+  return findTableActionDescriptor(runtime, actionHandle);
 }
 function findEditableTextAction(runtime, actionHandle) {
   if (!actionHandle.startsWith("scope-command:text-leaf:")) return null;
@@ -129812,6 +130159,11 @@ function tablePlanOperationFamilyBlocker(stepKind, operationKind) {
   }
   return null;
 }
+function tableSelectionStepHasDescriptor(operation) {
+  return Boolean(
+    operation && "selectionDescriptor" in operation && operation.selectionDescriptor
+  );
+}
 function listCommandForOperation(operation, paragraphIndex, origin) {
   switch (operation.kind) {
     case "toggle":