@superdoc-dev/mcp 0.12.0-next.26 → 0.12.0-next.28

package/dist/index.js

@@ -52172,7 +52172,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-WQVqM0th.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")
@@ -74459,8 +74459,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) {
@@ -84396,19 +84399,22 @@ function toIdentityValue(value) {
   if (typeof value === "number" && Number.isFinite(value))
     return String(value);
 }
-function getBlockIdentityAttrs(node2) {
-  if (!node2 || typeof node2 !== "object")
+function getBlockIdentityAttrsForType(typeName) {
+  if (!typeName)
     return [];
-  return BLOCK_IDENTITY_ATTRS[node2.type] ?? [];
+  return BLOCK_IDENTITY_ATTRS[typeName] ?? [];
+}
+function shouldSynthesizeParaIdForType(typeName) {
+  return Boolean(typeName && SYNTHETIC_PARA_ID_TYPES.has(typeName));
 }
-function getExplicitIdentityEntries(node2) {
-  const attrPriority = getBlockIdentityAttrs(node2);
+function getExplicitIdentityEntries(attrs, typeName) {
+  const attrPriority = getBlockIdentityAttrsForType(typeName);
   if (attrPriority.length === 0)
     return [];
-  const attrs = typeof node2.attrs === "object" && node2.attrs ? node2.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,
@@ -84432,18 +84438,6 @@ function groupIdentityEntriesByValue(identityEntries) {
   }
   return [...groupsByValue.values()];
 }
-function shouldSynthesizeParaId(node2) {
-  return Boolean(node2 && typeof node2 === "object" && SYNTHETIC_PARA_ID_TYPES.has(node2.type));
-}
-function collectExplicitBlockIdentities(node2, reservedIds) {
-  if (!node2 || typeof node2 !== "object")
-    return;
-  const identityEntries = getExplicitIdentityEntries(node2);
-  for (const { value } of groupIdentityEntriesByValue(identityEntries))
-    reservedIds.add(value);
-  if (Array.isArray(node2.content))
-    node2.content.forEach((child) => collectExplicitBlockIdentities(child, reservedIds));
-}
 function createDeterministicDocxIdAllocator(reservedIds) {
   let nextValue = 1;
   return () => {
@@ -84458,6 +84452,15 @@ function createDeterministicDocxIdAllocator(reservedIds) {
     throw new Error("Unable to allocate a unique synthetic DOCX block id.");
   };
 }
+function collectExplicitBlockIdentities(node2, reservedIds) {
+  if (!node2 || typeof node2 !== "object")
+    return;
+  const identityEntries = getExplicitIdentityEntries(node2.attrs, node2?.type);
+  for (const { value } of groupIdentityEntriesByValue(identityEntries))
+    reservedIds.add(value);
+  if (Array.isArray(node2.content))
+    node2.content.forEach((child) => collectExplicitBlockIdentities(child, reservedIds));
+}
 function setBlockIdentity(node2, attrName, value) {
   node2.attrs = {
     ...node2.attrs ?? {},
@@ -84467,7 +84470,7 @@ function setBlockIdentity(node2, attrName, value) {
 function normalizeBlockIdentitiesInNode(node2, seenIds, allocateDocxId) {
   if (!node2 || typeof node2 !== "object")
     return;
-  const groupedIdentities = groupIdentityEntriesByValue(getExplicitIdentityEntries(node2));
+  const groupedIdentities = groupIdentityEntriesByValue(getExplicitIdentityEntries(node2.attrs, node2?.type));
   if (groupedIdentities.length > 0)
     for (const identityGroup of groupedIdentities)
       if (seenIds.has(identityGroup.value)) {
@@ -84477,7 +84480,7 @@ function normalizeBlockIdentitiesInNode(node2, seenIds, allocateDocxId) {
         seenIds.add(replacementId);
       } else
         seenIds.add(identityGroup.value);
-  else if (shouldSynthesizeParaId(node2)) {
+  else if (shouldSynthesizeParaIdForType(node2?.type)) {
     const syntheticParaId = allocateDocxId();
     setBlockIdentity(node2, "paraId", syntheticParaId);
     seenIds.add(syntheticParaId);
@@ -92095,6 +92098,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)) {
@@ -92103,11 +92107,44 @@ function buildBlockIndex(editor) {
     } else if (!ambiguous.has(key))
       byId.set(key, candidate);
   }
+  function recordExplicitIdentities(node2, pos) {
+    const attrPriority = getBlockIdentityAttrsForType(node2.type?.name);
+    if (attrPriority.length === 0)
+      return;
+    const attrs = node2.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((node2, 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(node2, path2);
+    recordExplicitIdentities(node2, pos);
     const nodeType = mapBlockNodeType(node2);
     if (!nodeType)
       return;
@@ -92130,7 +92167,8 @@ function buildBlockIndex(editor) {
   return {
     candidates,
     byId,
-    ambiguous
+    ambiguous,
+    explicitIdentities
   };
 }
 function findBlockById(index2, address) {
@@ -95715,6 +95753,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);
     });
@@ -118774,7 +118814,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_WQVqM0th_es = __esm(() => {
+var init_SuperConverter_DK5WIHuy_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -159518,7 +159558,7 @@ var init_SuperConverter_WQVqM0th_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-B8OXKxcw.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-BLN1v7eO.es.js
 function parseSizeUnit(val = "0") {
   const length = val.toString() || "0";
   const value = Number.parseFloat(length);
@@ -161001,6 +161041,194 @@ function applySetMarksToResolved(editor, existingMarks, setMarks) {
   }
   return marks;
 }
+function planRepairs(doc3, identityMap) {
+  if (identityMap)
+    return planRepairsFromIdentityMap(identityMap);
+  return planRepairsByWalk(doc3);
+}
+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(doc3) {
+  const reservedIds = /* @__PURE__ */ new Set;
+  let hasDuplicates = false;
+  doc3.descendants((node2) => {
+    const entries = getExplicitIdentityEntries(node2.attrs, node2.type?.name);
+    for (const { value } of groupIdentityEntriesByValue(entries))
+      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 = [];
+  doc3.descendants((node2, pos) => {
+    const groups = groupIdentityEntriesByValue(getExplicitIdentityEntries(node2.attrs, node2.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 doc3 = editor.state?.doc;
+  if (!doc3 || typeof doc3.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(doc3, 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 node2 = editor.state.doc.nodeAt(plan.pos);
+    if (!node2) {
+      blockedNodeIds.push(`pos:${plan.pos}`);
+      continue;
+    }
+    for (const group of plan.rewrittenGroups)
+      for (const attr of group.attrs)
+        if (node2.attrs?.[attr] !== group.replacementValue) {
+          const observedId = typeof node2.attrs?.id === "string" && node2.attrs.id || typeof node2.attrs?.sdBlockId === "string" && node2.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 = (id) => id.length > MAX_ID_PREVIEW_LENGTH ? `${id.slice(0, MAX_ID_PREVIEW_LENGTH - 1)}…` : id;
+    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);
@@ -162205,12 +162433,15 @@ function assertNoDuplicateBlockIds(index2) {
     if (count === 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;
@@ -162238,11 +162469,71 @@ function assertSingleStoryKey(steps) {
       });
   }
 }
+function collectReferencedBlockIds(step2) {
+  const where = step2.where;
+  const ids = [];
+  const withinNodeId = where.within?.nodeId;
+  if (withinNodeId)
+    ids.push(withinNodeId);
+  if (isRefWhere(where)) {
+    const ref2 = where.ref;
+    if (ref2.startsWith("text:")) {
+      const decoded = decodeRef(ref2);
+      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(ref2);
+    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 step2 of steps)
+    for (const blockId of collectReferencedBlockIds(step2)) {
+      if (!repairedIds.has(blockId))
+        continue;
+      throw planError("STALE_REF", `Step "${step2.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.`, step2.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 = [];
@@ -164335,6 +164626,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
@@ -165681,7 +165973,9 @@ function selectionMutationWrapper(editor, request, options) {
         ensureTrackedInlinePropertySupport(inlineKeys);
     }
     const stepId = v4_default();
-    const compiled = compilePlan(storyEditor, [buildSelectionStepDef(stepId, request, buildSelectionWhere(request))]);
+    const step2 = buildSelectionStepDef(stepId, request, buildSelectionWhere(request));
+    checkRevision(storyEditor, options?.expectedRevision);
+    const compiled = compilePlan(storyEditor, [step2], 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.");
@@ -165711,7 +166005,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)
@@ -165929,6 +166222,7 @@ function insertStructuredInner(editor, input, options) {
       }
     };
   } else if (ref2) {
+    checkRevision(editor, options?.expectedRevision);
     const dummyStepId = v4_default();
     const compiled = compilePlan(editor, [{
       id: dummyStepId,
@@ -165941,7 +166235,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: ref2 });
@@ -169913,8 +170207,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, normalizeActorId = (value) => {
     }
   };
 };
-var init_create_headless_toolbar_B8OXKxcw_es = __esm(() => {
-  init_SuperConverter_WQVqM0th_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();
@@ -224604,7 +224898,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-Bvhjxf8i.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) => {
@@ -248130,7 +248424,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;
@@ -296365,7 +296659,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((meta4) => !ALLOWED_META_KEYS.has(meta4));
-  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;
@@ -322713,13 +323008,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_Bvhjxf8i_es = __esm(() => {
+var init_src_PJVnllcq_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_WQVqM0th_es();
+  init_SuperConverter_DK5WIHuy_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
   init_uuid_B2wVPhPi_es();
-  init_create_headless_toolbar_B8OXKxcw_es();
+  init_create_headless_toolbar_BLN1v7eO_es();
   init_constants_D9qj59G2_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -358504,11 +358799,11 @@ function print() { __p += __j.call(arguments, '') }
   ]);
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-CCLA6uFG.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_CCLA6uFG_es = __esm(() => {
-  init_SuperConverter_WQVqM0th_es();
-  init_create_headless_toolbar_B8OXKxcw_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",
@@ -358799,16 +359094,16 @@ var init_zipper_yaJVJ4z9_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_Bvhjxf8i_es();
-  init_SuperConverter_WQVqM0th_es();
+  init_src_PJVnllcq_es();
+  init_SuperConverter_DK5WIHuy_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_B8OXKxcw_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_CCLA6uFG_es();
+  init_create_super_doc_ui_CrjXK3s__es();
   init_ui_C5PAS9hY_es();
   init_eventemitter3_BnGqBE_Q_es();
   init_errors_CNaD6vcg_es();
@@ -358928,6 +359223,81 @@ var init_errors4 = __esm(() => {
   };
 });
 
+// ../../packages/super-editor/src/editors/v1/core/super-converter/v2/importer/block-identity-renaming.js
+function toIdentityValue2(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  return;
+}
+function getBlockIdentityAttrsForType2(typeName) {
+  if (!typeName)
+    return [];
+  return BLOCK_IDENTITY_ATTRS2[typeName] ?? [];
+}
+function shouldSynthesizeParaIdForType2(typeName) {
+  return Boolean(typeName && SYNTHETIC_PARA_ID_TYPES2.has(typeName));
+}
+function getExplicitIdentityEntries2(attrs, typeName) {
+  const attrPriority = getBlockIdentityAttrsForType2(typeName);
+  if (attrPriority.length === 0)
+    return [];
+  const safeAttrs = attrs && typeof attrs === "object" ? attrs : {};
+  const identityEntries = [];
+  for (const attr of attrPriority) {
+    const value = toIdentityValue2(safeAttrs[attr]);
+    if (value) {
+      identityEntries.push({ attr, value });
+    }
+  }
+  return identityEntries;
+}
+function groupIdentityEntriesByValue2(identityEntries) {
+  const groupsByValue = new Map;
+  for (const entry of identityEntries) {
+    const existingGroup = groupsByValue.get(entry.value);
+    if (existingGroup) {
+      existingGroup.attrs.push(entry.attr);
+      continue;
+    }
+    groupsByValue.set(entry.value, { value: entry.value, attrs: [entry.attr] });
+  }
+  return [...groupsByValue.values()];
+}
+function createDeterministicDocxIdAllocator2(reservedIds) {
+  let nextValue = 1;
+  return () => {
+    while (nextValue <= MAX_DOCX_ID2) {
+      const id2 = nextValue.toString(16).toUpperCase().padStart(DOCX_ID_LENGTH2, "0");
+      nextValue += 1;
+      if (reservedIds.has(id2))
+        continue;
+      reservedIds.add(id2);
+      return id2;
+    }
+    throw new Error("Unable to allocate a unique synthetic DOCX block id.");
+  };
+}
+var PARAGRAPH_IDENTITY_ATTRS2, TABLE_IDENTITY_ATTRS2, DEFAULT_BLOCK_IDENTITY_ATTRS2, SYNTHETIC_PARA_ID_TYPES2, DOCX_ID_LENGTH2 = 8, MAX_DOCX_ID2 = 4294967295, BLOCK_IDENTITY_ATTRS2;
+var init_block_identity_renaming = __esm(() => {
+  PARAGRAPH_IDENTITY_ATTRS2 = ["sdBlockId", "paraId"];
+  TABLE_IDENTITY_ATTRS2 = ["sdBlockId", "paraId", "blockId"];
+  DEFAULT_BLOCK_IDENTITY_ATTRS2 = ["sdBlockId", "blockId", "paraId"];
+  SYNTHETIC_PARA_ID_TYPES2 = new Set(["paragraph", "tableRow"]);
+  BLOCK_IDENTITY_ATTRS2 = {
+    paragraph: PARAGRAPH_IDENTITY_ATTRS2,
+    heading: DEFAULT_BLOCK_IDENTITY_ATTRS2,
+    listItem: DEFAULT_BLOCK_IDENTITY_ATTRS2,
+    table: TABLE_IDENTITY_ATTRS2,
+    tableRow: TABLE_IDENTITY_ATTRS2,
+    tableCell: TABLE_IDENTITY_ATTRS2,
+    tableHeader: TABLE_IDENTITY_ATTRS2,
+    sdt: DEFAULT_BLOCK_IDENTITY_ATTRS2,
+    structuredContentBlock: DEFAULT_BLOCK_IDENTITY_ATTRS2
+  };
+});
+
 // ../../packages/super-editor/src/editors/v1/document-api-adapters/helpers/node-address-resolver.ts
 function isListItem3(attrs) {
   const numbering = attrs?.paragraphProperties?.numberingProperties;
@@ -359031,6 +359401,7 @@ function buildBlockIndex2(editor) {
   const byId = new Map;
   const ambiguous = new Set;
   const pathByNode = new WeakMap;
+  const explicitIdentities = new Map;
   pathByNode.set(editor.state.doc, []);
   function registerKey(key2, candidate) {
     if (byId.has(key2)) {
@@ -359040,12 +359411,44 @@ function buildBlockIndex2(editor) {
       byId.set(key2, candidate);
     }
   }
+  function recordExplicitIdentities(node2, pos) {
+    const attrPriority = getBlockIdentityAttrsForType2(node2.type?.name);
+    if (attrPriority.length === 0)
+      return;
+    const attrs = node2.attrs ?? {};
+    let nodeGroups;
+    for (const attr of attrPriority) {
+      const value = toIdentityValue2(attrs[attr]);
+      if (!value)
+        continue;
+      if (!nodeGroups)
+        nodeGroups = 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((node2, 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(node2, path2);
     }
+    recordExplicitIdentities(node2, pos);
     const nodeType = mapBlockNodeType2(node2);
     if (!nodeType)
       return;
@@ -359066,7 +359469,7 @@ function buildBlockIndex2(editor) {
       registerKey(`${nodeType}:${aliasId}`, candidate);
     }
   });
-  return { candidates, byId, ambiguous };
+  return { candidates, byId, ambiguous, explicitIdentities };
 }
 function findBlockById2(index2, address) {
   if (address.kind !== "block")
@@ -359151,6 +359554,7 @@ var SUPPORTED_BLOCK_NODE_TYPES, ALIAS_ELIGIBLE_TYPES2;
 var init_node_address_resolver = __esm(() => {
   init_deterministic_node_id();
   init_errors4();
+  init_block_identity_renaming();
   SUPPORTED_BLOCK_NODE_TYPES = new Set([
     "paragraph",
     "heading",
@@ -391965,9 +392369,11 @@ function trackRevisions2(editor) {
     return;
   subscribedEditors2.add(editor);
   editor.on("transaction", ({ transaction }) => {
-    if (transaction.docChanged) {
-      incrementRevision2(editor);
-    }
+    if (transaction.getMeta?.("superdoc/block-identity-repair"))
+      return;
+    if (!transaction.docChanged)
+      return;
+    incrementRevision2(editor);
   });
 }
 function checkRevision2(editor, expectedRevision) {
@@ -405287,6 +405693,8 @@ function resolveStoryRuntime2(hostEditor, locator, options = {}) {
   if (store && !hasHostStoreSyncListener2(runtime.editor, storyKey)) {
     markHostStoreSyncListener2(runtime.editor, storyKey);
     runtime.editor.on("transaction", ({ transaction }) => {
+      if (transaction.getMeta?.("superdoc/block-identity-repair"))
+        return;
       if (transaction.docChanged) {
         incrementStoryRevision2(store, storyKey);
       }
@@ -457234,54 +457642,10 @@ var init_math3 = __esm(() => {
 });
 
 // ../../packages/super-editor/src/editors/v1/core/super-converter/v2/importer/normalizeDuplicateBlockIdentitiesInContent.js
-function toIdentityValue2(value) {
-  if (typeof value === "string" && value.length > 0)
-    return value;
-  if (typeof value === "number" && Number.isFinite(value))
-    return String(value);
-  return;
-}
-function getBlockIdentityAttrs2(node4) {
-  if (!node4 || typeof node4 !== "object")
-    return [];
-  return BLOCK_IDENTITY_ATTRS2[node4.type] ?? [];
-}
-function getExplicitIdentityEntries2(node4) {
-  const attrPriority = getBlockIdentityAttrs2(node4);
-  if (attrPriority.length === 0)
-    return [];
-  const attrs = typeof node4.attrs === "object" && node4.attrs ? node4.attrs : {};
-  const identityEntries = [];
-  for (const attr of attrPriority) {
-    const value = toIdentityValue2(attrs[attr]);
-    if (value) {
-      identityEntries.push({ attr, value });
-    }
-  }
-  return identityEntries;
-}
-function groupIdentityEntriesByValue2(identityEntries) {
-  const groupsByValue = new Map;
-  for (const entry of identityEntries) {
-    const existingGroup = groupsByValue.get(entry.value);
-    if (existingGroup) {
-      existingGroup.attrs.push(entry.attr);
-      continue;
-    }
-    groupsByValue.set(entry.value, {
-      value: entry.value,
-      attrs: [entry.attr]
-    });
-  }
-  return [...groupsByValue.values()];
-}
-function shouldSynthesizeParaId2(node4) {
-  return Boolean(node4 && typeof node4 === "object" && SYNTHETIC_PARA_ID_TYPES2.has(node4.type));
-}
 function collectExplicitBlockIdentities2(node4, reservedIds) {
   if (!node4 || typeof node4 !== "object")
     return;
-  const identityEntries = getExplicitIdentityEntries2(node4);
+  const identityEntries = getExplicitIdentityEntries2(node4.attrs, node4?.type);
   for (const { value } of groupIdentityEntriesByValue2(identityEntries)) {
     reservedIds.add(value);
   }
@@ -457289,27 +457653,13 @@ function collectExplicitBlockIdentities2(node4, reservedIds) {
     node4.content.forEach((child) => collectExplicitBlockIdentities2(child, reservedIds));
   }
 }
-function createDeterministicDocxIdAllocator2(reservedIds) {
-  let nextValue = 1;
-  return () => {
-    while (nextValue <= MAX_DOCX_ID2) {
-      const id2 = nextValue.toString(16).toUpperCase().padStart(DOCX_ID_LENGTH2, "0");
-      nextValue += 1;
-      if (reservedIds.has(id2))
-        continue;
-      reservedIds.add(id2);
-      return id2;
-    }
-    throw new Error("Unable to allocate a unique synthetic DOCX block id.");
-  };
-}
 function setBlockIdentity2(node4, attrName, value) {
   node4.attrs = { ...node4.attrs ?? {}, [attrName]: value };
 }
 function normalizeBlockIdentitiesInNode2(node4, seenIds, allocateDocxId) {
   if (!node4 || typeof node4 !== "object")
     return;
-  const identityEntries = getExplicitIdentityEntries2(node4);
+  const identityEntries = getExplicitIdentityEntries2(node4.attrs, node4?.type);
   const groupedIdentities = groupIdentityEntriesByValue2(identityEntries);
   if (groupedIdentities.length > 0) {
     for (const identityGroup of groupedIdentities) {
@@ -457323,7 +457673,7 @@ function normalizeBlockIdentitiesInNode2(node4, seenIds, allocateDocxId) {
         seenIds.add(identityGroup.value);
       }
     }
-  } else if (shouldSynthesizeParaId2(node4)) {
+  } else if (shouldSynthesizeParaIdForType2(node4?.type)) {
     const syntheticParaId = allocateDocxId();
     setBlockIdentity2(node4, "paraId", syntheticParaId);
     seenIds.add(syntheticParaId);
@@ -457342,23 +457692,8 @@ function normalizeDuplicateBlockIdentitiesInContent2(content4 = []) {
   content4.forEach((node4) => normalizeBlockIdentitiesInNode2(node4, seenIds, allocateDocxId));
   return content4;
 }
-var PARAGRAPH_IDENTITY_ATTRS2, TABLE_IDENTITY_ATTRS2, DEFAULT_BLOCK_IDENTITY_ATTRS2, SYNTHETIC_PARA_ID_TYPES2, DOCX_ID_LENGTH2 = 8, MAX_DOCX_ID2 = 4294967295, BLOCK_IDENTITY_ATTRS2;
 var init_normalizeDuplicateBlockIdentitiesInContent = __esm(() => {
-  PARAGRAPH_IDENTITY_ATTRS2 = ["sdBlockId", "paraId"];
-  TABLE_IDENTITY_ATTRS2 = ["sdBlockId", "paraId", "blockId"];
-  DEFAULT_BLOCK_IDENTITY_ATTRS2 = ["sdBlockId", "blockId", "paraId"];
-  SYNTHETIC_PARA_ID_TYPES2 = new Set(["paragraph", "tableRow"]);
-  BLOCK_IDENTITY_ATTRS2 = {
-    paragraph: PARAGRAPH_IDENTITY_ATTRS2,
-    heading: DEFAULT_BLOCK_IDENTITY_ATTRS2,
-    listItem: DEFAULT_BLOCK_IDENTITY_ATTRS2,
-    table: TABLE_IDENTITY_ATTRS2,
-    tableRow: TABLE_IDENTITY_ATTRS2,
-    tableCell: TABLE_IDENTITY_ATTRS2,
-    tableHeader: TABLE_IDENTITY_ATTRS2,
-    sdt: DEFAULT_BLOCK_IDENTITY_ATTRS2,
-    structuredContentBlock: DEFAULT_BLOCK_IDENTITY_ATTRS2
-  };
+  init_block_identity_renaming();
 });
 
 // ../../packages/super-editor/src/editors/v1/core/super-converter/v3/handlers/w/styles/index.js
@@ -471936,6 +472271,168 @@ var init_executor_registry = __esm(() => {
   registry3 = new Map;
 });
 
+// ../../packages/super-editor/src/editors/v1/document-api-adapters/plan-engine/repair-block-identities.ts
+function planRepairs2(doc6, identityMap) {
+  if (identityMap) {
+    return planRepairsFromIdentityMap2(identityMap);
+  }
+  return planRepairsByWalk2(doc6);
+}
+function planRepairsFromIdentityMap2(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 i5 = 1;i5 < observations.length; i5 += 1) {
+      const { pos, attrs } = observations[i5];
+      rewrites.push({ pos, value, attrs });
+    }
+  }
+  rewrites.sort((a2, b2) => a2.pos - b2.pos);
+  const reservedIds = new Set(identityMap.keys());
+  const allocateDocxId = createDeterministicDocxIdAllocator2(reservedIds);
+  const plansByPos = 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((a2, b2) => a2.pos - b2.pos);
+  return {
+    plans,
+    report: { repairedBlockCount: plans.length, duplicateBlockIds, renames }
+  };
+}
+function planRepairsByWalk2(doc6) {
+  const reservedIds = new Set;
+  let hasDuplicates = false;
+  doc6.descendants((node4) => {
+    const entries = getExplicitIdentityEntries2(node4.attrs, node4.type?.name);
+    for (const { value } of groupIdentityEntriesByValue2(entries)) {
+      if (reservedIds.has(value)) {
+        hasDuplicates = true;
+      } else {
+        reservedIds.add(value);
+      }
+    }
+  });
+  if (!hasDuplicates) {
+    return { plans: [], report: { repairedBlockCount: 0, duplicateBlockIds: [], renames: [] } };
+  }
+  const allocateDocxId = createDeterministicDocxIdAllocator2(reservedIds);
+  const seenIds = new Set;
+  const plans = [];
+  const duplicateBlockIds = [];
+  const renames = [];
+  doc6.descendants((node4, pos) => {
+    const entries = getExplicitIdentityEntries2(node4.attrs, node4.type?.name);
+    const groups = groupIdentityEntriesByValue2(entries);
+    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 repairDuplicateBlockIdentities2(editor) {
+  const doc6 = editor.state?.doc;
+  if (!doc6 || typeof doc6.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 = getBlockIndex2(editor).explicitIdentities;
+  } catch {
+    identityMap = undefined;
+  }
+  const { plans, report } = planRepairs2(doc6, 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 node4 = editor.state.doc.nodeAt(plan.pos);
+    if (!node4) {
+      blockedNodeIds.push(`pos:${plan.pos}`);
+      continue;
+    }
+    for (const group of plan.rewrittenGroups) {
+      for (const attr of group.attrs) {
+        if (node4.attrs?.[attr] !== group.replacementValue) {
+          const observedId = typeof node4.attrs?.id === "string" && node4.attrs.id || typeof node4.attrs?.sdBlockId === "string" && node4.attrs.sdBlockId || `pos:${plan.pos}`;
+          blockedNodeIds.push(observedId);
+        }
+      }
+    }
+  }
+  if (blockedNodeIds.length > 0) {
+    const unique2 = [...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 = unique2.slice(0, 4).map(truncate).join(", ");
+    const previewSuffix = unique2.length > 4 ? `, +${unique2.length - 4} more` : "";
+    throw planError2("REPAIR_BLOCKED", `Runtime identity repair was rejected by a transaction filter ` + `(${unique2.length} node${unique2.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: unique2,
+      remediation: "Re-import the document via doc.open to assign unique identities."
+    });
+  }
+  return report;
+}
+var init_repair_block_identities = __esm(() => {
+  init_block_identity_renaming();
+  init_index_cache();
+  init_errors6();
+});
+
 // ../../packages/super-editor/src/editors/v1/document-api-adapters/helpers/selection-target-resolver.ts
 function resolveTextPoint3(editor, index3, point7) {
   const candidate = findTextBlockByNodeId2(index3, point7.blockId);
@@ -472899,10 +473396,12 @@ function assertNoDuplicateBlockIds2(index3) {
       duplicates.push(candidate.nodeId);
   }
   if (duplicates.length > 0) {
-    throw planError2("DOCUMENT_IDENTITY_CONFLICT", "Document contains blocks with duplicate identities. This must be resolved before mutations can be applied.", undefined, {
+    const preview = duplicates.slice(0, 4).join(", ");
+    const previewSuffix = duplicates.length > 4 ? `, +${duplicates.length - 4} more` : "";
+    throw planError2("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."
     });
   }
 }
@@ -472933,12 +473432,76 @@ function assertSingleStoryKey2(steps) {
     }
   }
 }
+function collectReferencedBlockIds2(step3) {
+  const where = step3.where;
+  const ids = [];
+  const withinNodeId = where.within?.nodeId;
+  if (withinNodeId)
+    ids.push(withinNodeId);
+  if (isRefWhere2(where)) {
+    const ref4 = where.ref;
+    if (ref4.startsWith("text:")) {
+      const decoded = decodeRef2(ref4);
+      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(ref4);
+    }
+    return ids;
+  }
+  if (isBlockWhere2(where)) {
+    ids.push(where.nodeId);
+    return ids;
+  }
+  if (isTargetWhere2(where)) {
+    for (const point7 of [where.target?.start, where.target?.end]) {
+      const blockId = point7?.blockId;
+      if (blockId)
+        ids.push(blockId);
+      const edgeNodeId = point7?.node?.nodeId;
+      if (edgeNodeId)
+        ids.push(edgeNodeId);
+    }
+  }
+  return ids;
+}
+function assertNoStaleRefsAfterRepair2(steps, repairedIds) {
+  if (repairedIds.size === 0)
+    return;
+  for (const step3 of steps) {
+    for (const blockId of collectReferencedBlockIds2(step3)) {
+      if (!repairedIds.has(blockId))
+        continue;
+      throw planError2("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 compilePlan2(editor, steps, options = {}) {
   if (steps.length > MAX_PLAN_STEPS2) {
     throw planError2("INVALID_INPUT", `plan contains ${steps.length} steps, maximum is ${MAX_PLAN_STEPS2}`);
   }
+  let index3 = getBlockIndex2(editor);
+  if (!options.skipIdentityRepair) {
+    const repair = repairDuplicateBlockIdentities2(editor);
+    if (repair) {
+      clearIndexCache2(editor);
+      index3 = getBlockIndex2(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` : ""}.`);
+      assertNoStaleRefsAfterRepair2(steps, new Set(repair.duplicateBlockIds));
+    }
+  }
   const compiledRevision = getRevision2(editor);
-  const index3 = getBlockIndex2(editor);
   assertNoDuplicateBlockIds2(index3);
   const mutationSteps = [];
   const assertSteps = [];
@@ -472994,6 +473557,7 @@ var init_compiler = __esm(() => {
   init_style_resolver();
   init_index_cache();
   init_revision_tracker();
+  init_repair_block_identities();
   init_text_strategy();
   init_block_strategy();
   init_node_address_resolver();
@@ -475201,6 +475765,7 @@ function executePlan2(editor, input2) {
   if (!input2.steps?.length) {
     throw planError2("INVALID_INPUT", "plan must contain at least one step");
   }
+  checkRevision2(editor, input2.expectedRevision);
   const compiled = compilePlan2(editor, input2.steps, {
     selectTextModel: input2.changeMode === "tracked" ? "raw" : "visible"
   });
@@ -476706,7 +477271,8 @@ function selectionMutationWrapper2(editor, request, options) {
     const stepId = v4_default2();
     const where = buildSelectionWhere2(request);
     const step3 = buildSelectionStepDef2(stepId, request, where);
-    const compiled = compilePlan2(storyEditor, [step3]);
+    checkRevision2(storyEditor, options?.expectedRevision);
+    const compiled = compilePlan2(storyEditor, [step3], options?.dryRun ? { skipIdentityRepair: true } : undefined);
     if (request.kind === "insert" && request.target) {
       const hasNodeEdge = request.target.start.kind === "nodeEdge" || request.target.end.kind === "nodeEdge";
       if (hasNodeEdge) {
@@ -476741,7 +477307,6 @@ function selectionMutationWrapper2(editor, request, options) {
         }
       }
     }
-    checkRevision2(storyEditor, options?.expectedRevision);
     if (options?.dryRun) {
       const resolution2 = buildSelectionResolutionFromCompiled2(compiled, stepId);
       if (request.kind === "insert" && !request.text) {
@@ -476904,6 +477469,7 @@ function insertStructuredInner2(editor, input2, options) {
     }
     effectiveTarget = { kind: "text", blockId, range: { start: offset2, end: offset2 } };
   } else if (ref4) {
+    checkRevision2(editor, options?.expectedRevision);
     const dummyStepId = v4_default2();
     const dummyStep = {
       id: dummyStepId,
@@ -476911,7 +477477,7 @@ function insertStructuredInner2(editor, input2, options) {
       where: { by: "ref", ref: ref4 },
       args: { position: "before", content: { text: "" } }
     };
-    const compiled = compilePlan2(editor, [dummyStep]);
+    const compiled = compilePlan2(editor, [dummyStep], options?.dryRun ? { skipIdentityRepair: true } : undefined);
     const compiledStep = compiled.mutationSteps.find((s2) => s2.step.id === dummyStepId);
     const compiledTarget = compiledStep?.targets[0];
     if (!compiledTarget) {
@@ -490619,7 +491185,7 @@ function previewPlan2(editor, input2) {
   let currentPhase = "compile";
   let evaluatedRevision = getRevision2(editor);
   try {
-    const compiled = compilePlan2(editor, input2.steps);
+    const compiled = compilePlan2(editor, input2.steps, { skipIdentityRepair: true });
     evaluatedRevision = compiled.compiledRevision;
     currentPhase = "execute";
     const tr = editor.state.tr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/mcp",
-  "version": "0.12.0-next.26",
+  "version": "0.12.0-next.28",
   "type": "module",
   "engines": {
     "node": ">=20"
@@ -20,8 +20,8 @@
     "@types/node": "22.19.2",
     "typescript": "^5.9.2",
     "@superdoc/document-api": "0.0.1",
-    "@superdoc/super-editor": "0.0.1",
-    "superdoc": "1.39.0"
+    "superdoc": "1.39.0",
+    "@superdoc/super-editor": "0.0.1"
   },
   "publishConfig": {
     "access": "public"