@superdoc-dev/cli 0.17.0-next.25 → 0.17.0-next.27

package/dist/index.js

@@ -68327,7 +68327,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-CCgGAnXY.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-DK5WIHuy.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -88534,6 +88534,22 @@ function fixTable(state, table, tablePos, tr) {
   }
   return tr.setMeta(fixTablesKey, { fixTables: true });
 }
+function findTable($pos) {
+  return findParentNode$1((node3) => node3.type.spec.tableRole === "table", $pos);
+}
+function findParentNode$1(predicate, $pos) {
+  for (let depth = $pos.depth;depth >= 0; depth -= 1) {
+    const node3 = $pos.node(depth);
+    if (predicate(node3))
+      return {
+        node: node3,
+        pos: depth === 0 ? 0 : $pos.before(depth),
+        start: $pos.start(depth),
+        depth
+      };
+  }
+  return null;
+}
 function selectedRect(state) {
   const sel = state.selection;
   const $pos = selectionCell(state);
@@ -90598,8 +90614,11 @@ function trackRevisions(editor) {
     return;
   subscribedEditors.add(editor);
   editor.on("transaction", ({ transaction }) => {
-    if (transaction.docChanged)
-      incrementRevision(editor);
+    if (transaction.getMeta?.("superdoc/block-identity-repair"))
+      return;
+    if (!transaction.docChanged)
+      return;
+    incrementRevision(editor);
   });
 }
 function checkRevision(editor, expectedRevision) {
@@ -100535,19 +100554,22 @@ function toIdentityValue(value) {
   if (typeof value === "number" && Number.isFinite(value))
     return String(value);
 }
-function getBlockIdentityAttrs(node3) {
-  if (!node3 || typeof node3 !== "object")
+function getBlockIdentityAttrsForType(typeName) {
+  if (!typeName)
     return [];
-  return BLOCK_IDENTITY_ATTRS[node3.type] ?? [];
+  return BLOCK_IDENTITY_ATTRS[typeName] ?? [];
 }
-function getExplicitIdentityEntries(node3) {
-  const attrPriority = getBlockIdentityAttrs(node3);
+function shouldSynthesizeParaIdForType(typeName) {
+  return Boolean(typeName && SYNTHETIC_PARA_ID_TYPES.has(typeName));
+}
+function getExplicitIdentityEntries(attrs, typeName) {
+  const attrPriority = getBlockIdentityAttrsForType(typeName);
   if (attrPriority.length === 0)
     return [];
-  const attrs = typeof node3.attrs === "object" && node3.attrs ? node3.attrs : {};
+  const safeAttrs = attrs && typeof attrs === "object" ? attrs : {};
   const identityEntries = [];
   for (const attr of attrPriority) {
-    const value = toIdentityValue(attrs[attr]);
+    const value = toIdentityValue(safeAttrs[attr]);
     if (value)
       identityEntries.push({
         attr,
@@ -100571,18 +100593,6 @@ function groupIdentityEntriesByValue(identityEntries) {
   }
   return [...groupsByValue.values()];
 }
-function shouldSynthesizeParaId(node3) {
-  return Boolean(node3 && typeof node3 === "object" && SYNTHETIC_PARA_ID_TYPES.has(node3.type));
-}
-function collectExplicitBlockIdentities(node3, reservedIds) {
-  if (!node3 || typeof node3 !== "object")
-    return;
-  const identityEntries = getExplicitIdentityEntries(node3);
-  for (const { value } of groupIdentityEntriesByValue(identityEntries))
-    reservedIds.add(value);
-  if (Array.isArray(node3.content))
-    node3.content.forEach((child) => collectExplicitBlockIdentities(child, reservedIds));
-}
 function createDeterministicDocxIdAllocator(reservedIds) {
   let nextValue = 1;
   return () => {
@@ -100597,6 +100607,15 @@ function createDeterministicDocxIdAllocator(reservedIds) {
     throw new Error("Unable to allocate a unique synthetic DOCX block id.");
   };
 }
+function collectExplicitBlockIdentities(node3, reservedIds) {
+  if (!node3 || typeof node3 !== "object")
+    return;
+  const identityEntries = getExplicitIdentityEntries(node3.attrs, node3?.type);
+  for (const { value } of groupIdentityEntriesByValue(identityEntries))
+    reservedIds.add(value);
+  if (Array.isArray(node3.content))
+    node3.content.forEach((child) => collectExplicitBlockIdentities(child, reservedIds));
+}
 function setBlockIdentity(node3, attrName, value) {
   node3.attrs = {
     ...node3.attrs ?? {},
@@ -100606,7 +100625,7 @@ function setBlockIdentity(node3, attrName, value) {
 function normalizeBlockIdentitiesInNode(node3, seenIds, allocateDocxId) {
   if (!node3 || typeof node3 !== "object")
     return;
-  const groupedIdentities = groupIdentityEntriesByValue(getExplicitIdentityEntries(node3));
+  const groupedIdentities = groupIdentityEntriesByValue(getExplicitIdentityEntries(node3.attrs, node3?.type));
   if (groupedIdentities.length > 0)
     for (const identityGroup of groupedIdentities)
       if (seenIds.has(identityGroup.value)) {
@@ -100616,7 +100635,7 @@ function normalizeBlockIdentitiesInNode(node3, seenIds, allocateDocxId) {
         seenIds.add(replacementId);
       } else
         seenIds.add(identityGroup.value);
-  else if (shouldSynthesizeParaId(node3)) {
+  else if (shouldSynthesizeParaIdForType(node3?.type)) {
     const syntheticParaId = allocateDocxId();
     setBlockIdentity(node3, "paraId", syntheticParaId);
     seenIds.add(syntheticParaId);
@@ -108234,6 +108253,7 @@ function buildBlockIndex(editor) {
   const byId = /* @__PURE__ */ new Map;
   const ambiguous = /* @__PURE__ */ new Set;
   const pathByNode = /* @__PURE__ */ new WeakMap;
+  const explicitIdentities = /* @__PURE__ */ new Map;
   pathByNode.set(editor.state.doc, []);
   function registerKey(key, candidate) {
     if (byId.has(key)) {
@@ -108242,11 +108262,44 @@ function buildBlockIndex(editor) {
     } else if (!ambiguous.has(key))
       byId.set(key, candidate);
   }
+  function recordExplicitIdentities(node3, pos) {
+    const attrPriority = getBlockIdentityAttrsForType(node3.type?.name);
+    if (attrPriority.length === 0)
+      return;
+    const attrs = node3.attrs ?? {};
+    let nodeGroups;
+    for (const attr of attrPriority) {
+      const value = toIdentityValue(attrs[attr]);
+      if (!value)
+        continue;
+      if (!nodeGroups)
+        nodeGroups = /* @__PURE__ */ new Map;
+      const existing = nodeGroups.get(value);
+      if (existing)
+        existing.push(attr);
+      else
+        nodeGroups.set(value, [attr]);
+    }
+    if (!nodeGroups)
+      return;
+    for (const [value, attrsForValue] of nodeGroups) {
+      const observations = explicitIdentities.get(value);
+      const observation = {
+        pos,
+        attrs: attrsForValue
+      };
+      if (observations)
+        observations.push(observation);
+      else
+        explicitIdentities.set(value, [observation]);
+    }
+  }
   editor.state.doc.descendants((node3, pos, parent, index2) => {
     const parentPath = parent ? pathByNode.get(parent) ?? [] : [];
     const path2 = typeof index2 === "number" && Number.isInteger(index2) && index2 >= 0 ? [...parentPath, index2] : undefined;
     if (path2)
       pathByNode.set(node3, path2);
+    recordExplicitIdentities(node3, pos);
     const nodeType = mapBlockNodeType(node3);
     if (!nodeType)
       return;
@@ -108269,7 +108322,8 @@ function buildBlockIndex(editor) {
   return {
     candidates,
     byId,
-    ambiguous
+    ambiguous,
+    explicitIdentities
   };
 }
 function findBlockById(index2, address2) {
@@ -111854,6 +111908,8 @@ function resolveStoryRuntime(hostEditor, locator, options = {}) {
   if (store && !hasHostStoreSyncListener(runtime.editor, storyKey)) {
     markHostStoreSyncListener(runtime.editor, storyKey);
     runtime.editor.on("transaction", ({ transaction }) => {
+      if (transaction.getMeta?.("superdoc/block-identity-repair"))
+        return;
       if (transaction.docChanged)
         incrementStoryRevision(store, storyKey);
     });
@@ -134913,7 +134969,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_CCgGAnXY_es = __esm(() => {
+var init_SuperConverter_DK5WIHuy_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -175657,7 +175713,7 @@ var init_SuperConverter_CCgGAnXY_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-BvrKiWf0.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-BLN1v7eO.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -177140,6 +177196,194 @@ function applySetMarksToResolved(editor, existingMarks, setMarks) {
   }
   return marks;
 }
+function planRepairs(doc2, identityMap) {
+  if (identityMap)
+    return planRepairsFromIdentityMap(identityMap);
+  return planRepairsByWalk(doc2);
+}
+function planRepairsFromIdentityMap(identityMap) {
+  let hasDuplicates = false;
+  for (const observations of identityMap.values())
+    if (observations.length > 1) {
+      hasDuplicates = true;
+      break;
+    }
+  if (!hasDuplicates)
+    return {
+      plans: [],
+      report: {
+        repairedBlockCount: 0,
+        duplicateBlockIds: [],
+        renames: []
+      }
+    };
+  const rewrites = [];
+  for (const [value, observations] of identityMap) {
+    if (observations.length <= 1)
+      continue;
+    for (let i4 = 1;i4 < observations.length; i4 += 1) {
+      const { pos, attrs } = observations[i4];
+      rewrites.push({
+        pos,
+        value,
+        attrs
+      });
+    }
+  }
+  rewrites.sort((a, b) => a.pos - b.pos);
+  const allocateDocxId = createDeterministicDocxIdAllocator(new Set(identityMap.keys()));
+  const plansByPos = /* @__PURE__ */ new Map;
+  const duplicateBlockIds = [];
+  const renames = [];
+  for (const { pos, value, attrs } of rewrites) {
+    const replacementValue = allocateDocxId();
+    let plan = plansByPos.get(pos);
+    if (!plan) {
+      plan = {
+        pos,
+        rewrittenGroups: []
+      };
+      plansByPos.set(pos, plan);
+    }
+    const attrsCopy = [...attrs];
+    plan.rewrittenGroups.push({
+      originalValue: value,
+      replacementValue,
+      attrs: attrsCopy
+    });
+    duplicateBlockIds.push(value);
+    renames.push({
+      originalValue: value,
+      replacementValue,
+      attrs: attrsCopy
+    });
+  }
+  const plans = [...plansByPos.values()].sort((a, b) => a.pos - b.pos);
+  return {
+    plans,
+    report: {
+      repairedBlockCount: plans.length,
+      duplicateBlockIds,
+      renames
+    }
+  };
+}
+function planRepairsByWalk(doc2) {
+  const reservedIds = /* @__PURE__ */ new Set;
+  let hasDuplicates = false;
+  doc2.descendants((node3) => {
+    const entries2 = getExplicitIdentityEntries(node3.attrs, node3.type?.name);
+    for (const { value } of groupIdentityEntriesByValue(entries2))
+      if (reservedIds.has(value))
+        hasDuplicates = true;
+      else
+        reservedIds.add(value);
+  });
+  if (!hasDuplicates)
+    return {
+      plans: [],
+      report: {
+        repairedBlockCount: 0,
+        duplicateBlockIds: [],
+        renames: []
+      }
+    };
+  const allocateDocxId = createDeterministicDocxIdAllocator(reservedIds);
+  const seenIds = /* @__PURE__ */ new Set;
+  const plans = [];
+  const duplicateBlockIds = [];
+  const renames = [];
+  doc2.descendants((node3, pos) => {
+    const groups = groupIdentityEntriesByValue(getExplicitIdentityEntries(node3.attrs, node3.type?.name));
+    if (groups.length === 0)
+      return;
+    let plan = null;
+    for (const group of groups)
+      if (seenIds.has(group.value)) {
+        if (!plan)
+          plan = {
+            pos,
+            rewrittenGroups: []
+          };
+        const replacementValue = allocateDocxId();
+        plan.rewrittenGroups.push({
+          originalValue: group.value,
+          replacementValue,
+          attrs: [...group.attrs]
+        });
+        duplicateBlockIds.push(group.value);
+        renames.push({
+          originalValue: group.value,
+          replacementValue,
+          attrs: [...group.attrs]
+        });
+        seenIds.add(replacementValue);
+      } else
+        seenIds.add(group.value);
+    if (plan)
+      plans.push(plan);
+  });
+  return {
+    plans,
+    report: {
+      repairedBlockCount: plans.length,
+      duplicateBlockIds,
+      renames
+    }
+  };
+}
+function repairDuplicateBlockIdentities(editor) {
+  const doc2 = editor.state?.doc;
+  if (!doc2 || typeof doc2.descendants !== "function")
+    return null;
+  if (typeof editor.state?.tr !== "object" || editor.state.tr === null)
+    return null;
+  if (typeof editor.dispatch !== "function")
+    return null;
+  let identityMap;
+  try {
+    identityMap = getBlockIndex(editor).explicitIdentities;
+  } catch {
+    identityMap = undefined;
+  }
+  const { plans, report } = planRepairs(doc2, identityMap);
+  if (plans.length === 0)
+    return null;
+  const tr = editor.state.tr;
+  tr.setMeta("addToHistory", false);
+  tr.setMeta("superdoc/block-identity-repair", report);
+  for (const plan of plans)
+    for (const group of plan.rewrittenGroups)
+      for (const attr of group.attrs)
+        tr.setNodeAttribute(plan.pos, attr, group.replacementValue);
+  editor.dispatch(tr);
+  const blockedNodeIds = [];
+  for (const plan of plans) {
+    const node3 = editor.state.doc.nodeAt(plan.pos);
+    if (!node3) {
+      blockedNodeIds.push(`pos:${plan.pos}`);
+      continue;
+    }
+    for (const group of plan.rewrittenGroups)
+      for (const attr of group.attrs)
+        if (node3.attrs?.[attr] !== group.replacementValue) {
+          const observedId = typeof node3.attrs?.id === "string" && node3.attrs.id || typeof node3.attrs?.sdBlockId === "string" && node3.attrs.sdBlockId || `pos:${plan.pos}`;
+          blockedNodeIds.push(observedId);
+        }
+  }
+  if (blockedNodeIds.length > 0) {
+    const unique = [...new Set(blockedNodeIds)];
+    const MAX_ID_PREVIEW_LENGTH = 32;
+    const truncate = (id2) => id2.length > MAX_ID_PREVIEW_LENGTH ? `${id2.slice(0, MAX_ID_PREVIEW_LENGTH - 1)}…` : id2;
+    const preview = unique.slice(0, 4).map(truncate).join(", ");
+    const previewSuffix = unique.length > 4 ? `, +${unique.length - 4} more` : "";
+    throw planError("REPAIR_BLOCKED", `Runtime identity repair was rejected by a transaction filter (${unique.length} node${unique.length === 1 ? "" : "s"}: ${preview}${previewSuffix}). A structured-content lock or permission range likely covers one of the duplicate blocks. Re-import the document via doc.open to assign unique identities.`, undefined, {
+      blockedNodeIds: unique,
+      remediation: "Re-import the document via doc.open to assign unique identities."
+    });
+  }
+  return report;
+}
 function getCandidateText(editor, candidate, options) {
   if (candidate.node.childCount > 0)
     return textContentInBlock(candidate.node, options);
@@ -178344,12 +178588,15 @@ function assertNoDuplicateBlockIds(index2) {
     if (count2 === 1)
       duplicates.push(candidate.nodeId);
   }
-  if (duplicates.length > 0)
-    throw planError("DOCUMENT_IDENTITY_CONFLICT", "Document contains blocks with duplicate identities. This must be resolved before mutations can be applied.", undefined, {
+  if (duplicates.length > 0) {
+    const preview = duplicates.slice(0, 4).join(", ");
+    const previewSuffix = duplicates.length > 4 ? `, +${duplicates.length - 4} more` : "";
+    throw planError("DOCUMENT_IDENTITY_CONFLICT", `Document contains ${duplicates.length} block identit${duplicates.length === 1 ? "y" : "ies"} shared by multiple blocks (${preview}${previewSuffix}). Re-import the document via doc.open to assign unique identities.`, undefined, {
       duplicateBlockIds: duplicates,
       blockCount: duplicates.length,
-      remediation: "Re-import the document or call document.repair() to assign unique identities."
+      remediation: "Re-import the document via doc.open to assign unique identities."
     });
+  }
 }
 function assertSingleStoryKey(steps) {
   let seenStoryKey;
@@ -178377,11 +178624,71 @@ function assertSingleStoryKey(steps) {
       });
   }
 }
+function collectReferencedBlockIds(step3) {
+  const where = step3.where;
+  const ids = [];
+  const withinNodeId = where.within?.nodeId;
+  if (withinNodeId)
+    ids.push(withinNodeId);
+  if (isRefWhere(where)) {
+    const ref3 = where.ref;
+    if (ref3.startsWith("text:")) {
+      const decoded = decodeRef(ref3);
+      if (decoded) {
+        for (const seg of decoded.segments ?? [])
+          if (seg?.blockId)
+            ids.push(seg.blockId);
+        const nodeId = decoded.node?.nodeId;
+        if (nodeId)
+          ids.push(nodeId);
+      }
+    } else
+      ids.push(ref3);
+    return ids;
+  }
+  if (isBlockWhere(where)) {
+    ids.push(where.nodeId);
+    return ids;
+  }
+  if (isTargetWhere(where))
+    for (const point3 of [where.target?.start, where.target?.end]) {
+      const blockId = point3?.blockId;
+      if (blockId)
+        ids.push(blockId);
+      const edgeNodeId = point3?.node?.nodeId;
+      if (edgeNodeId)
+        ids.push(edgeNodeId);
+    }
+  return ids;
+}
+function assertNoStaleRefsAfterRepair(steps, repairedIds) {
+  if (repairedIds.size === 0)
+    return;
+  for (const step3 of steps)
+    for (const blockId of collectReferencedBlockIds(step3)) {
+      if (!repairedIds.has(blockId))
+        continue;
+      throw planError("STALE_REF", `Step "${step3.id}" references block id "${blockId}", which was duplicated in this document and has just been repaired (the duplicate occurrence was renamed). The reference is ambiguous — it may have pointed at the renamed block. Re-run query.match / doc.find against the repaired document and retry with a fresh ref.`, step3.id, {
+        blockId,
+        repairedBlockIds: [...repairedIds],
+        remediation: "Re-run query.match() or doc.find() to obtain fresh refs, then retry the mutation."
+      });
+    }
+}
 function compilePlan(editor, steps, options = {}) {
   if (steps.length > 200)
     throw planError("INVALID_INPUT", `plan contains ${steps.length} steps, maximum is 200`);
+  let index2 = getBlockIndex(editor);
+  if (!options.skipIdentityRepair) {
+    const repair = repairDuplicateBlockIdentities(editor);
+    if (repair) {
+      clearIndexCache(editor);
+      index2 = getBlockIndex(editor);
+      console.warn(`[plan-engine] Repaired ${repair.repairedBlockCount} block(s) with duplicate identities before plan compilation. Original ids: ${repair.duplicateBlockIds.slice(0, 4).join(", ")}${repair.duplicateBlockIds.length > 4 ? `, +${repair.duplicateBlockIds.length - 4} more` : ""}.`);
+      assertNoStaleRefsAfterRepair(steps, new Set(repair.duplicateBlockIds));
+    }
+  }
   const compiledRevision = getRevision(editor);
-  const index2 = getBlockIndex(editor);
   assertNoDuplicateBlockIds(index2);
   const mutationSteps = [];
   const assertSteps = [];
@@ -180474,6 +180781,7 @@ function executeCompiledPlan(editor, compiled, options = {}) {
 function executePlan(editor, input) {
   if (!input.steps?.length)
     throw planError("INVALID_INPUT", "plan must contain at least one step");
+  checkRevision(editor, input.expectedRevision);
   return executeCompiledPlan(editor, compilePlan(editor, input.steps, { selectTextModel: input.changeMode === "tracked" ? "raw" : "visible" }), {
     changeMode: input.changeMode ?? "direct",
     expectedRevision: input.expectedRevision
@@ -181820,7 +182128,9 @@ function selectionMutationWrapper(editor, request, options) {
         ensureTrackedInlinePropertySupport(inlineKeys);
     }
     const stepId = v4_default();
-    const compiled = compilePlan(storyEditor, [buildSelectionStepDef(stepId, request, buildSelectionWhere(request))]);
+    const step3 = buildSelectionStepDef(stepId, request, buildSelectionWhere(request));
+    checkRevision(storyEditor, options?.expectedRevision);
+    const compiled = compilePlan(storyEditor, [step3], options?.dryRun ? { skipIdentityRepair: true } : undefined);
     if (request.kind === "insert" && request.target) {
       if (request.target.start.kind === "nodeEdge" || request.target.end.kind === "nodeEdge")
         throw new DocumentApiAdapterError("INVALID_TARGET", "Text inserts do not support nodeEdge targets. Use a text-offset target inside a textblock.");
@@ -181850,7 +182160,6 @@ function selectionMutationWrapper(editor, request, options) {
         }
       }
     }
-    checkRevision(storyEditor, options?.expectedRevision);
     if (options?.dryRun) {
       const resolution$1 = buildSelectionResolutionFromCompiled(compiled, stepId);
       if (request.kind === "insert" && !request.text)
@@ -182068,6 +182377,7 @@ function insertStructuredInner(editor, input, options) {
       }
     };
   } else if (ref3) {
+    checkRevision(editor, options?.expectedRevision);
     const dummyStepId = v4_default();
     const compiled = compilePlan(editor, [{
       id: dummyStepId,
@@ -182080,7 +182390,7 @@ function insertStructuredInner(editor, input, options) {
         position: "before",
         content: { text: "" }
       }
-    }]);
+    }], options?.dryRun ? { skipIdentityRepair: true } : undefined);
     const compiledTarget = compiled.mutationSteps.find((s) => s.step.id === dummyStepId)?.targets[0];
     if (!compiledTarget)
       throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "Structured insert ref could not be resolved.", { ref: ref3 });
@@ -186052,8 +186362,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, normalizeActorId = (value) => {
     }
   };
 };
-var init_create_headless_toolbar_BvrKiWf0_es = __esm(() => {
-  init_SuperConverter_CCgGAnXY_es();
+var init_create_headless_toolbar_BLN1v7eO_es = __esm(() => {
+  init_SuperConverter_DK5WIHuy_es();
   init_uuid_B2wVPhPi_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
@@ -235222,7 +235532,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-BB0n1coY.es.js
+// ../../packages/superdoc/dist/chunks/src-PJVnllcq.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -258881,7 +259191,7 @@ function previewPlan(editor, input2) {
   let currentPhase = "compile";
   let evaluatedRevision = getRevision(editor);
   try {
-    const compiled = compilePlan(editor, input2.steps);
+    const compiled = compilePlan(editor, input2.steps, { skipIdentityRepair: true });
     evaluatedRevision = compiled.compiledRevision;
     currentPhase = "execute";
     const tr = editor.state.tr;
@@ -286373,11 +286683,12 @@ function percentile(sortedValues, p$12) {
   return sortedValues[lower] * (1 - weight) + sortedValues[upper] * weight;
 }
 function pushEmptyLineSelectionBand(rects, opts) {
+  const lineOffset = sumLineHeights(opts.measure, opts.startLineIndex, opts.lineIndex);
   rects.push({
     x: opts.x,
-    y: opts.y,
+    y: opts.yBase + lineOffset,
     width: Math.max(1, opts.width),
-    height: opts.height,
+    height: opts.lineHeight,
     pageIndex: opts.pageIndex
   });
 }
@@ -286408,13 +286719,15 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
           const sliceFrom = Math.max(range.pmStart, from$1);
           const sliceTo = Math.min(range.pmEnd, to);
           if (sliceFrom >= sliceTo) {
-            const emptyLineOffset = lineHeightBeforeIndex$1(measure, index2) - lineHeightBeforeIndex$1(measure, fragment2.fromLine);
             pushEmptyLineSelectionBand(rects, {
               x: fragment2.x,
-              y: fragment2.y + emptyLineOffset + pageTopY,
+              yBase: fragment2.y + pageTopY,
               width: fragment2.width,
-              height: line.lineHeight,
-              pageIndex
+              lineHeight: line.lineHeight,
+              pageIndex,
+              measure,
+              lineIndex: index2,
+              startLineIndex: fragment2.fromLine
             });
             return;
           }
@@ -286596,13 +286909,15 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
                 const sliceFrom = Math.max(range.pmStart, from$1);
                 const sliceTo = Math.min(range.pmEnd, to);
                 if (sliceFrom >= sliceTo) {
-                  const emptyLineOffset = lineHeightBeforeIndex$1(info.measure, index2) - lineHeightBeforeIndex$1(info.measure, info.startLine);
                   pushEmptyLineSelectionBand(rects, {
                     x: fragment2.x + contentOffsetX + cellX + padding.left,
-                    y: fragment2.y + contentOffsetY + rowOffset + blockTopCursor + effectiveSpacingBeforePx + emptyLineOffset + pageTopY,
+                    yBase: fragment2.y + contentOffsetY + rowOffset + blockTopCursor + effectiveSpacingBeforePx + pageTopY,
                     width: cellMeasure.width - padding.left - padding.right,
-                    height: line.lineHeight,
-                    pageIndex
+                    lineHeight: line.lineHeight,
+                    pageIndex,
+                    measure: info.measure,
+                    lineIndex: index2,
+                    startLineIndex: info.startLine
                   });
                   return;
                 }
@@ -286943,15 +287258,7 @@ function selectionCollapsesAcrossTableCells(doc$12, anchor, head) {
       return false;
     const $from = doc$12.resolve(Math.min(anchor, head));
     const $to = doc$12.resolve(Math.max(anchor, head));
-    const cellAncestor = (pos) => {
-      for (let depth = pos.depth;depth > 0; depth--) {
-        const role = pos.node(depth).type.spec.tableRole;
-        if (role === "cell" || role === "header_cell")
-          return pos.node(depth);
-      }
-      return null;
-    };
-    return cellAncestor($from) !== cellAncestor($to) && $to.parentOffset === 0;
+    return cellWrapping2($from) !== cellWrapping2($to) && $to.parentOffset === 0;
   } catch {
     return false;
   }
@@ -288939,6 +289246,19 @@ function getTopLevelTableBlockAtPos(doc$12, blocks2, tablePos) {
     return null;
   return getTableBlocks(blocks2)[tableIndex] ?? null;
 }
+function resolveCellContextAtResolvedPos($pos) {
+  const $cell = cellAround($pos);
+  if (!$cell)
+    return null;
+  const table2 = findTable($cell);
+  if (!table2)
+    return null;
+  return {
+    $cell,
+    cellPos: $cell.pos,
+    tablePos: table2.pos
+  };
+}
 function resolveCellAnchorStateFromCellPos(doc$12, blocks2, cellPos) {
   if (!doc$12 || !Number.isFinite(cellPos) || cellPos < 0 || cellPos > doc$12.content.size)
     return null;
@@ -289043,30 +289363,30 @@ function resolveCellContext(doc$12, pos) {
   } catch {
     return null;
   }
-  let cellDepth = -1;
-  let tableDepth = -1;
-  for (let depth = $pos.depth;depth > 0; depth--) {
-    const role = $pos.node(depth).type.spec.tableRole;
-    if (cellDepth === -1 && (role === "cell" || role === "header_cell"))
-      cellDepth = depth;
-    if (cellDepth !== -1 && role === "table") {
-      tableDepth = depth;
-      break;
-    }
-  }
-  if (cellDepth === -1 || tableDepth === -1)
+  const context = resolveCellContextAtResolvedPos($pos);
+  if (!context)
     return null;
   return {
-    cellPos: $pos.before(cellDepth),
-    tablePos: $pos.before(tableDepth)
+    cellPos: context.cellPos,
+    tablePos: context.tablePos
   };
 }
 function resolveCrossCellSelection(doc$12, anchorPos, headPos) {
-  const anchor = resolveCellContext(doc$12, anchorPos);
-  const head = resolveCellContext(doc$12, headPos);
+  if (!doc$12)
+    return null;
+  let $anchorPos;
+  let $headPos;
+  try {
+    $anchorPos = doc$12.resolve(anchorPos);
+    $headPos = doc$12.resolve(headPos);
+  } catch {
+    return null;
+  }
+  const anchor = resolveCellContextAtResolvedPos($anchorPos);
+  const head = resolveCellContextAtResolvedPos($headPos);
   if (!anchor || !head)
     return null;
-  if (anchor.tablePos !== head.tablePos)
+  if (!inSameTable(anchor.$cell, head.$cell))
     return null;
   if (anchor.cellPos === head.cellPos)
     return null;
@@ -307106,7 +307426,8 @@ var Node$13 = class Node$14 {
   const ySyncMeta = tr.getMeta(ySyncPluginKey);
   const pendingDeadKeyPlaceholder = TrackChangesBasePluginKey.getState(state)?.pendingDeadKeyPlaceholder ?? null;
   const hasDisallowedMeta = tr.meta && Object.keys(tr.meta).some((meta2) => !ALLOWED_META_KEYS.has(meta2));
-  if (ySyncMeta?.isChangeOrigin || !tr.steps.length || hasDisallowedMeta && !isProgrammaticInput || notAllowedMeta.includes(tr.getMeta("inputType")) || tr.getMeta(CommentsPluginKey)) {
+  const isBlockIdentityRepair = Boolean(tr.getMeta("superdoc/block-identity-repair"));
+  if (ySyncMeta?.isChangeOrigin || !tr.steps.length || isBlockIdentityRepair || hasDisallowedMeta && !isProgrammaticInput || notAllowedMeta.includes(tr.getMeta("inputType")) || tr.getMeta(CommentsPluginKey)) {
     if (pendingDeadKeyPlaceholder && !isCompositionTransaction(tr))
       mergeTrackChangesMeta(tr, { pendingDeadKeyPlaceholder: null });
     return tr;
@@ -333454,13 +333775,13 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions, TRACKED_MARK_NAMES;
-var init_src_BB0n1coY_es = __esm(() => {
+var init_src_PJVnllcq_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_CCgGAnXY_es();
+  init_SuperConverter_DK5WIHuy_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
   init_uuid_B2wVPhPi_es();
-  init_create_headless_toolbar_BvrKiWf0_es();
+  init_create_headless_toolbar_BLN1v7eO_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -369245,11 +369566,11 @@ function print() { __p += __j.call(arguments, '') }
   ]);
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-C_J_pCF0.es.js
+// ../../packages/superdoc/dist/chunks/create-super-doc-ui-CrjXK3s_.es.js
 var DEFAULT_TEXT_ALIGN_OPTIONS, DEFAULT_LINE_HEIGHT_OPTIONS, DEFAULT_ZOOM_OPTIONS, DEFAULT_DOCUMENT_MODE_OPTIONS, DEFAULT_FONT_SIZE_OPTIONS, headlessToolbarConstants, MOD_ALIASES, ALT_ALIASES, CTRL_ALIASES, SHIFT_ALIASES, BUILTIN_CONTEXT_MENU_GROUPS, BUILTIN_GROUP_ORDER, RESERVED_PROXY_PROPERTY_NAMES, ALL_TOOLBAR_COMMAND_IDS, EMPTY_ACTIVE_IDS, FONT_SIZE_OPTIONS;
-var init_create_super_doc_ui_C_J_pCF0_es = __esm(() => {
-  init_SuperConverter_CCgGAnXY_es();
-  init_create_headless_toolbar_BvrKiWf0_es();
+var init_create_super_doc_ui_CrjXK3s__es = __esm(() => {
+  init_SuperConverter_DK5WIHuy_es();
+  init_create_headless_toolbar_BLN1v7eO_es();
   DEFAULT_TEXT_ALIGN_OPTIONS = [
     {
       label: "Left",
@@ -369540,16 +369861,16 @@ var init_zipper_yaJVJ4z9_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_BB0n1coY_es();
-  init_SuperConverter_CCgGAnXY_es();
+  init_src_PJVnllcq_es();
+  init_SuperConverter_DK5WIHuy_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_BvrKiWf0_es();
+  init_create_headless_toolbar_BLN1v7eO_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
   init_DocxZipper_FUsfThjV_es();
-  init_create_super_doc_ui_C_J_pCF0_es();
+  init_create_super_doc_ui_CrjXK3s__es();
   init_ui_C5PAS9hY_es();
   init_eventemitter3_BnGqBE_Q_es();
   init_errors_CNaD6vcg_es();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/cli",
-  "version": "0.17.0-next.25",
+  "version": "0.17.0-next.27",
   "type": "module",
   "bin": {
     "superdoc": "./dist/index.js"
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "@superdoc-dev/cli-darwin-arm64": "0.17.0-next.25",
-    "@superdoc-dev/cli-darwin-x64": "0.17.0-next.25",
-    "@superdoc-dev/cli-linux-arm64": "0.17.0-next.25",
-    "@superdoc-dev/cli-windows-x64": "0.17.0-next.25",
-    "@superdoc-dev/cli-linux-x64": "0.17.0-next.25"
+    "@superdoc-dev/cli-darwin-arm64": "0.17.0-next.27",
+    "@superdoc-dev/cli-darwin-x64": "0.17.0-next.27",
+    "@superdoc-dev/cli-linux-x64": "0.17.0-next.27",
+    "@superdoc-dev/cli-linux-arm64": "0.17.0-next.27",
+    "@superdoc-dev/cli-windows-x64": "0.17.0-next.27"
   },
   "scripts": {
     "predev": "node scripts/ensure-superdoc-build.js",