@superdoc-dev/cli 0.17.0-next.26 → 0.17.0-next.28

package/dist/index.js

@@ -68327,7 +68327,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")
@@ -90614,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) {
@@ -100551,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,
@@ -100587,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 () => {
@@ -100613,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 ?? {},
@@ -100622,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)) {
@@ -100632,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);
@@ -108250,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)) {
@@ -108258,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;
@@ -108285,7 +108322,8 @@ function buildBlockIndex(editor) {
   return {
     candidates,
     byId,
-    ambiguous
+    ambiguous,
+    explicitIdentities
   };
 }
 function findBlockById(index2, address2) {
@@ -111870,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);
     });
@@ -134929,7 +134969,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();
@@ -175673,7 +175713,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 length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -177156,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);
@@ -178360,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;
@@ -178393,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 = [];
@@ -180490,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
@@ -181836,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.");
@@ -181866,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)
@@ -182084,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,
@@ -182096,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 });
@@ -186068,8 +186362,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();
@@ -235238,7 +235532,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) => {
@@ -258897,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;
@@ -307132,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;
@@ -333480,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_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();
@@ -369271,11 +369566,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",
@@ -369566,16 +369861,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/cli",
-  "version": "0.17.0-next.26",
+  "version": "0.17.0-next.28",
   "type": "module",
   "bin": {
     "superdoc": "./dist/index.js"
@@ -24,20 +24,20 @@
     "@types/node": "22.19.2",
     "@types/ws": "^8.5.13",
     "typescript": "^5.9.2",
-    "@superdoc/document-api": "0.0.1",
+    "@superdoc/super-editor": "0.0.1",
     "superdoc": "1.39.0",
-    "@superdoc/super-editor": "0.0.1"
+    "@superdoc/document-api": "0.0.1"
   },
   "module": "src/index.ts",
   "publishConfig": {
     "access": "public"
   },
   "optionalDependencies": {
-    "@superdoc-dev/cli-darwin-arm64": "0.17.0-next.26",
-    "@superdoc-dev/cli-darwin-x64": "0.17.0-next.26",
-    "@superdoc-dev/cli-linux-x64": "0.17.0-next.26",
-    "@superdoc-dev/cli-linux-arm64": "0.17.0-next.26",
-    "@superdoc-dev/cli-windows-x64": "0.17.0-next.26"
+    "@superdoc-dev/cli-darwin-x64": "0.17.0-next.28",
+    "@superdoc-dev/cli-darwin-arm64": "0.17.0-next.28",
+    "@superdoc-dev/cli-linux-x64": "0.17.0-next.28",
+    "@superdoc-dev/cli-windows-x64": "0.17.0-next.28",
+    "@superdoc-dev/cli-linux-arm64": "0.17.0-next.28"
   },
   "scripts": {
     "predev": "node scripts/ensure-superdoc-build.js",