@superdoc-dev/cli 1.0.2 → 1.0.3

package/dist/index.js

@@ -502,7 +502,7 @@ function mutationOperation(options) {
 function projectFromDefinitions(fn) {
   return Object.fromEntries(OPERATION_IDS.map((id) => [id, fn(id, OPERATION_DEFINITIONS[id])]));
 }
-var NONE_FAILURES, NONE_THROWS, T_NOT_FOUND, T_COMMAND, T_NOT_FOUND_COMMAND, T_NOT_FOUND_TRACKED, T_NOT_FOUND_COMMAND_TRACKED, OPERATION_DEFINITIONS, OPERATION_IDS, SINGLETON_OPERATION_IDS, NAMESPACED_OPERATION_IDS;
+var NONE_FAILURES, NONE_THROWS, T_NOT_FOUND, T_COMMAND, T_NOT_FOUND_COMMAND, T_NOT_FOUND_TRACKED, T_NOT_FOUND_COMMAND_TRACKED, T_PLAN_ENGINE, T_QUERY_MATCH, OPERATION_DEFINITIONS, OPERATION_IDS, SINGLETON_OPERATION_IDS, NAMESPACED_OPERATION_IDS;
 var init_operation_definitions = __esm(() => {
   NONE_FAILURES = [];
   NONE_THROWS = [];
@@ -516,6 +516,19 @@ var init_operation_definitions = __esm(() => {
     "TRACK_CHANGE_COMMAND_UNAVAILABLE",
     "CAPABILITY_UNAVAILABLE"
   ];
+  T_PLAN_ENGINE = [
+    "REVISION_MISMATCH",
+    "MATCH_NOT_FOUND",
+    "AMBIGUOUS_MATCH",
+    "STYLE_CONFLICT",
+    "PRECONDITION_FAILED",
+    "INVALID_INPUT",
+    "CROSS_BLOCK_MATCH",
+    "PLAN_CONFLICT_OVERLAP",
+    "INVALID_STEP_COMBINATION",
+    "CAPABILITY_UNAVAILABLE"
+  ];
+  T_QUERY_MATCH = ["MATCH_NOT_FOUND", "AMBIGUOUS_MATCH", "INVALID_INPUT"];
   OPERATION_DEFINITIONS = {
     find: {
       memberPath: "find",
@@ -1019,6 +1032,45 @@ var init_operation_definitions = __esm(() => {
       referenceDocPath: "track-changes/reject-all.mdx",
       referenceGroup: "trackChanges"
     },
+    "query.match": {
+      memberPath: "query.match",
+      description: "Deterministic selector-based search with cardinality contracts for mutation targeting.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: T_QUERY_MATCH,
+        deterministicTargetResolution: true
+      }),
+      referenceDocPath: "query/match.mdx",
+      referenceGroup: "query"
+    },
+    "mutations.preview": {
+      memberPath: "mutations.preview",
+      description: "Dry-run a mutation plan, returning resolved targets without applying changes.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: T_PLAN_ENGINE,
+        deterministicTargetResolution: true
+      }),
+      referenceDocPath: "mutations/preview.mdx",
+      referenceGroup: "mutations"
+    },
+    "mutations.apply": {
+      memberPath: "mutations.apply",
+      description: "Execute a mutation plan atomically against the document.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "non-idempotent",
+        supportsDryRun: false,
+        supportsTrackedMode: true,
+        possibleFailureCodes: NONE_FAILURES,
+        throws: T_PLAN_ENGINE,
+        deterministicTargetResolution: true
+      }),
+      referenceDocPath: "mutations/apply.mdx",
+      referenceGroup: "mutations"
+    },
     "capabilities.get": {
       memberPath: "capabilities",
       description: "Query runtime capabilities supported by the current document engine.",
@@ -1858,6 +1910,71 @@ var init_schemas = __esm(() => {
       success: receiptSuccessSchema,
       failure: receiptFailureResultSchemaFor("trackChanges.rejectAll")
     },
+    "query.match": {
+      input: objectSchema({
+        select: { oneOf: [textSelectorSchema, nodeSelectorSchema] },
+        within: nodeAddressSchema,
+        require: { enum: ["any", "first", "exactlyOne", "all"] },
+        includeNodes: { type: "boolean" },
+        includeStyle: { type: "boolean" },
+        limit: { type: "integer", minimum: 1 },
+        offset: { type: "integer", minimum: 0 }
+      }, ["select"]),
+      output: objectSchema({
+        evaluatedRevision: { type: "string" },
+        matches: arraySchema(objectSchema({
+          address: nodeAddressSchema,
+          textRanges: arraySchema(textAddressSchema),
+          ref: { type: "string" },
+          refStability: { enum: ["ephemeral", "stable"] },
+          style: objectSchema({
+            marks: objectSchema({
+              bold: { type: "boolean" },
+              italic: { type: "boolean" },
+              underline: { type: "boolean" },
+              strike: { type: "boolean" }
+            }),
+            isUniform: { type: "boolean" }
+          }, ["marks", "isUniform"])
+        })),
+        totalMatches: { type: "integer", minimum: 0 }
+      }, ["evaluatedRevision", "matches", "totalMatches"])
+    },
+    "mutations.preview": {
+      input: objectSchema({
+        expectedRevision: { type: "string" },
+        atomic: { const: true },
+        changeMode: { enum: ["direct", "tracked"] },
+        steps: arraySchema({ type: "object" })
+      }, ["expectedRevision", "atomic", "changeMode", "steps"]),
+      output: objectSchema({
+        evaluatedRevision: { type: "string" },
+        steps: arraySchema({ type: "object" }),
+        valid: { type: "boolean" },
+        failures: arraySchema({ type: "object" })
+      }, ["evaluatedRevision", "steps", "valid"])
+    },
+    "mutations.apply": {
+      input: objectSchema({
+        expectedRevision: { type: "string" },
+        atomic: { const: true },
+        changeMode: { enum: ["direct", "tracked"] },
+        steps: arraySchema({ type: "object" })
+      }, ["expectedRevision", "atomic", "changeMode", "steps"]),
+      output: objectSchema({
+        success: { const: true },
+        revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
+        steps: arraySchema({ type: "object" }),
+        trackedChanges: arraySchema({ type: "object" }),
+        timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
+      }, ["success", "revision", "steps", "timing"]),
+      success: objectSchema({
+        success: { const: true },
+        revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
+        steps: arraySchema({ type: "object" }),
+        timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
+      }, ["success", "revision", "steps", "timing"])
+    },
     "capabilities.get": {
       input: strictEmptyObjectSchema,
       output: capabilitiesOutputSchema
@@ -1915,6 +2032,16 @@ var init_reference_doc_map = __esm(() => {
       title: "Track Changes",
       description: "Tracked-change inspection and review operations.",
       pagePath: "track-changes/index.mdx"
+    },
+    query: {
+      title: "Query",
+      description: "Deterministic selector-based queries for mutation targeting.",
+      pagePath: "query/index.mdx"
+    },
+    mutations: {
+      title: "Mutations",
+      description: "Atomic mutation plan preview and execution.",
+      pagePath: "mutations/index.mdx"
     }
   };
   REFERENCE_OPERATION_GROUPS = Object.keys(GROUP_METADATA).map((key) => ({
@@ -2142,33 +2269,33 @@ function normalizeCommentTarget(input) {
   const { blockId: _b, start: _s, end: _e, ...rest } = input;
   return { ...rest, target };
 }
-function executeAddComment(adapter, input) {
+function executeAddComment(adapter, input, options) {
   validateAddCommentInput(input);
   const normalized = normalizeCommentTarget(input);
-  return adapter.add(normalized);
+  return adapter.add(normalized, options);
 }
-function executeEditComment(adapter, input) {
-  return adapter.edit(input);
+function executeEditComment(adapter, input, options) {
+  return adapter.edit(input, options);
 }
-function executeReplyToComment(adapter, input) {
-  return adapter.reply(input);
+function executeReplyToComment(adapter, input, options) {
+  return adapter.reply(input, options);
 }
-function executeMoveComment(adapter, input) {
+function executeMoveComment(adapter, input, options) {
   validateMoveCommentInput(input);
   const normalized = normalizeCommentTarget(input);
-  return adapter.move(normalized);
+  return adapter.move(normalized, options);
 }
-function executeResolveComment(adapter, input) {
-  return adapter.resolve(input);
+function executeResolveComment(adapter, input, options) {
+  return adapter.resolve(input, options);
 }
-function executeRemoveComment(adapter, input) {
-  return adapter.remove(input);
+function executeRemoveComment(adapter, input, options) {
+  return adapter.remove(input, options);
 }
-function executeSetCommentInternal(adapter, input) {
-  return adapter.setInternal(input);
+function executeSetCommentInternal(adapter, input, options) {
+  return adapter.setInternal(input, options);
 }
-function executeSetCommentActive(adapter, input) {
-  return adapter.setActive(input);
+function executeSetCommentActive(adapter, input, options) {
+  return adapter.setActive(input, options);
 }
 function executeGoToComment(adapter, input) {
   return adapter.goTo(input);
@@ -2232,6 +2359,7 @@ function executeFind(adapter, selectorOrQuery, options) {
 // ../../packages/document-api/src/write/write.ts
 function normalizeMutationOptions(options) {
   return {
+    expectedRevision: options?.expectedRevision,
     changeMode: options?.changeMode ?? "direct",
     dryRun: options?.dryRun ?? false
   };
@@ -2676,17 +2804,17 @@ function executeTrackChangesList(adapter, input) {
 function executeTrackChangesGet(adapter, input) {
   return adapter.get(input);
 }
-function executeTrackChangesAccept(adapter, input) {
-  return adapter.accept(input);
+function executeTrackChangesAccept(adapter, input, options) {
+  return adapter.accept(input, options);
 }
-function executeTrackChangesReject(adapter, input) {
-  return adapter.reject(input);
+function executeTrackChangesReject(adapter, input, options) {
+  return adapter.reject(input, options);
 }
-function executeTrackChangesAcceptAll(adapter, input) {
-  return adapter.acceptAll(input);
+function executeTrackChangesAcceptAll(adapter, input, options) {
+  return adapter.acceptAll(input, options);
 }
-function executeTrackChangesRejectAll(adapter, input) {
-  return adapter.rejectAll(input);
+function executeTrackChangesRejectAll(adapter, input, options) {
+  return adapter.rejectAll(input, options);
 }
 
 // ../../packages/document-api/src/invoke/invoke.ts
@@ -2714,23 +2842,26 @@ function buildDispatchTable(api) {
     "lists.outdent": (input, options) => api.lists.outdent(input, options),
     "lists.restart": (input, options) => api.lists.restart(input, options),
     "lists.exit": (input, options) => api.lists.exit(input, options),
-    "comments.add": (input) => api.comments.add(input),
-    "comments.edit": (input) => api.comments.edit(input),
-    "comments.reply": (input) => api.comments.reply(input),
-    "comments.move": (input) => api.comments.move(input),
-    "comments.resolve": (input) => api.comments.resolve(input),
-    "comments.remove": (input) => api.comments.remove(input),
-    "comments.setInternal": (input) => api.comments.setInternal(input),
-    "comments.setActive": (input) => api.comments.setActive(input),
+    "comments.add": (input, options) => api.comments.add(input, options),
+    "comments.edit": (input, options) => api.comments.edit(input, options),
+    "comments.reply": (input, options) => api.comments.reply(input, options),
+    "comments.move": (input, options) => api.comments.move(input, options),
+    "comments.resolve": (input, options) => api.comments.resolve(input, options),
+    "comments.remove": (input, options) => api.comments.remove(input, options),
+    "comments.setInternal": (input, options) => api.comments.setInternal(input, options),
+    "comments.setActive": (input, options) => api.comments.setActive(input, options),
     "comments.goTo": (input) => api.comments.goTo(input),
     "comments.get": (input) => api.comments.get(input),
     "comments.list": (input) => api.comments.list(input),
     "trackChanges.list": (input) => api.trackChanges.list(input),
     "trackChanges.get": (input) => api.trackChanges.get(input),
-    "trackChanges.accept": (input) => api.trackChanges.accept(input),
-    "trackChanges.reject": (input) => api.trackChanges.reject(input),
-    "trackChanges.acceptAll": (input) => api.trackChanges.acceptAll(input),
-    "trackChanges.rejectAll": (input) => api.trackChanges.rejectAll(input),
+    "trackChanges.accept": (input, options) => api.trackChanges.accept(input, options),
+    "trackChanges.reject": (input, options) => api.trackChanges.reject(input, options),
+    "trackChanges.acceptAll": (input, options) => api.trackChanges.acceptAll(input, options),
+    "trackChanges.rejectAll": (input, options) => api.trackChanges.rejectAll(input, options),
+    "query.match": (input) => api.query.match(input),
+    "mutations.preview": (input) => api.mutations.preview(input),
+    "mutations.apply": (input) => api.mutations.apply(input),
     "capabilities.get": () => api.capabilities()
   };
 }
@@ -2763,29 +2894,29 @@ function createDocumentApi(adapters) {
       return executeInfo(adapters.info, input);
     },
     comments: {
-      add(input) {
-        return executeAddComment(adapters.comments, input);
+      add(input, options) {
+        return executeAddComment(adapters.comments, input, options);
       },
-      edit(input) {
-        return executeEditComment(adapters.comments, input);
+      edit(input, options) {
+        return executeEditComment(adapters.comments, input, options);
       },
-      reply(input) {
-        return executeReplyToComment(adapters.comments, input);
+      reply(input, options) {
+        return executeReplyToComment(adapters.comments, input, options);
       },
-      move(input) {
-        return executeMoveComment(adapters.comments, input);
+      move(input, options) {
+        return executeMoveComment(adapters.comments, input, options);
       },
-      resolve(input) {
-        return executeResolveComment(adapters.comments, input);
+      resolve(input, options) {
+        return executeResolveComment(adapters.comments, input, options);
       },
-      remove(input) {
-        return executeRemoveComment(adapters.comments, input);
+      remove(input, options) {
+        return executeRemoveComment(adapters.comments, input, options);
       },
-      setInternal(input) {
-        return executeSetCommentInternal(adapters.comments, input);
+      setInternal(input, options) {
+        return executeSetCommentInternal(adapters.comments, input, options);
       },
-      setActive(input) {
-        return executeSetCommentActive(adapters.comments, input);
+      setActive(input, options) {
+        return executeSetCommentActive(adapters.comments, input, options);
       },
       goTo(input) {
         return executeGoToComment(adapters.comments, input);
@@ -2827,17 +2958,17 @@ function createDocumentApi(adapters) {
       get(input) {
         return executeTrackChangesGet(adapters.trackChanges, input);
       },
-      accept(input) {
-        return executeTrackChangesAccept(adapters.trackChanges, input);
+      accept(input, options) {
+        return executeTrackChangesAccept(adapters.trackChanges, input, options);
       },
-      reject(input) {
-        return executeTrackChangesReject(adapters.trackChanges, input);
+      reject(input, options) {
+        return executeTrackChangesReject(adapters.trackChanges, input, options);
       },
-      acceptAll(input) {
-        return executeTrackChangesAcceptAll(adapters.trackChanges, input);
+      acceptAll(input, options) {
+        return executeTrackChangesAcceptAll(adapters.trackChanges, input, options);
       },
-      rejectAll(input) {
-        return executeTrackChangesRejectAll(adapters.trackChanges, input);
+      rejectAll(input, options) {
+        return executeTrackChangesRejectAll(adapters.trackChanges, input, options);
       }
     },
     create: {
@@ -2848,6 +2979,19 @@ function createDocumentApi(adapters) {
         return executeCreateHeading(adapters.create, input, options);
       }
     },
+    query: {
+      match(input) {
+        return adapters.query.match(input);
+      }
+    },
+    mutations: {
+      preview(input) {
+        return adapters.mutations.preview(input);
+      },
+      apply(input) {
+        return adapters.mutations.apply(input);
+      }
+    },
     capabilities: capabilities2,
     lists: {
       list(query2) {
@@ -3521,6 +3665,7 @@ var init_operation_hints = __esm(() => {
     find: "completed search",
     getNode: "resolved node",
     getNodeById: "resolved node",
+    getText: "extracted text",
     info: "retrieved info",
     insert: "inserted text",
     replace: "replaced text",
@@ -3530,6 +3675,7 @@ var init_operation_hints = __esm(() => {
     "format.underline": "applied underline",
     "format.strikethrough": "applied strikethrough",
     "create.paragraph": "created paragraph",
+    "create.heading": "created heading",
     "lists.list": "listed items",
     "lists.get": "resolved list item",
     "lists.insert": "inserted list item",
@@ -3554,12 +3700,14 @@ var init_operation_hints = __esm(() => {
     "trackChanges.accept": "accepted tracked change",
     "trackChanges.reject": "rejected tracked change",
     "trackChanges.acceptAll": "accepted all tracked changes",
-    "trackChanges.rejectAll": "rejected all tracked changes"
+    "trackChanges.rejectAll": "rejected all tracked changes",
+    "capabilities.get": "retrieved capabilities"
   };
   OUTPUT_FORMAT = {
     find: "queryResult",
     getNode: "nodeInfo",
     getNodeById: "nodeInfo",
+    getText: "plain",
     info: "documentInfo",
     insert: "mutationReceipt",
     replace: "mutationReceipt",
@@ -3569,6 +3717,7 @@ var init_operation_hints = __esm(() => {
     "format.underline": "mutationReceipt",
     "format.strikethrough": "mutationReceipt",
     "create.paragraph": "createResult",
+    "create.heading": "createResult",
     "lists.list": "listResult",
     "lists.get": "listItemInfo",
     "lists.insert": "listsMutationResult",
@@ -3593,12 +3742,14 @@ var init_operation_hints = __esm(() => {
     "trackChanges.accept": "trackChangeMutationReceipt",
     "trackChanges.reject": "trackChangeMutationReceipt",
     "trackChanges.acceptAll": "trackChangeMutationReceipt",
-    "trackChanges.rejectAll": "trackChangeMutationReceipt"
+    "trackChanges.rejectAll": "trackChangeMutationReceipt",
+    "capabilities.get": "plain"
   };
   RESPONSE_ENVELOPE_KEY = {
     find: "result",
     getNode: "node",
     getNodeById: "node",
+    getText: "text",
     info: null,
     insert: null,
     replace: null,
@@ -3608,6 +3759,7 @@ var init_operation_hints = __esm(() => {
     "format.underline": null,
     "format.strikethrough": null,
     "create.paragraph": "result",
+    "create.heading": "result",
     "lists.list": "result",
     "lists.get": "item",
     "lists.insert": "result",
@@ -3632,7 +3784,8 @@ var init_operation_hints = __esm(() => {
     "trackChanges.accept": "receipt",
     "trackChanges.reject": "receipt",
     "trackChanges.acceptAll": "receipt",
-    "trackChanges.rejectAll": "receipt"
+    "trackChanges.rejectAll": "receipt",
+    "capabilities.get": "capabilities"
   };
   RESPONSE_VALIDATION_KEY = {
     insert: "receipt",
@@ -3647,6 +3800,7 @@ var init_operation_hints = __esm(() => {
     find: "query",
     getNode: "query",
     getNodeById: "query",
+    getText: "query",
     info: "general",
     insert: "textMutation",
     replace: "textMutation",
@@ -3656,6 +3810,7 @@ var init_operation_hints = __esm(() => {
     "format.underline": "textMutation",
     "format.strikethrough": "textMutation",
     "create.paragraph": "create",
+    "create.heading": "create",
     "lists.list": "lists",
     "lists.get": "lists",
     "lists.insert": "lists",
@@ -3680,7 +3835,8 @@ var init_operation_hints = __esm(() => {
     "trackChanges.accept": "trackChanges",
     "trackChanges.reject": "trackChanges",
     "trackChanges.acceptAll": "trackChanges",
-    "trackChanges.rejectAll": "trackChanges"
+    "trackChanges.rejectAll": "trackChanges",
+    "capabilities.get": "general"
   };
 });
 
@@ -3985,7 +4141,7 @@ function deriveCategoryFromDocApi(docApiId) {
   const group = REFERENCE_GROUP_BY_OP.get(docApiId);
   if (!group)
     return "query";
-  if (group === "core") {
+  if (group === "core" || group === "mutations") {
     return COMMAND_CATALOG[docApiId].mutates ? "mutation" : "query";
   }
   return group;
@@ -4032,11 +4188,7 @@ var init_operation_set = __esm(() => {
   init_cli_only_operation_definitions();
   init_types3();
   init_types3();
-  CLI_OPERATION_DENYLIST = [
-    "getText",
-    "capabilities.get",
-    "create.heading"
-  ];
+  CLI_OPERATION_DENYLIST = [];
   denySet = new Set(CLI_OPERATION_DENYLIST);
   CLI_DOC_OPERATIONS = OPERATION_IDS.filter((id) => !denySet.has(id));
   CLI_OPERATION_IDS = [
@@ -189149,6 +189301,16 @@ function buildOperationCapabilities2(editor) {
   }
   return operations;
 }
+function buildPlanEngineCapabilities() {
+  return {
+    supportedStepOps: SUPPORTED_STEP_OPS,
+    supportedNonUniformStrategies: SUPPORTED_NON_UNIFORM_STRATEGIES,
+    supportedSetMarks: SUPPORTED_SET_MARKS,
+    regex: {
+      maxPatternLength: REGEX_MAX_PATTERN_LENGTH
+    }
+  };
+}
 function getDocumentApiCapabilities2(editor) {
   const operations = buildOperationCapabilities2(editor);
   const commentsEnabled = isCommentsNamespaceEnabled2(editor);
@@ -189174,10 +189336,11 @@ function getDocumentApiCapabilities2(editor) {
         reasons: dryRunEnabled ? undefined : ["DRY_RUN_UNAVAILABLE"]
       }
     },
-    operations
+    operations,
+    planEngine: buildPlanEngineCapabilities()
   };
 }
-var REQUIRED_COMMANDS2, VALID_CAPABILITY_REASON_CODES2, FORMAT_MARK_MAP2;
+var REQUIRED_COMMANDS2, VALID_CAPABILITY_REASON_CODES2, FORMAT_MARK_MAP2, SUPPORTED_STEP_OPS, SUPPORTED_NON_UNIFORM_STRATEGIES, SUPPORTED_SET_MARKS, REGEX_MAX_PATTERN_LENGTH = 1024;
 var init_capabilities_adapter = __esm(() => {
   init_src();
   REQUIRED_COMMANDS2 = {
@@ -189210,6 +189373,17 @@ var init_capabilities_adapter = __esm(() => {
     "format.underline": "underline",
     "format.strikethrough": "strike"
   };
+  SUPPORTED_STEP_OPS = [
+    "text.rewrite",
+    "text.insert",
+    "text.delete",
+    "style.apply",
+    "assert",
+    "create.paragraph",
+    "create.heading"
+  ];
+  SUPPORTED_NON_UNIFORM_STRATEGIES = ["error", "useLeadingRun", "majority", "union"];
+  SUPPORTED_SET_MARKS = ["bold", "italic", "underline", "strike"];
 });
 
 // ../../node_modules/.pnpm/prosemirror-model@1.25.4/node_modules/prosemirror-model/dist/index.js
@@ -194209,8 +194383,8 @@ function toBlockAddress2(candidate) {
     nodeId: candidate.nodeId
   };
 }
-function resolveParagraphAliasId2(node3, primaryId) {
-  if (node3.type.name !== "paragraph")
+function resolveBlockAliasId(node3, nodeType, primaryId) {
+  if (!ALIAS_ELIGIBLE_TYPES.has(nodeType))
     return;
   const attrs = node3.attrs;
   const sdBlockId = toId2(attrs?.sdBlockId);
@@ -194246,7 +194420,7 @@ function buildBlockIndex2(editor) {
     };
     candidates.push(candidate);
     registerKey(`${nodeType}:${nodeId}`, candidate);
-    const aliasId = resolveParagraphAliasId2(node3, nodeId);
+    const aliasId = resolveBlockAliasId(node3, nodeType, nodeId);
     if (aliasId) {
       registerKey(`${nodeType}:${aliasId}`, candidate);
     }
@@ -194268,9 +194442,24 @@ function findBlockByNodeIdOnly2(index2, nodeId) {
       count: matches3.length
     });
   }
+  const aliasMatches = new Map;
   for (const [key2, candidate] of index2.byId) {
-    if (key2.endsWith(`:${nodeId}`))
-      return candidate;
+    if (!key2.endsWith(`:${nodeId}`))
+      continue;
+    aliasMatches.set(`${candidate.nodeType}:${candidate.nodeId}`, candidate);
+  }
+  if (aliasMatches.size === 1) {
+    return Array.from(aliasMatches.values())[0];
+  }
+  if (aliasMatches.size > 1) {
+    throw new DocumentApiAdapterError3("AMBIGUOUS_TARGET", `Multiple blocks share nodeId "${nodeId}" via aliases.`, {
+      nodeId,
+      count: aliasMatches.size,
+      matches: Array.from(aliasMatches.values()).map((candidate) => ({
+        nodeType: candidate.nodeType,
+        nodeId: candidate.nodeId
+      }))
+    });
   }
   throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", `Block with nodeId "${nodeId}" was not found.`, { nodeId });
 }
@@ -194297,7 +194486,7 @@ function findBlockByPos2(index2, pos) {
   }
   return;
 }
-var SUPPORTED_BLOCK_NODE_TYPES;
+var SUPPORTED_BLOCK_NODE_TYPES, ALIAS_ELIGIBLE_TYPES;
 var init_node_address_resolver = __esm(() => {
   init_errors3();
   SUPPORTED_BLOCK_NODE_TYPES = new Set([
@@ -194310,6 +194499,7 @@ var init_node_address_resolver = __esm(() => {
     "image",
     "sdt"
   ]);
+  ALIAS_ELIGIBLE_TYPES = new Set(["paragraph", "heading", "listItem"]);
 });
 
 // ../../packages/super-editor/src/document-api-adapters/helpers/index-cache.ts
@@ -194537,6 +194727,1627 @@ var init_adapter_utils = __esm(() => {
   init_errors3();
 });
 
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/executor-registry.ts
+function registerStepExecutor(opPrefix, executor) {
+  if (registry.has(opPrefix)) {
+    throw new Error(`Step executor already registered for op prefix "${opPrefix}"`);
+  }
+  registry.set(opPrefix, executor);
+}
+function getStepExecutor(op) {
+  if (registry.has(op))
+    return registry.get(op);
+  const prefix3 = op.split(".")[0];
+  return registry.get(prefix3);
+}
+function hasStepExecutor(op) {
+  return getStepExecutor(op) !== undefined;
+}
+var registry;
+var init_executor_registry = __esm(() => {
+  registry = new Map;
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/errors.ts
+function planError(code7, message, stepId, details) {
+  return new PlanError(code7, `${code7} — ${message}`, stepId, details);
+}
+var PlanError;
+var init_errors4 = __esm(() => {
+  PlanError = class PlanError extends Error {
+    code;
+    stepId;
+    details;
+    constructor(code7, message, stepId, details) {
+      super(message);
+      this.name = "PlanError";
+      this.code = code7;
+      this.stepId = stepId;
+      this.details = details;
+    }
+  };
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/revision-tracker.ts
+function getRevision(editor) {
+  const rev = revisionMap.get(editor) ?? 0;
+  return String(rev);
+}
+function incrementRevision(editor) {
+  const current = revisionMap.get(editor) ?? 0;
+  const next2 = current + 1;
+  revisionMap.set(editor, next2);
+  return String(next2);
+}
+function initRevision(editor) {
+  if (!revisionMap.has(editor)) {
+    revisionMap.set(editor, 0);
+  }
+}
+function trackRevisions(editor) {
+  if (subscribedEditors.has(editor))
+    return;
+  subscribedEditors.add(editor);
+  editor.on("transaction", ({ transaction }) => {
+    if (transaction.docChanged) {
+      incrementRevision(editor);
+    }
+  });
+}
+function checkRevision(editor, expectedRevision) {
+  if (expectedRevision === undefined)
+    return;
+  const current = getRevision(editor);
+  if (expectedRevision !== current) {
+    throw new PlanError("REVISION_MISMATCH", `REVISION_MISMATCH — expected revision "${expectedRevision}" but document is at "${current}"`, undefined, { expectedRevision, currentRevision: current });
+  }
+}
+var revisionMap, subscribedEditors;
+var init_revision_tracker = __esm(() => {
+  init_errors4();
+  revisionMap = new WeakMap;
+  subscribedEditors = new WeakSet;
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/style-resolver.ts
+function captureRunsInRange(editor, blockPos, from3, to) {
+  const doc4 = editor.state.doc;
+  const contentStart = blockPos + 1;
+  const absFrom = contentStart + from3;
+  const absTo = contentStart + to;
+  const runs2 = [];
+  doc4.nodesBetween(absFrom, absTo, (node3, pos) => {
+    if (!node3.isText)
+      return true;
+    const nodeStart = Math.max(pos, absFrom);
+    const nodeEnd = Math.min(pos + node3.nodeSize, absTo);
+    if (nodeStart >= nodeEnd)
+      return true;
+    const relFrom = nodeStart - contentStart;
+    const relTo = nodeEnd - contentStart;
+    const formattingMarks = node3.marks.filter((m3) => !METADATA_MARK_NAMES.has(m3.type.name));
+    runs2.push({
+      from: relFrom,
+      to: relTo,
+      charCount: relTo - relFrom,
+      marks: formattingMarks
+    });
+    return true;
+  });
+  const isUniform = checkUniformity(runs2);
+  return { runs: runs2, isUniform };
+}
+function checkUniformity(runs2) {
+  if (runs2.length <= 1)
+    return true;
+  const reference2 = runs2[0].marks;
+  for (let i4 = 1;i4 < runs2.length; i4++) {
+    if (!marksEqual(reference2, runs2[i4].marks))
+      return false;
+  }
+  return true;
+}
+function marksEqual(a2, b3) {
+  if (a2.length !== b3.length)
+    return false;
+  for (let i4 = 0;i4 < a2.length; i4++) {
+    if (!a2[i4].eq(b3[i4]))
+      return false;
+  }
+  return true;
+}
+function resolveInlineStyle(editor, captured, policy2, stepId) {
+  if (policy2.mode === "clear")
+    return [];
+  if (policy2.mode === "set") {
+    return buildMarksFromPolicy(editor, policy2.setMarks);
+  }
+  if (policy2.requireUniform && !captured.isUniform) {
+    throw planError("STYLE_CONFLICT", "matched range has non-uniform inline styles and requireUniform is true", stepId, { runCount: captured.runs.length });
+  }
+  let resolvedMarks;
+  if (captured.isUniform || captured.runs.length === 0) {
+    resolvedMarks = captured.runs.length > 0 ? captured.runs[0].marks : [];
+  } else {
+    const strategy = policy2.onNonUniform ?? "useLeadingRun";
+    if (strategy === "error") {
+      throw planError("STYLE_CONFLICT", 'matched range has non-uniform inline styles and onNonUniform is "error"', stepId, { runCount: captured.runs.length });
+    }
+    resolvedMarks = applyNonUniformStrategy(editor, captured.runs, strategy);
+  }
+  if (policy2.setMarks) {
+    return applySetMarksToResolved(editor, resolvedMarks, policy2.setMarks);
+  }
+  return resolvedMarks;
+}
+function applyNonUniformStrategy(editor, runs2, strategy) {
+  switch (strategy) {
+    case "useLeadingRun":
+      return resolveUseLeadingRun(runs2);
+    case "majority":
+      return resolveMajority(editor, runs2);
+    case "union":
+      return resolveUnion(editor, runs2);
+  }
+}
+function resolveUseLeadingRun(runs2) {
+  return runs2.length > 0 ? runs2[0].marks : [];
+}
+function resolveMajority(editor, runs2) {
+  const totalChars = runs2.reduce((sum, r2) => sum + r2.charCount, 0);
+  if (totalChars === 0)
+    return [];
+  const allMarkNames = new Set;
+  for (const run2 of runs2) {
+    for (const mark2 of run2.marks) {
+      allMarkNames.add(mark2.type.name);
+    }
+  }
+  const resultMarks = [];
+  for (const markName of allMarkNames) {
+    if (CORE_MARK_NAMES.has(markName)) {
+      let activeChars = 0;
+      for (const run2 of runs2) {
+        if (run2.marks.some((m3) => m3.type.name === markName)) {
+          activeChars += run2.charCount;
+        }
+      }
+      if (activeChars > totalChars / 2) {
+        for (const run2 of runs2) {
+          const found3 = run2.marks.find((m3) => m3.type.name === markName);
+          if (found3) {
+            resultMarks.push(found3);
+            break;
+          }
+        }
+      }
+    } else {
+      resolveValueBearingMarkMajority(runs2, markName, totalChars, resultMarks);
+    }
+  }
+  return resultMarks;
+}
+function resolveValueBearingMarkMajority(runs2, markName, totalChars, resultMarks) {
+  let anyRunHasMark = false;
+  for (const run2 of runs2) {
+    if (run2.marks.some((m3) => m3.type.name === markName)) {
+      anyRunHasMark = true;
+      break;
+    }
+  }
+  if (!anyRunHasMark)
+    return;
+  const allAttrKeys = new Set;
+  const markInstances = [];
+  for (const run2 of runs2) {
+    const mark2 = run2.marks.find((m3) => m3.type.name === markName);
+    if (mark2) {
+      markInstances.push({ mark: mark2, run: run2 });
+      for (const key2 of Object.keys(mark2.attrs)) {
+        allAttrKeys.add(key2);
+      }
+    }
+  }
+  const resolvedAttrs = {};
+  let hasAnyAttr = false;
+  for (const key2 of allAttrKeys) {
+    const valueTally = new Map;
+    for (let i4 = 0;i4 < runs2.length; i4++) {
+      const run2 = runs2[i4];
+      const mark2 = run2.marks.find((m3) => m3.type.name === markName);
+      const value = mark2 ? mark2.attrs[key2] : undefined;
+      const serialized = JSON.stringify(value);
+      const existing = valueTally.get(serialized);
+      if (existing) {
+        existing.chars += run2.charCount;
+      } else {
+        valueTally.set(serialized, { chars: run2.charCount, firstRunIdx: i4, value });
+      }
+    }
+    let winner;
+    for (const entry of valueTally.values()) {
+      if (!winner || entry.chars > winner.chars || entry.chars === winner.chars && entry.firstRunIdx < winner.firstRunIdx) {
+        winner = entry;
+      }
+    }
+    if (winner && winner.value !== undefined) {
+      resolvedAttrs[key2] = winner.value;
+      hasAnyAttr = true;
+    }
+  }
+  if (hasAnyAttr && markInstances.length > 0) {
+    const templateMark = markInstances[0].mark;
+    try {
+      const resolvedMark = templateMark.type.create(resolvedAttrs);
+      resultMarks.push(resolvedMark);
+    } catch {
+      resultMarks.push(templateMark);
+    }
+  }
+}
+function resolveUnion(editor, runs2) {
+  const allMarkNames = new Set;
+  for (const run2 of runs2) {
+    for (const mark2 of run2.marks) {
+      allMarkNames.add(mark2.type.name);
+    }
+  }
+  const resultMarks = [];
+  for (const markName of allMarkNames) {
+    if (CORE_MARK_NAMES.has(markName)) {
+      for (const run2 of runs2) {
+        const found3 = run2.marks.find((m3) => m3.type.name === markName);
+        if (found3) {
+          resultMarks.push(found3);
+          break;
+        }
+      }
+    } else {
+      for (const run2 of runs2) {
+        const found3 = run2.marks.find((m3) => m3.type.name === markName);
+        if (found3) {
+          resultMarks.push(found3);
+          break;
+        }
+      }
+    }
+  }
+  return resultMarks;
+}
+function buildMarksFromPolicy(editor, setMarks) {
+  if (!setMarks)
+    return [];
+  const { schema } = editor.state;
+  const marks = [];
+  if (setMarks.bold && schema.marks.bold)
+    marks.push(schema.marks.bold.create());
+  if (setMarks.italic && schema.marks.italic)
+    marks.push(schema.marks.italic.create());
+  if (setMarks.underline && schema.marks.underline)
+    marks.push(schema.marks.underline.create());
+  if (setMarks.strike && schema.marks.strike)
+    marks.push(schema.marks.strike.create());
+  return marks;
+}
+function applySetMarksToResolved(editor, existingMarks, setMarks) {
+  const { schema } = editor.state;
+  let marks = [...existingMarks];
+  const overrides = [
+    [setMarks.bold, schema.marks.bold],
+    [setMarks.italic, schema.marks.italic],
+    [setMarks.underline, schema.marks.underline],
+    [setMarks.strike, schema.marks.strike]
+  ];
+  for (const [value, markType] of overrides) {
+    if (value === undefined || !markType)
+      continue;
+    if (value) {
+      if (!marks.some((m3) => m3.type === markType)) {
+        marks.push(markType.create());
+      }
+    } else {
+      marks = marks.filter((m3) => m3.type !== markType);
+    }
+  }
+  return marks;
+}
+var CORE_MARK_NAMES, METADATA_MARK_NAMES;
+var init_style_resolver = __esm(() => {
+  init_errors4();
+  CORE_MARK_NAMES = new Set(["bold", "italic", "underline", "strike"]);
+  METADATA_MARK_NAMES = new Set([
+    "trackInsert",
+    "trackDelete",
+    "trackFormat",
+    "commentMark",
+    "aiMark",
+    "aiAnimationMark"
+  ]);
+});
+
+// ../../packages/super-editor/src/document-api-adapters/find/common.ts
+function resolveUnknownBlockId2(attrs) {
+  if (!attrs)
+    return;
+  return toId2(attrs.paraId) ?? toId2(attrs.sdBlockId) ?? toId2(attrs.blockId) ?? toId2(attrs.id) ?? toId2(attrs.uuid);
+}
+function isDualKindType2(nodeType) {
+  return Boolean(nodeType && DUAL_KIND_TYPES2.has(nodeType));
+}
+function getAddressStartPos2(editor, index2, address2) {
+  if (address2.kind === "block") {
+    const block = findBlockById2(index2, address2);
+    return block?.pos ?? Number.MAX_SAFE_INTEGER;
+  }
+  const inlineIndex = getInlineIndex2(editor);
+  const inline = findInlineByAnchor2(inlineIndex, address2);
+  return inline?.pos ?? Number.MAX_SAFE_INTEGER;
+}
+function buildTextContext2(editor, address2, matchFrom, matchTo, textRanges) {
+  const docSize = editor.state.doc.content.size;
+  const snippetFrom = Math.max(0, matchFrom - SNIPPET_PADDING2);
+  const snippetTo = Math.min(docSize, matchTo + SNIPPET_PADDING2);
+  const rawSnippet = editor.state.doc.textBetween(snippetFrom, snippetTo, " ");
+  const snippet = rawSnippet.replace(/ {2,}/g, " ");
+  const rawPrefix = editor.state.doc.textBetween(snippetFrom, matchFrom, " ");
+  const rawMatch = editor.state.doc.textBetween(matchFrom, matchTo, " ");
+  const prefix3 = rawPrefix.replace(/ {2,}/g, " ");
+  const matchNormalized = rawMatch.replace(/ {2,}/g, " ");
+  return {
+    address: address2,
+    snippet,
+    highlightRange: {
+      start: prefix3.length,
+      end: prefix3.length + matchNormalized.length
+    },
+    textRanges: textRanges?.length ? textRanges : undefined
+  };
+}
+function toTextAddress2(editor, block, range) {
+  const blockStart = block.pos + 1;
+  const blockEnd = block.end - 1;
+  if (range.from < blockStart || range.to > blockEnd)
+    return;
+  const start2 = editor.state.doc.textBetween(blockStart, range.from, `
+`, "").length;
+  const end = editor.state.doc.textBetween(blockStart, range.to, `
+`, "").length;
+  return {
+    kind: "text",
+    blockId: block.nodeId,
+    range: { start: start2, end }
+  };
+}
+function shouldQueryBothKinds2(select2) {
+  if (select2.type === "node") {
+    return !select2.kind && isDualKindType2(select2.nodeType);
+  }
+  return false;
+}
+function sortAddressesByPosition2(editor, index2, addresses) {
+  return [...addresses].sort((a2, b3) => {
+    const aPos = getAddressStartPos2(editor, index2, a2);
+    const bPos = getAddressStartPos2(editor, index2, b3);
+    if (aPos !== bPos)
+      return aPos - bPos;
+    if (a2.kind === b3.kind)
+      return 0;
+    return a2.kind === "block" ? -1 : 1;
+  });
+}
+function collectUnknownNodeDiagnostics2(editor, index2, diagnostics) {
+  editor.state.doc.descendants((node3, pos) => {
+    if (node3.isBlock && !KNOWN_BLOCK_PM_NODE_TYPES2.has(node3.type.name)) {
+      const blockId = resolveUnknownBlockId2(node3.attrs ?? {});
+      diagnostics.push({
+        message: `Unknown block node type "${node3.type.name}" is not part of the stable Document API match set.`,
+        hint: blockId ? `Skipped unknown block with stable id "${blockId}".` : "Skipped unknown block with no stable id available."
+      });
+      return;
+    }
+    if (node3.isInline && !KNOWN_INLINE_PM_NODE_TYPES2.has(node3.type.name)) {
+      const container = findCandidateByPos2(index2.candidates, pos);
+      diagnostics.push({
+        message: `Unknown inline node type "${node3.type.name}" is not part of the stable Document API match set.`,
+        address: container ? toBlockAddress2(container) : undefined,
+        hint: container ? `Skipped unknown inline node inside block "${container.nodeType}" with id "${container.nodeId}".` : "Skipped unknown inline node outside resolvable block scope."
+      });
+    }
+  });
+}
+function isInlineQuery2(select2) {
+  if (select2.type === "node") {
+    if (select2.kind)
+      return select2.kind === "inline";
+    return Boolean(select2.nodeType && isInlineQueryType2(select2.nodeType));
+  }
+  return false;
+}
+var SNIPPET_PADDING2 = 30, DUAL_KIND_TYPES2, KNOWN_BLOCK_PM_NODE_TYPES2, KNOWN_INLINE_PM_NODE_TYPES2;
+var init_common = __esm(() => {
+  init_index_cache();
+  init_node_address_resolver();
+  init_inline_address_resolver();
+  init_adapter_utils();
+  DUAL_KIND_TYPES2 = new Set(["sdt", "image"]);
+  KNOWN_BLOCK_PM_NODE_TYPES2 = new Set([
+    "paragraph",
+    "table",
+    "tableRow",
+    "tableCell",
+    "tableHeader",
+    "structuredContentBlock",
+    "sdt",
+    "image"
+  ]);
+  KNOWN_INLINE_PM_NODE_TYPES2 = new Set([
+    "text",
+    "run",
+    "structuredContent",
+    "image",
+    "tab",
+    "lineBreak",
+    "hardBreak",
+    "hard_break",
+    "footnoteReference",
+    "bookmarkStart",
+    "bookmarkEnd",
+    "commentRangeStart",
+    "commentRangeEnd"
+  ]);
+});
+
+// ../../packages/super-editor/src/document-api-adapters/find/text-strategy.ts
+function compileRegex2(selector, diagnostics) {
+  if (selector.pattern.length > MAX_PATTERN_LENGTH) {
+    addDiagnostic2(diagnostics, `Text query regex pattern exceeds ${MAX_PATTERN_LENGTH} characters.`);
+    return null;
+  }
+  const flags = selector.caseSensitive ? "g" : "gi";
+  try {
+    return new RegExp(selector.pattern, flags);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    addDiagnostic2(diagnostics, `Invalid text query regex: ${reason}`);
+    return null;
+  }
+}
+function buildSearchPattern2(selector, diagnostics) {
+  const mode = selector.mode ?? "contains";
+  if (mode === "regex") {
+    return compileRegex2(selector, diagnostics);
+  }
+  if (selector.pattern.length > MAX_PATTERN_LENGTH) {
+    addDiagnostic2(diagnostics, `Text query pattern exceeds ${MAX_PATTERN_LENGTH} characters.`);
+    return null;
+  }
+  const escaped = selector.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const flags = selector.caseSensitive ? "g" : "gi";
+  return new RegExp(escaped, flags);
+}
+function executeTextSelector2(editor, index2, query2, diagnostics) {
+  if (query2.select.type !== "text") {
+    addDiagnostic2(diagnostics, `Text strategy received a non-text selector (type="${query2.select.type}").`);
+    return { matches: [], total: 0 };
+  }
+  const selector = query2.select;
+  if (!selector.pattern.length) {
+    addDiagnostic2(diagnostics, "Text query pattern must be non-empty.");
+    return { matches: [], total: 0 };
+  }
+  const scope = resolveWithinScope2(index2, query2, diagnostics);
+  if (!scope.ok)
+    return { matches: [], total: 0 };
+  const pattern = buildSearchPattern2(selector, diagnostics);
+  if (!pattern)
+    return { matches: [], total: 0 };
+  const search3 = requireEditorCommand2(editor.commands?.search, "find (search)");
+  const rawResult = search3(pattern, {
+    highlight: false,
+    caseSensitive: selector.caseSensitive ?? false,
+    maxMatches: Infinity
+  });
+  if (!Array.isArray(rawResult)) {
+    throw new DocumentApiAdapterError3("CAPABILITY_UNAVAILABLE", "Editor search command returned an unexpected result format.");
+  }
+  const allMatches = rawResult;
+  const scopeRange = scope.range;
+  const matches3 = scopeRange ? allMatches.filter((m3) => m3.from >= scopeRange.start && m3.to <= scopeRange.end) : allMatches;
+  const textBlocks = index2.candidates.filter(isTextBlockCandidate2);
+  const contexts = [];
+  const addresses = [];
+  for (const match2 of matches3) {
+    const ranges = match2.ranges?.length ? match2.ranges : [{ from: match2.from, to: match2.to }];
+    let source;
+    const textRanges = ranges.map((range) => {
+      const block = findCandidateByPos2(textBlocks, range.from);
+      if (!block)
+        return;
+      if (!source)
+        source = block;
+      return toTextAddress2(editor, block, range);
+    }).filter((range) => Boolean(range));
+    if (!source) {
+      source = findCandidateByPos2(textBlocks, match2.from) ?? findBlockByPos2(index2, match2.from);
+    }
+    if (!source)
+      continue;
+    const address2 = toBlockAddress2(source);
+    addresses.push(address2);
+    contexts.push(buildTextContext2(editor, address2, match2.from, match2.to, textRanges));
+  }
+  const paged = paginate2(addresses, query2.offset, query2.limit);
+  const pagedContexts = paginate2(contexts, query2.offset, query2.limit).items;
+  return {
+    matches: paged.items,
+    total: paged.total,
+    context: pagedContexts.length ? pagedContexts : undefined
+  };
+}
+var MAX_PATTERN_LENGTH = 1024;
+var init_text_strategy = __esm(() => {
+  init_node_address_resolver();
+  init_adapter_utils();
+  init_common();
+  init_errors3();
+  init_mutation_helpers();
+});
+
+// ../../packages/super-editor/src/document-api-adapters/find/block-strategy.ts
+function executeBlockSelector2(index2, query2, diagnostics) {
+  const scope = resolveWithinScope2(index2, query2, diagnostics);
+  if (!scope.ok)
+    return { matches: [], total: 0 };
+  const scoped = scopeByRange2(index2.candidates, scope.range);
+  const select2 = query2.select;
+  let filtered = [];
+  if (select2.type === "node") {
+    if (select2.kind && select2.kind !== "block") {
+      addDiagnostic2(diagnostics, "Only block nodes are supported by the current adapter.");
+    } else {
+      filtered = scoped.filter((candidate) => {
+        if (select2.nodeType) {
+          if (candidate.nodeType !== select2.nodeType)
+            return false;
+        }
+        return true;
+      });
+    }
+  }
+  const addresses = filtered.map((candidate) => ({
+    kind: "block",
+    nodeType: candidate.nodeType,
+    nodeId: candidate.nodeId
+  }));
+  const paged = paginate2(addresses, query2.offset, query2.limit);
+  return {
+    matches: paged.items,
+    total: paged.total
+  };
+}
+var init_block_strategy = __esm(() => {
+  init_adapter_utils();
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/compiler.ts
+function isAssertStep(step) {
+  return step.op === "assert";
+}
+function isSelectWhere(where) {
+  return where.by === "select";
+}
+function normalizeMatchRanges(stepId, ranges) {
+  if (ranges.length === 0) {
+    throw planError("INVALID_INPUT", "logical match produced zero ranges", stepId);
+  }
+  for (const r2 of ranges) {
+    if (r2.range.start < 0 || r2.range.end < r2.range.start) {
+      throw planError("INVALID_INPUT", `invalid range bounds [${r2.range.start}, ${r2.range.end}) in block "${r2.blockId}"`, stepId);
+    }
+  }
+  const blockId = ranges[0].blockId;
+  if (ranges.some((r2) => r2.blockId !== blockId)) {
+    throw planError("CROSS_BLOCK_MATCH", `mutation target spans multiple blocks`, stepId, {
+      blockIds: [...new Set(ranges.map((r2) => r2.blockId))]
+    });
+  }
+  if (ranges.length === 1) {
+    return { blockId, from: ranges[0].range.start, to: ranges[0].range.end };
+  }
+  const sorted = [...ranges].sort((a2, b3) => a2.range.start - b3.range.start);
+  const from3 = sorted[0].range.start;
+  let to = sorted[0].range.end;
+  for (let i4 = 1;i4 < sorted.length; i4++) {
+    const r2 = sorted[i4];
+    if (r2.range.start > to) {
+      throw planError("INVALID_INPUT", `match ranges are discontiguous within block "${blockId}" (gap between offset ${to} and ${r2.range.start})`, stepId);
+    }
+    if (r2.range.end > to)
+      to = r2.range.end;
+  }
+  return { blockId, from: from3, to };
+}
+function resolveTextSelector(editor, index2, selector, within2, stepId) {
+  if (selector.type === "text") {
+    const query3 = {
+      select: selector,
+      within: within2,
+      includeNodes: false
+    };
+    const result2 = executeTextSelector2(editor, index2, query3, []);
+    const addresses2 = [];
+    if (result2.context) {
+      for (const ctx2 of result2.context) {
+        if (!ctx2.textRanges?.length)
+          continue;
+        const coalesced = normalizeMatchRanges(stepId, ctx2.textRanges);
+        const candidate = index2.candidates.find((c2) => c2.nodeId === coalesced.blockId);
+        if (!candidate)
+          continue;
+        const blockText = getBlockText(editor, candidate);
+        const matchText = blockText.slice(coalesced.from, coalesced.to);
+        const captured = captureRunsInRange(editor, candidate.pos, coalesced.from, coalesced.to);
+        addresses2.push({
+          blockId: coalesced.blockId,
+          from: coalesced.from,
+          to: coalesced.to,
+          text: matchText,
+          marks: captured.runs.length > 0 ? captured.runs[0].marks : [],
+          blockPos: candidate.pos
+        });
+      }
+    }
+    return { addresses: addresses2 };
+  }
+  const query2 = {
+    select: selector,
+    within: within2,
+    includeNodes: false
+  };
+  const result = executeBlockSelector2(index2, query2, []);
+  const textBlocks = index2.candidates.filter(isTextBlockCandidate2);
+  const addresses = [];
+  for (const match2 of result.matches) {
+    if (match2.kind !== "block")
+      continue;
+    const candidate = textBlocks.find((c2) => c2.nodeId === match2.nodeId);
+    if (!candidate)
+      continue;
+    const blockText = getBlockText(editor, candidate);
+    addresses.push({
+      blockId: match2.nodeId,
+      from: 0,
+      to: blockText.length,
+      text: blockText,
+      marks: [],
+      blockPos: candidate.pos
+    });
+  }
+  return { addresses };
+}
+function getBlockText(editor, candidate) {
+  const blockStart = candidate.pos + 1;
+  const blockEnd = candidate.end - 1;
+  return editor.state.doc.textBetween(blockStart, blockEnd, `
+`, "");
+}
+function applyCardinalityCheck(step, targets) {
+  const where = step.where;
+  if (!("require" in where))
+    return;
+  const require2 = where.require;
+  if (require2 === "first") {
+    if (targets.length === 0) {
+      throw planError("MATCH_NOT_FOUND", `selector matched zero ranges`, step.id);
+    }
+  } else if (require2 === "exactlyOne") {
+    if (targets.length === 0) {
+      throw planError("MATCH_NOT_FOUND", `selector matched zero ranges`, step.id);
+    }
+    if (targets.length > 1) {
+      throw planError("AMBIGUOUS_MATCH", `selector matched ${targets.length} ranges, expected exactly one`, step.id, {
+        matchCount: targets.length
+      });
+    }
+  } else if (require2 === "all") {
+    if (targets.length === 0) {
+      throw planError("MATCH_NOT_FOUND", `selector matched zero ranges`, step.id);
+    }
+  }
+}
+function isRefWhere(where) {
+  return where.by === "ref";
+}
+function resolveTextRef(editor, index2, step, ref2) {
+  const encoded = ref2.slice(5);
+  let refData;
+  try {
+    refData = JSON.parse(atob(encoded));
+  } catch {
+    throw planError("INVALID_INPUT", `invalid text ref encoding`, step.id);
+  }
+  const currentRevision = getRevision(editor);
+  if (refData.rev !== currentRevision) {
+    throw planError("REVISION_MISMATCH", `text ref was created at revision "${refData.rev}" but document is at "${currentRevision}"`, step.id, { refRevision: refData.rev, currentRevision });
+  }
+  if (!refData.ranges?.length)
+    return [];
+  const coalesced = normalizeMatchRanges(step.id, refData.ranges);
+  const candidate = index2.candidates.find((c2) => c2.nodeId === coalesced.blockId);
+  if (!candidate)
+    return [];
+  const blockText = getBlockText(editor, candidate);
+  const matchText = blockText.slice(coalesced.from, coalesced.to);
+  const capturedStyle = step.op === "text.rewrite" ? captureRunsInRange(editor, candidate.pos, coalesced.from, coalesced.to) : undefined;
+  return [
+    {
+      stepId: step.id,
+      op: step.op,
+      blockId: coalesced.blockId,
+      from: coalesced.from,
+      to: coalesced.to,
+      text: matchText,
+      marks: [],
+      capturedStyle
+    }
+  ];
+}
+function resolveBlockRef(editor, index2, step, ref2) {
+  const candidate = index2.candidates.find((c2) => c2.nodeId === ref2);
+  if (!candidate)
+    return [];
+  const blockText = getBlockText(editor, candidate);
+  const capturedStyle = step.op === "text.rewrite" ? captureRunsInRange(editor, candidate.pos, 0, blockText.length) : undefined;
+  return [
+    {
+      stepId: step.id,
+      op: step.op,
+      blockId: candidate.nodeId,
+      from: 0,
+      to: blockText.length,
+      text: blockText,
+      marks: [],
+      capturedStyle
+    }
+  ];
+}
+function resolveRefTargets(editor, index2, step, where) {
+  const ref2 = where.ref;
+  if (ref2.startsWith("text:")) {
+    return resolveTextRef(editor, index2, step, ref2);
+  }
+  return resolveBlockRef(editor, index2, step, ref2);
+}
+function resolveStepTargets(editor, index2, step) {
+  const where = step.where;
+  let targets;
+  if (isRefWhere(where)) {
+    targets = resolveRefTargets(editor, index2, step, where);
+  } else if (isSelectWhere(where)) {
+    const resolved = resolveTextSelector(editor, index2, where.select, where.within, step.id);
+    targets = resolved.addresses.map((addr) => {
+      const capturedStyle = step.op === "text.rewrite" ? captureRunsInRange(editor, addr.blockPos, addr.from, addr.to) : undefined;
+      return {
+        stepId: step.id,
+        op: step.op,
+        blockId: addr.blockId,
+        from: addr.from,
+        to: addr.to,
+        text: addr.text,
+        marks: addr.marks,
+        capturedStyle
+      };
+    });
+  } else {
+    throw planError("INVALID_INPUT", `unsupported where.by value`, step.id);
+  }
+  targets.sort((a2, b3) => {
+    if (a2.blockId === b3.blockId)
+      return a2.from - b3.from;
+    const posA = index2.candidates.find((c2) => c2.nodeId === a2.blockId)?.pos ?? 0;
+    const posB = index2.candidates.find((c2) => c2.nodeId === b3.blockId)?.pos ?? 0;
+    return posA - posB;
+  });
+  targets = targets.filter((t, i4) => i4 === 0 || t.blockId !== targets[i4 - 1].blockId || t.from !== targets[i4 - 1].from || t.to !== targets[i4 - 1].to);
+  applyCardinalityCheck(step, targets);
+  const require2 = "require" in where ? where.require : undefined;
+  if (require2 === "first" && targets.length > 1) {
+    targets = [targets[0]];
+  }
+  return targets;
+}
+function compilePlan(editor, steps) {
+  const index2 = getBlockIndex2(editor);
+  const mutationSteps = [];
+  const assertSteps = [];
+  const seenIds = new Set;
+  for (const step of steps) {
+    if (!step.id) {
+      throw planError("INVALID_INPUT", "step.id is required");
+    }
+    if (seenIds.has(step.id)) {
+      throw planError("INVALID_INPUT", `duplicate step id "${step.id}"`, step.id);
+    }
+    seenIds.add(step.id);
+  }
+  for (const step of steps) {
+    if (isAssertStep(step)) {
+      assertSteps.push(step);
+      continue;
+    }
+    if (!hasStepExecutor(step.op)) {
+      throw planError("INVALID_INPUT", `unknown step op "${step.op}"`, step.id);
+    }
+    const targets = resolveStepTargets(editor, index2, step);
+    mutationSteps.push({ step, targets });
+  }
+  detectOverlaps(mutationSteps);
+  return { mutationSteps, assertSteps };
+}
+function detectOverlaps(steps) {
+  const rangesByBlock = new Map;
+  for (const compiled of steps) {
+    for (const target of compiled.targets) {
+      let blockRanges = rangesByBlock.get(target.blockId);
+      if (!blockRanges) {
+        blockRanges = [];
+        rangesByBlock.set(target.blockId, blockRanges);
+      }
+      blockRanges.push({ stepId: target.stepId, from: target.from, to: target.to });
+    }
+  }
+  for (const [blockId, ranges] of rangesByBlock) {
+    ranges.sort((a2, b3) => a2.from - b3.from);
+    for (let i4 = 1;i4 < ranges.length; i4++) {
+      const prev = ranges[i4 - 1];
+      const curr = ranges[i4];
+      if (prev.stepId !== curr.stepId && prev.to > curr.from) {
+        throw planError("PLAN_CONFLICT_OVERLAP", `steps "${prev.stepId}" and "${curr.stepId}" target overlapping ranges in block "${blockId}"`, curr.stepId, { blockId, rangeA: { from: prev.from, to: prev.to }, rangeB: { from: curr.from, to: curr.to } });
+      }
+    }
+  }
+}
+var init_compiler = __esm(() => {
+  init_errors4();
+  init_executor_registry();
+  init_style_resolver();
+  init_index_cache();
+  init_revision_tracker();
+  init_text_strategy();
+  init_block_strategy();
+  init_node_address_resolver();
+});
+
+// ../../packages/super-editor/src/document-api-adapters/helpers/transaction-meta.ts
+function applyDirectMutationMeta2(tr) {
+  tr.setMeta("inputType", "programmatic");
+  tr.setMeta("skipTrackChanges", true);
+  return tr;
+}
+function applyTrackedMutationMeta2(tr) {
+  tr.setMeta("inputType", "programmatic");
+  tr.setMeta("forceTrackChanges", true);
+  return tr;
+}
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/executor.ts
+function resolveMarks(editor, target, step) {
+  if (step.op !== "text.rewrite")
+    return [];
+  const rewriteStep = step;
+  const policy2 = rewriteStep.args.style?.inline ?? DEFAULT_INLINE_POLICY;
+  const captured = target.capturedStyle ?? captureRunsInRange(editor, toAbsoluteBlockPos(editor, target.blockId), target.from, target.to);
+  return resolveInlineStyle(editor, captured, policy2, step.id);
+}
+function toAbsoluteBlockPos(editor, blockId) {
+  const index2 = getBlockIndex2(editor);
+  const candidate = index2.candidates.find((c2) => c2.nodeId === blockId);
+  if (!candidate)
+    throw planError("TARGET_NOT_FOUND", `block "${blockId}" not found in style capture fallback`);
+  return candidate.pos;
+}
+function buildMarksFromSetMarks(editor, setMarks) {
+  if (!setMarks)
+    return [];
+  const { schema } = editor.state;
+  const marks = [];
+  if (setMarks.bold && schema.marks.bold)
+    marks.push(schema.marks.bold.create());
+  if (setMarks.italic && schema.marks.italic)
+    marks.push(schema.marks.italic.create());
+  if (setMarks.underline && schema.marks.underline)
+    marks.push(schema.marks.underline.create());
+  if (setMarks.strike && schema.marks.strike)
+    marks.push(schema.marks.strike.create());
+  return marks;
+}
+function resolveTextRange(editor, blockId, from3, to, stepId) {
+  const index2 = getBlockIndex2(editor);
+  const candidate = index2.candidates.find((c2) => c2.nodeId === blockId);
+  if (!candidate)
+    throw planError("TARGET_NOT_FOUND", `block "${blockId}" not found`, stepId);
+  const resolved = resolveTextRangeInBlock2(candidate.node, candidate.pos, { start: from3, end: to });
+  if (!resolved) {
+    throw planError("INVALID_INPUT", `text offset [${from3}, ${to}) out of range in block "${blockId}"`, stepId);
+  }
+  return { absFrom: resolved.from, absTo: resolved.to };
+}
+function resolveTextOffset(editor, blockId, offset2, stepId) {
+  return resolveTextRange(editor, blockId, offset2, offset2, stepId).absFrom;
+}
+function toAbsoluteBlockInsertPos(editor, blockId, offset2, stepId) {
+  const index2 = getBlockIndex2(editor);
+  const candidate = index2.candidates.find((c2) => c2.nodeId === blockId);
+  if (!candidate)
+    throw planError("TARGET_NOT_FOUND", `block "${blockId}" not found`, stepId);
+  return candidate.pos + offset2;
+}
+function executeTextRewrite(editor, tr, target, step, mapping) {
+  const range = resolveTextRange(editor, target.blockId, target.from, target.to, step.id);
+  const absFrom = mapping.map(range.absFrom);
+  const absTo = mapping.map(range.absTo);
+  const replacementText = step.args.replacement.text;
+  const marks = resolveMarks(editor, target, step);
+  const textNode = editor.state.schema.text(replacementText, marks);
+  tr.replaceWith(absFrom, absTo, textNode);
+  return { changed: replacementText !== target.text };
+}
+function executeTextInsert(editor, tr, target, step, mapping) {
+  const position4 = step.args.position;
+  const offset2 = position4 === "before" ? target.from : target.to;
+  const absPos = mapping.map(resolveTextOffset(editor, target.blockId, offset2, step.id));
+  const text4 = step.args.content.text;
+  if (!text4)
+    return { changed: false };
+  let marks = [];
+  const stylePolicy = step.args.style?.inline;
+  if (stylePolicy) {
+    if (stylePolicy.mode === "set") {
+      marks = buildMarksFromSetMarks(editor, stylePolicy.setMarks);
+    } else if (stylePolicy.mode === "clear") {
+      marks = [];
+    } else {
+      const resolvedPos = tr.doc.resolve(absPos);
+      marks = resolvedPos.marks();
+    }
+  } else {
+    const resolvedPos = tr.doc.resolve(absPos);
+    marks = resolvedPos.marks();
+  }
+  const textNode = editor.state.schema.text(text4, marks);
+  tr.insert(absPos, textNode);
+  return { changed: true };
+}
+function executeTextDelete(editor, tr, target, _step, mapping) {
+  const range = resolveTextRange(editor, target.blockId, target.from, target.to, _step.id);
+  const absFrom = mapping.map(range.absFrom);
+  const absTo = mapping.map(range.absTo);
+  if (absFrom === absTo)
+    return { changed: false };
+  tr.delete(absFrom, absTo);
+  return { changed: true };
+}
+function executeStyleApply(editor, tr, target, step, mapping) {
+  const range = resolveTextRange(editor, target.blockId, target.from, target.to, step.id);
+  const absFrom = mapping.map(range.absFrom);
+  const absTo = mapping.map(range.absTo);
+  const { schema } = editor.state;
+  let changed = false;
+  const markEntries = [
+    ["bold", step.args.marks.bold, schema.marks.bold],
+    ["italic", step.args.marks.italic, schema.marks.italic],
+    ["underline", step.args.marks.underline, schema.marks.underline],
+    ["strike", step.args.marks.strike, schema.marks.strike]
+  ];
+  for (const [, value, markType] of markEntries) {
+    if (value === undefined || !markType)
+      continue;
+    if (value) {
+      tr.addMark(absFrom, absTo, markType.create());
+    } else {
+      tr.removeMark(absFrom, absTo, markType);
+    }
+    changed = true;
+  }
+  return { changed };
+}
+function countTextMatches(text4, pattern, mode, caseSensitive) {
+  if (mode === "regex") {
+    if (pattern.length > 1024)
+      return 0;
+    const flags = caseSensitive ? "g" : "gi";
+    try {
+      const regex = new RegExp(pattern, flags);
+      const matches3 = text4.match(regex);
+      return matches3 ? matches3.length : 0;
+    } catch {
+      return 0;
+    }
+  }
+  const searchText = caseSensitive ? text4 : text4.toLowerCase();
+  const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    const idx = searchText.indexOf(searchPattern, pos);
+    if (idx === -1)
+      break;
+    count++;
+    pos = idx + 1;
+  }
+  return count;
+}
+function asId(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function resolveAssertNodeId(node3, mappedType) {
+  const attrs = node3.attrs ?? {};
+  if (mappedType === "paragraph" || mappedType === "heading" || mappedType === "listItem") {
+    return asId(attrs.paraId) ?? asId(attrs.sdBlockId) ?? asId(attrs.nodeId);
+  }
+  return asId(attrs.blockId) ?? asId(attrs.id) ?? asId(attrs.paraId) ?? asId(attrs.uuid) ?? asId(attrs.sdBlockId) ?? asId(attrs.nodeId);
+}
+function buildAssertIndex(doc4) {
+  const candidates = [];
+  const byId = new Map;
+  const ambiguous = new Set;
+  function registerKey(key2, candidate) {
+    if (byId.has(key2)) {
+      ambiguous.add(key2);
+      byId.delete(key2);
+      return;
+    }
+    if (!ambiguous.has(key2)) {
+      byId.set(key2, candidate);
+    }
+  }
+  doc4.descendants((node3, pos) => {
+    const nodeType = mapBlockNodeType2(node3);
+    if (!nodeType)
+      return true;
+    const nodeId = resolveAssertNodeId(node3, nodeType);
+    if (!nodeId)
+      return true;
+    const candidate = {
+      node: node3,
+      pos,
+      end: pos + node3.nodeSize,
+      nodeType,
+      nodeId
+    };
+    candidates.push(candidate);
+    registerKey(`${nodeType}:${nodeId}`, candidate);
+    if (nodeType === "paragraph" || nodeType === "heading" || nodeType === "listItem") {
+      const aliasId = asId(node3.attrs?.sdBlockId);
+      if (aliasId && aliasId !== nodeId) {
+        registerKey(`${nodeType}:${aliasId}`, candidate);
+      }
+    }
+    return true;
+  });
+  return { candidates, byId };
+}
+function resolveAssertScope(index2, select2, within2) {
+  if (!within2)
+    return { ok: true, range: undefined };
+  const scope = resolveWithinScope2(index2, { select: select2, within: within2 }, []);
+  if (!scope.ok)
+    return { ok: false };
+  return { ok: true, range: scope.range };
+}
+function countNodeMatchesInDoc(doc4, selector, within2) {
+  const index2 = buildAssertIndex(doc4);
+  const scope = resolveAssertScope(index2, selector, within2);
+  if (!scope.ok)
+    return 0;
+  if (selector.kind && selector.kind !== "block")
+    return 0;
+  const scoped = scopeByRange2(index2.candidates, scope.range);
+  let count = 0;
+  for (const candidate of scoped) {
+    if (selector.nodeType && candidate.nodeType !== selector.nodeType)
+      continue;
+    count++;
+  }
+  return count;
+}
+function resolveScopedTextForAssert(doc4, selector, within2) {
+  const index2 = buildAssertIndex(doc4);
+  const scope = resolveAssertScope(index2, selector, within2);
+  if (!scope.ok)
+    return "";
+  if (!scope.range)
+    return doc4.textContent;
+  return doc4.textBetween(scope.range.start, scope.range.end, `
+`, "");
+}
+function executeAssertStep(_editor, tr, step) {
+  const where = step.where;
+  if (where.by !== "select") {
+    throw planError("INVALID_INPUT", `assert steps only support by: 'select'`, step.id);
+  }
+  const selector = where.select;
+  if (selector.type !== "text") {
+    const count2 = countNodeMatchesInDoc(tr.doc, selector, where.within);
+    return { passed: count2 === step.args.expectCount, actualCount: count2 };
+  }
+  const text4 = resolveScopedTextForAssert(tr.doc, selector, where.within);
+  const pattern = selector.pattern;
+  const mode = selector.mode ?? "contains";
+  const caseSensitive = selector.caseSensitive ?? false;
+  const count = countTextMatches(text4, pattern, mode, caseSensitive);
+  return { passed: count === step.args.expectCount, actualCount: count };
+}
+function executeCreateStep(editor, tr, step, targets, mapping) {
+  const target = targets[0];
+  if (!target) {
+    throw planError("INVALID_INPUT", `${step.op} step requires exactly one target`, step.id);
+  }
+  const args3 = step.args;
+  const pos = mapping.map(toAbsoluteBlockInsertPos(editor, target.blockId, target.from, step.id));
+  const paragraphType = editor.state.schema?.nodes?.paragraph;
+  if (!paragraphType) {
+    throw planError("INVALID_INPUT", "paragraph node type not in schema", step.id);
+  }
+  const sdBlockId = args3.sdBlockId;
+  const text4 = args3.text ?? "";
+  const textNode = text4.length > 0 ? editor.state.schema.text(text4) : null;
+  let attrs;
+  if (step.op === "create.heading") {
+    const level = args3.level ?? 1;
+    attrs = {
+      ...sdBlockId ? { sdBlockId } : undefined,
+      paragraphProperties: { styleId: `Heading${level}` }
+    };
+  } else {
+    attrs = sdBlockId ? { sdBlockId } : undefined;
+  }
+  const node3 = paragraphType.createAndFill(attrs, textNode ?? undefined) ?? paragraphType.create(attrs, textNode ? [textNode] : undefined);
+  if (!node3) {
+    throw planError("INVALID_INPUT", `could not create ${step.op} node`, step.id);
+  }
+  tr.insert(pos, node3);
+  return {
+    stepId: step.id,
+    op: step.op,
+    effect: "changed",
+    matchCount: 1,
+    data: { domain: "text", resolutions: [] }
+  };
+}
+function runMutationsOnTransaction(editor, tr, compiled, options) {
+  const mapping = tr.mapping;
+  const stepOutcomes = [];
+  const assertFailures = [];
+  const ctx2 = {
+    editor,
+    tr,
+    mapping,
+    changeMode: "direct",
+    planGroupId: "",
+    commandDispatched: false
+  };
+  for (const compiledStep of compiled.mutationSteps) {
+    const { step, targets } = compiledStep;
+    const executor = getStepExecutor(step.op);
+    if (!executor) {
+      throw planError("INVALID_INPUT", `unsupported step op "${step.op}"`, step.id);
+    }
+    const outcome = executor.execute(ctx2, targets, step);
+    stepOutcomes.push(outcome);
+  }
+  for (const assertStep of compiled.assertSteps) {
+    const { passed, actualCount } = executeAssertStep(editor, tr, assertStep);
+    if (!passed) {
+      if (options.throwOnAssertFailure) {
+        throw planError("PRECONDITION_FAILED", `assert "${assertStep.id}" expected ${assertStep.args.expectCount} matches but found ${actualCount}`, assertStep.id, { expectedCount: assertStep.args.expectCount, actualCount });
+      }
+      assertFailures.push({ stepId: assertStep.id, expectedCount: assertStep.args.expectCount, actualCount });
+    }
+    const data = {
+      domain: "assert",
+      expectedCount: assertStep.args.expectCount,
+      actualCount
+    };
+    stepOutcomes.push({
+      stepId: assertStep.id,
+      op: "assert",
+      effect: passed ? "assert_passed" : "assert_failed",
+      matchCount: actualCount,
+      data
+    });
+  }
+  return { stepOutcomes, assertFailures, commandDispatched: ctx2.commandDispatched };
+}
+function executeCompiledPlan(editor, compiled, options = {}) {
+  const startTime = performance.now();
+  const revisionBefore = getRevision(editor);
+  checkRevision(editor, options.expectedRevision);
+  const tr = editor.state.tr;
+  const changeMode = options.changeMode ?? "direct";
+  if (changeMode === "tracked") {
+    applyTrackedMutationMeta2(tr);
+  } else {
+    applyDirectMutationMeta2(tr);
+  }
+  const { stepOutcomes } = runMutationsOnTransaction(editor, tr, compiled, { throwOnAssertFailure: true });
+  if (tr.docChanged) {
+    editor.dispatch(tr);
+  }
+  const revisionAfter = getRevision(editor);
+  const totalMs = performance.now() - startTime;
+  return {
+    success: true,
+    revision: {
+      before: revisionBefore,
+      after: revisionAfter
+    },
+    steps: stepOutcomes,
+    timing: { totalMs }
+  };
+}
+function executePlan(editor, input2) {
+  if (!input2.steps?.length) {
+    throw planError("INVALID_INPUT", "plan must contain at least one step");
+  }
+  const compiled = compilePlan(editor, input2.steps);
+  return executeCompiledPlan(editor, compiled, {
+    changeMode: input2.changeMode ?? "direct",
+    expectedRevision: input2.expectedRevision
+  });
+}
+var DEFAULT_INLINE_POLICY;
+var init_executor = __esm(() => {
+  init_executor_registry();
+  init_errors4();
+  init_revision_tracker();
+  init_compiler();
+  init_index_cache();
+  init_style_resolver();
+  init_node_address_resolver();
+  init_adapter_utils();
+  DEFAULT_INLINE_POLICY = {
+    mode: "preserve",
+    onNonUniform: "majority"
+  };
+});
+
+// ../../packages/super-editor/src/document-api-adapters/helpers/text-mutation-resolution.ts
+function readTextAtResolvedRange2(editor, range) {
+  return editor.state.doc.textBetween(range.from, range.to, `
+`, OBJECT_REPLACEMENT_CHAR2);
+}
+function buildTextMutationResolution2(input2) {
+  return {
+    ...input2.requestedTarget ? { requestedTarget: input2.requestedTarget } : {},
+    target: input2.target,
+    range: { from: input2.range.from, to: input2.range.to },
+    text: input2.text
+  };
+}
+var OBJECT_REPLACEMENT_CHAR2 = "";
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/plan-wrappers.ts
+function normalizeWriteLocator2(request) {
+  if (request.kind === "insert") {
+    const hasBlockId = request.blockId !== undefined;
+    const hasOffset = request.offset !== undefined;
+    if (hasOffset && request.target) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with offset on insert request.", {
+        fields: ["target", "offset"]
+      });
+    }
+    if (hasOffset && !hasBlockId) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", "offset requires blockId on insert request.", {
+        fields: ["offset", "blockId"]
+      });
+    }
+    if (!hasBlockId)
+      return request;
+    if (request.target) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with blockId on insert request.", {
+        fields: ["target", "blockId"]
+      });
+    }
+    const effectiveOffset = request.offset ?? 0;
+    const target = {
+      kind: "text",
+      blockId: request.blockId,
+      range: { start: effectiveOffset, end: effectiveOffset }
+    };
+    return { kind: "insert", target, text: request.text };
+  }
+  if (request.kind === "replace" || request.kind === "delete") {
+    const hasBlockId = request.blockId !== undefined;
+    const hasStart = request.start !== undefined;
+    const hasEnd = request.end !== undefined;
+    if (request.target && (hasBlockId || hasStart || hasEnd)) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", `Cannot combine target with blockId/start/end on ${request.kind} request.`, { fields: ["target", "blockId", "start", "end"] });
+    }
+    if (!hasBlockId && (hasStart || hasEnd)) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", `start/end require blockId on ${request.kind} request.`, {
+        fields: ["blockId", "start", "end"]
+      });
+    }
+    if (!hasBlockId)
+      return request;
+    if (!hasStart || !hasEnd) {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", `blockId requires both start and end on ${request.kind} request.`, { fields: ["blockId", "start", "end"] });
+    }
+    const target = {
+      kind: "text",
+      blockId: request.blockId,
+      range: { start: request.start, end: request.end }
+    };
+    if (request.kind === "replace")
+      return { kind: "replace", target, text: request.text };
+    return { kind: "delete", target, text: "" };
+  }
+  return request;
+}
+function normalizeFormatLocator2(input2) {
+  const hasBlockId = input2.blockId !== undefined;
+  const hasStart = input2.start !== undefined;
+  const hasEnd = input2.end !== undefined;
+  if (input2.target && (hasBlockId || hasStart || hasEnd)) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with blockId/start/end on format request.", { fields: ["target", "blockId", "start", "end"] });
+  }
+  if (!hasBlockId && (hasStart || hasEnd)) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", "start/end require blockId on format request.", {
+      fields: ["blockId", "start", "end"]
+    });
+  }
+  if (!hasBlockId)
+    return input2;
+  if (!hasStart || !hasEnd) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", "blockId requires both start and end on format request.", {
+      fields: ["blockId", "start", "end"]
+    });
+  }
+  const target = {
+    kind: "text",
+    blockId: input2.blockId,
+    range: { start: input2.start, end: input2.end }
+  };
+  return { target };
+}
+function resolveWriteTarget2(editor, request) {
+  const requestedTarget = request.target;
+  if (request.kind === "insert" && !request.target) {
+    const fallback = resolveDefaultInsertTarget2(editor);
+    if (!fallback)
+      return null;
+    const text5 = readTextAtResolvedRange2(editor, fallback.range);
+    return {
+      requestedTarget,
+      effectiveTarget: fallback.target,
+      range: fallback.range,
+      resolution: buildTextMutationResolution2({
+        requestedTarget,
+        target: fallback.target,
+        range: fallback.range,
+        text: text5
+      })
+    };
+  }
+  const target = request.target;
+  if (!target)
+    return null;
+  const range = resolveTextTarget2(editor, target);
+  if (!range)
+    return null;
+  const text4 = readTextAtResolvedRange2(editor, range);
+  return {
+    requestedTarget,
+    effectiveTarget: target,
+    range,
+    resolution: buildTextMutationResolution2({ requestedTarget, target, range, text: text4 })
+  };
+}
+function mapPlanReceiptToTextReceipt(_receipt, resolution) {
+  return { success: true, resolution };
+}
+function toCompiledTarget(stepId, op, resolved) {
+  return {
+    stepId,
+    op,
+    blockId: resolved.effectiveTarget.blockId,
+    from: resolved.effectiveTarget.range.start,
+    to: resolved.effectiveTarget.range.end,
+    text: resolved.resolution.text,
+    marks: []
+  };
+}
+function executeDomainCommand(editor, handler2, options) {
+  const stepId = v42();
+  const step = {
+    id: stepId,
+    op: "domain.command",
+    where: STUB_WHERE,
+    args: {},
+    _handler: handler2
+  };
+  const compiled = { mutationSteps: [{ step, targets: [] }], assertSteps: [] };
+  return executeCompiledPlan(editor, compiled, { expectedRevision: options?.expectedRevision });
+}
+function validateWriteRequest2(request, resolved) {
+  if (request.kind === "insert") {
+    if (!request.text)
+      return { code: "INVALID_TARGET", message: "Insert operations require non-empty text." };
+    if (resolved.range.from !== resolved.range.to) {
+      return { code: "INVALID_TARGET", message: "Insert operations require a collapsed target range." };
+    }
+    return null;
+  }
+  if (request.kind === "replace") {
+    if (request.text == null || request.text.length === 0) {
+      return { code: "INVALID_TARGET", message: "Replace operations require non-empty text. Use delete for removals." };
+    }
+    if (resolved.resolution.text === request.text) {
+      return { code: "NO_OP", message: "Replace operation produced no change." };
+    }
+    return null;
+  }
+  if (resolved.range.from === resolved.range.to) {
+    return { code: "NO_OP", message: "Delete operation produced no change for a collapsed range." };
+  }
+  return null;
+}
+function writeWrapper(editor, request, options) {
+  const normalizedRequest = normalizeWriteLocator2(request);
+  const resolved = resolveWriteTarget2(editor, normalizedRequest);
+  if (!resolved) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Mutation target could not be resolved.", {
+      target: normalizedRequest.target
+    });
+  }
+  const validationFailure = validateWriteRequest2(normalizedRequest, resolved);
+  if (validationFailure) {
+    return { success: false, resolution: resolved.resolution, failure: validationFailure };
+  }
+  const mode = options?.changeMode ?? "direct";
+  if (mode === "tracked")
+    ensureTrackedCapability2(editor, { operation: "write" });
+  if (options?.dryRun) {
+    return { success: true, resolution: resolved.resolution };
+  }
+  const stepId = v42();
+  let op;
+  let stepDef;
+  if (normalizedRequest.kind === "insert") {
+    op = "text.insert";
+    stepDef = {
+      id: stepId,
+      op,
+      where: STUB_WHERE,
+      args: { position: "before", content: { text: normalizedRequest.text ?? "" } }
+    };
+  } else if (normalizedRequest.kind === "replace") {
+    op = "text.rewrite";
+    stepDef = {
+      id: stepId,
+      op,
+      where: STUB_WHERE,
+      args: { replacement: { text: normalizedRequest.text ?? "" }, style: { inline: { mode: "preserve" } } }
+    };
+  } else {
+    op = "text.delete";
+    stepDef = {
+      id: stepId,
+      op,
+      where: STUB_WHERE,
+      args: {}
+    };
+  }
+  const step = stepDef;
+  const target = toCompiledTarget(stepId, op, resolved);
+  const compiled = {
+    mutationSteps: [{ step, targets: [target] }],
+    assertSteps: []
+  };
+  const receipt2 = executeCompiledPlan(editor, compiled, {
+    changeMode: mode,
+    expectedRevision: options?.expectedRevision
+  });
+  return mapPlanReceiptToTextReceipt(receipt2, resolved.resolution);
+}
+function formatMarkWrapper(editor, markName, operationId, input2, options) {
+  const normalizedInput = normalizeFormatLocator2(input2);
+  const range = resolveTextTarget2(editor, normalizedInput.target);
+  if (!range) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Format target could not be resolved.", {
+      target: normalizedInput.target
+    });
+  }
+  const resolution = buildTextMutationResolution2({
+    requestedTarget: input2.target,
+    target: normalizedInput.target,
+    range,
+    text: readTextAtResolvedRange2(editor, range)
+  });
+  if (range.from === range.to) {
+    const label = FORMAT_OPERATION_LABEL2[operationId];
+    return {
+      success: false,
+      resolution,
+      failure: { code: "INVALID_TARGET", message: `${label} formatting requires a non-collapsed target range.` }
+    };
+  }
+  requireSchemaMark2(editor, markName, operationId);
+  const mode = options?.changeMode ?? "direct";
+  if (mode === "tracked") {
+    ensureTrackedCapability2(editor, { operation: operationId, requireMarks: [TrackFormatMarkName2] });
+  }
+  if (options?.dryRun) {
+    return { success: true, resolution };
+  }
+  const stepId = v42();
+  const marks = {};
+  if (markName === "bold")
+    marks.bold = true;
+  else if (markName === "italic")
+    marks.italic = true;
+  else if (markName === "underline")
+    marks.underline = true;
+  else if (markName === "strike")
+    marks.strike = true;
+  const step = {
+    id: stepId,
+    op: "style.apply",
+    where: STUB_WHERE,
+    args: { marks }
+  };
+  const target = {
+    stepId,
+    op: "style.apply",
+    blockId: normalizedInput.target.blockId,
+    from: normalizedInput.target.range.start,
+    to: normalizedInput.target.range.end,
+    text: resolution.text,
+    marks: []
+  };
+  const compiled = {
+    mutationSteps: [{ step, targets: [target] }],
+    assertSteps: []
+  };
+  const receipt2 = executeCompiledPlan(editor, compiled, {
+    changeMode: mode,
+    expectedRevision: options?.expectedRevision
+  });
+  return mapPlanReceiptToTextReceipt(receipt2, resolution);
+}
+function formatBoldWrapper(editor, input2, options) {
+  return formatMarkWrapper(editor, "bold", "format.bold", input2, options);
+}
+function formatItalicWrapper(editor, input2, options) {
+  return formatMarkWrapper(editor, "italic", "format.italic", input2, options);
+}
+function formatUnderlineWrapper(editor, input2, options) {
+  return formatMarkWrapper(editor, "underline", "format.underline", input2, options);
+}
+function formatStrikethroughWrapper(editor, input2, options) {
+  return formatMarkWrapper(editor, "strike", "format.strikethrough", input2, options);
+}
+var STUB_WHERE, FORMAT_OPERATION_LABEL2;
+var init_plan_wrappers = __esm(() => {
+  init_wrapper();
+  init_executor();
+  init_errors3();
+  init_adapter_utils();
+  init_mutation_helpers();
+  STUB_WHERE = {
+    by: "select",
+    select: { type: "text", pattern: "", mode: "exact" },
+    require: "exactlyOne"
+  };
+  FORMAT_OPERATION_LABEL2 = {
+    "format.bold": "Bold",
+    "format.italic": "Italic",
+    "format.underline": "Underline",
+    "format.strikethrough": "Strikethrough"
+  };
+});
+
 // ../../packages/super-editor/src/document-api-adapters/helpers/comment-entity-store.ts
 function ensureFallbackStore2(editor) {
   if (!editor.storage) {
@@ -194693,7 +196504,7 @@ function resolveImportedId2(candidate) {
   const attrs = candidate.attrs ?? {};
   return toNonEmptyString2(attrs.importedId);
 }
-function toTextAddress2(candidate) {
+function toTextAddress3(candidate) {
   const { start: start2, end } = candidate.anchor;
   if (start2.blockId !== end.blockId)
     return null;
@@ -194715,7 +196526,7 @@ function listCommentAnchors2(editor) {
     const commentId = resolveCommentId2(candidate);
     if (!commentId)
       continue;
-    const target = toTextAddress2(candidate);
+    const target = toTextAddress3(candidate);
     if (!target)
       continue;
     const dedupeKey = `${commentId}|${target.blockId}:${target.range.start}:${target.range.end}`;
@@ -194745,7 +196556,7 @@ var init_comment_target_resolver = __esm(() => {
   init_index_cache();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/comments-adapter.ts
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/comments-wrappers.ts
 function toCommentAddress2(commentId) {
   return {
     kind: "entity",
@@ -194872,7 +196683,7 @@ function buildCommentInfos2(editor) {
   });
   return infos;
 }
-function addCommentHandler2(editor, input2) {
+function addCommentHandler2(editor, input2, options) {
   requireEditorCommand2(editor.commands?.addComment, "comments.add (addComment)");
   if (input2.target.range.start === input2.target.range.end) {
     return {
@@ -194898,7 +196709,6 @@ function addCommentHandler2(editor, input2) {
       }
     };
   }
-  const commentId = v42();
   if (!applyTextSelection2(editor, resolved.from, resolved.to)) {
     return {
       success: false,
@@ -194909,45 +196719,41 @@ function addCommentHandler2(editor, input2) {
       }
     };
   }
-  const addComment = requireEditorCommand2(editor.commands?.addComment, "comments.add (addComment)");
-  const didInsert = addComment({
-    content: input2.text,
-    isInternal: false,
-    commentId
-  }) === true;
-  if (!didInsert) {
+  const commentId = v42();
+  const receipt2 = executeDomainCommand(editor, () => {
+    const addComment = requireEditorCommand2(editor.commands?.addComment, "comments.add (addComment)");
+    const didInsert = addComment({ content: input2.text, isInternal: false, commentId }) === true;
+    if (didInsert) {
+      clearIndexCache2(editor);
+      const store = getCommentEntityStore2(editor);
+      const now = Date.now();
+      const user = editor.options?.user ?? {};
+      upsertCommentEntity2(store, commentId, {
+        commentId,
+        commentText: input2.text,
+        commentJSON: buildCommentJsonFromText2(input2.text),
+        parentCommentId: undefined,
+        createdTime: now,
+        creatorName: user.name,
+        creatorEmail: user.email,
+        creatorImage: user.image,
+        isDone: false,
+        isInternal: false,
+        fileId: editor.options?.documentId,
+        documentId: editor.options?.documentId
+      });
+    }
+    return didInsert;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment insertion produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment insertion produced no change." }
     };
   }
-  clearIndexCache2(editor);
-  const store = getCommentEntityStore2(editor);
-  const now = Date.now();
-  const user = editor.options?.user ?? {};
-  upsertCommentEntity2(store, commentId, {
-    commentId,
-    commentText: input2.text,
-    commentJSON: buildCommentJsonFromText2(input2.text),
-    parentCommentId: undefined,
-    createdTime: now,
-    creatorName: user.name,
-    creatorEmail: user.email,
-    creatorImage: user.image,
-    isDone: false,
-    isInternal: false,
-    fileId: editor.options?.documentId,
-    documentId: editor.options?.documentId
-  });
-  return {
-    success: true,
-    inserted: [toCommentAddress2(commentId)]
-  };
+  return { success: true, inserted: [toCommentAddress2(commentId)] };
 }
-function editCommentHandler2(editor, input2) {
+function editCommentHandler2(editor, input2, options) {
   const editComment = requireEditorCommand2(editor.commands?.editComment, "comments.edit (editComment)");
   const store = getCommentEntityStore2(editor);
   const identity2 = resolveCommentIdentity2(editor, input2.commentId);
@@ -194956,37 +196762,33 @@ function editCommentHandler2(editor, input2) {
   if (existingText === input2.text) {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment edit produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment edit produced no change." }
     };
   }
-  const didEdit = editComment({
-    commentId: identity2.commentId,
-    importedId: identity2.importedId,
-    content: input2.text
-  });
-  if (!didEdit) {
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didEdit = editComment({
+      commentId: identity2.commentId,
+      importedId: identity2.importedId,
+      content: input2.text
+    });
+    if (didEdit) {
+      upsertCommentEntity2(store, identity2.commentId, {
+        commentText: input2.text,
+        commentJSON: buildCommentJsonFromText2(input2.text),
+        importedId: identity2.importedId
+      });
+    }
+    return Boolean(didEdit);
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment edit produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment edit produced no change." }
     };
   }
-  upsertCommentEntity2(store, identity2.commentId, {
-    commentText: input2.text,
-    commentJSON: buildCommentJsonFromText2(input2.text),
-    importedId: identity2.importedId
-  });
-  return {
-    success: true,
-    updated: [toCommentAddress2(identity2.commentId)]
-  };
+  return { success: true, updated: [toCommentAddress2(identity2.commentId)] };
 }
-function replyToCommentHandler2(editor, input2) {
+function replyToCommentHandler2(editor, input2, options) {
   const addCommentReply = requireEditorCommand2(editor.commands?.addCommentReply, "comments.reply (addCommentReply)");
   if (!input2.parentCommentId) {
     return {
@@ -194999,51 +196801,47 @@ function replyToCommentHandler2(editor, input2) {
   }
   const parentIdentity = resolveCommentIdentity2(editor, input2.parentCommentId);
   const replyId = v42();
-  const didReply = addCommentReply({
-    parentId: parentIdentity.commentId,
-    content: input2.text,
-    commentId: replyId
-  });
-  if (!didReply) {
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didReply = addCommentReply({
+      parentId: parentIdentity.commentId,
+      content: input2.text,
+      commentId: replyId
+    });
+    if (didReply) {
+      const now = Date.now();
+      const user = editor.options?.user ?? {};
+      const store = getCommentEntityStore2(editor);
+      upsertCommentEntity2(store, replyId, {
+        commentId: replyId,
+        parentCommentId: parentIdentity.commentId,
+        commentText: input2.text,
+        commentJSON: buildCommentJsonFromText2(input2.text),
+        createdTime: now,
+        creatorName: user.name,
+        creatorEmail: user.email,
+        creatorImage: user.image,
+        isDone: false,
+        isInternal: false,
+        fileId: editor.options?.documentId,
+        documentId: editor.options?.documentId
+      });
+    }
+    return Boolean(didReply);
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "INVALID_TARGET",
-        message: "Comment reply could not be applied."
-      }
+      failure: { code: "INVALID_TARGET", message: "Comment reply could not be applied." }
     };
   }
-  const now = Date.now();
-  const user = editor.options?.user ?? {};
-  const store = getCommentEntityStore2(editor);
-  upsertCommentEntity2(store, replyId, {
-    commentId: replyId,
-    parentCommentId: parentIdentity.commentId,
-    commentText: input2.text,
-    commentJSON: buildCommentJsonFromText2(input2.text),
-    createdTime: now,
-    creatorName: user.name,
-    creatorEmail: user.email,
-    creatorImage: user.image,
-    isDone: false,
-    isInternal: false,
-    fileId: editor.options?.documentId,
-    documentId: editor.options?.documentId
-  });
-  return {
-    success: true,
-    inserted: [toCommentAddress2(replyId)]
-  };
+  return { success: true, inserted: [toCommentAddress2(replyId)] };
 }
-function moveCommentHandler2(editor, input2) {
+function moveCommentHandler2(editor, input2, options) {
   const moveComment = requireEditorCommand2(editor.commands?.moveComment, "comments.move (moveComment)");
   if (input2.target.range.start === input2.target.range.end) {
     return {
       success: false,
-      failure: {
-        code: "INVALID_TARGET",
-        message: "Comment target range must be non-collapsed."
-      }
+      failure: { code: "INVALID_TARGET", message: "Comment target range must be non-collapsed." }
     };
   }
   const resolved = resolveTextTarget2(editor, input2.target);
@@ -195053,20 +196851,14 @@ function moveCommentHandler2(editor, input2) {
   if (resolved.from === resolved.to) {
     return {
       success: false,
-      failure: {
-        code: "INVALID_TARGET",
-        message: "Comment target range must be non-collapsed."
-      }
+      failure: { code: "INVALID_TARGET", message: "Comment target range must be non-collapsed." }
     };
   }
   const identity2 = resolveCommentIdentity2(editor, input2.commentId);
   if (!identity2.anchors.length) {
     return {
       success: false,
-      failure: {
-        code: "INVALID_TARGET",
-        message: "Comment cannot be moved because it has no resolvable anchor."
-      }
+      failure: { code: "INVALID_TARGET", message: "Comment cannot be moved because it has no resolvable anchor." }
     };
   }
   if (identity2.anchors.length > 1) {
@@ -195082,32 +196874,19 @@ function moveCommentHandler2(editor, input2) {
   if (currentTarget && isSameTarget2(currentTarget, input2.target)) {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment move produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment move produced no change." }
     };
   }
-  const didMove = moveComment({
-    commentId: identity2.commentId,
-    from: resolved.from,
-    to: resolved.to
-  });
-  if (!didMove) {
+  const receipt2 = executeDomainCommand(editor, () => Boolean(moveComment({ commentId: identity2.commentId, from: resolved.from, to: resolved.to })), { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment move produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment move produced no change." }
     };
   }
-  return {
-    success: true,
-    updated: [toCommentAddress2(identity2.commentId)]
-  };
+  return { success: true, updated: [toCommentAddress2(identity2.commentId)] };
 }
-function resolveCommentHandler2(editor, input2) {
+function resolveCommentHandler2(editor, input2, options) {
   const resolveComment = requireEditorCommand2(editor.commands?.resolveComment, "comments.resolve (resolveComment)");
   const store = getCommentEntityStore2(editor);
   const identity2 = resolveCommentIdentity2(editor, input2.commentId);
@@ -195116,51 +196895,46 @@ function resolveCommentHandler2(editor, input2) {
   if (alreadyResolved) {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment is already resolved."
-      }
+      failure: { code: "NO_OP", message: "Comment is already resolved." }
     };
   }
-  const didResolve = resolveComment({
-    commentId: identity2.commentId,
-    importedId: identity2.importedId
-  });
-  if (!didResolve) {
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didResolve = resolveComment({
+      commentId: identity2.commentId,
+      importedId: identity2.importedId
+    });
+    if (didResolve) {
+      upsertCommentEntity2(store, identity2.commentId, {
+        importedId: identity2.importedId,
+        isDone: true,
+        resolvedTime: Date.now()
+      });
+    }
+    return Boolean(didResolve);
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment resolve produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment resolve produced no change." }
     };
   }
-  upsertCommentEntity2(store, identity2.commentId, {
-    importedId: identity2.importedId,
-    isDone: true,
-    resolvedTime: Date.now()
-  });
-  return {
-    success: true,
-    updated: [toCommentAddress2(identity2.commentId)]
-  };
+  return { success: true, updated: [toCommentAddress2(identity2.commentId)] };
 }
-function removeCommentHandler2(editor, input2) {
+function removeCommentHandler2(editor, input2, options) {
   const removeComment = requireEditorCommand2(editor.commands?.removeComment, "comments.remove (removeComment)");
   const store = getCommentEntityStore2(editor);
   const identity2 = resolveCommentIdentity2(editor, input2.commentId);
-  const didRemove = removeComment({
-    commentId: identity2.commentId,
-    importedId: identity2.importedId
-  }) === true;
-  const removedRecords = removeCommentEntityTree2(store, identity2.commentId);
-  if (!didRemove && removedRecords.length === 0) {
+  let didRemove = false;
+  let removedRecords = [];
+  const receipt2 = executeDomainCommand(editor, () => {
+    didRemove = removeComment({ commentId: identity2.commentId, importedId: identity2.importedId }) === true;
+    removedRecords = removeCommentEntityTree2(store, identity2.commentId);
+    return didRemove || removedRecords.length > 0;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment remove produced no change."
-      }
+      failure: { code: "NO_OP", message: "Comment remove produced no change." }
     };
   }
   const removedIds = new Set;
@@ -195178,7 +196952,7 @@ function removeCommentHandler2(editor, input2) {
     removed: Array.from(removedIds).map((id2) => toCommentAddress2(id2))
   };
 }
-function setCommentInternalHandler2(editor, input2) {
+function setCommentInternalHandler2(editor, input2, options) {
   const setCommentInternal = requireEditorCommand2(editor.commands?.setCommentInternal, "comments.setInternal (setCommentInternal)");
   const store = getCommentEntityStore2(editor);
   const identity2 = resolveCommentIdentity2(editor, input2.commentId);
@@ -195187,46 +196961,47 @@ function setCommentInternalHandler2(editor, input2) {
   if (typeof currentInternal === "boolean" && currentInternal === input2.isInternal) {
     return {
       success: false,
-      failure: {
-        code: "NO_OP",
-        message: "Comment internal state is already set to the requested value."
-      }
+      failure: { code: "NO_OP", message: "Comment internal state is already set to the requested value." }
     };
   }
   const hasOpenAnchor = identity2.anchors.some((anchor) => anchor.status === "open");
-  if (hasOpenAnchor) {
-    const didApply = setCommentInternal({
-      commentId: identity2.commentId,
+  const receipt2 = executeDomainCommand(editor, () => {
+    if (hasOpenAnchor) {
+      const didApply = setCommentInternal({
+        commentId: identity2.commentId,
+        importedId: identity2.importedId,
+        isInternal: input2.isInternal
+      });
+      if (!didApply)
+        return false;
+    }
+    upsertCommentEntity2(store, identity2.commentId, {
       importedId: identity2.importedId,
       isInternal: input2.isInternal
     });
-    if (!didApply) {
-      return {
-        success: false,
-        failure: {
-          code: "INVALID_TARGET",
-          message: "Comment internal state could not be updated on the current anchor."
-        }
-      };
-    }
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return {
+      success: false,
+      failure: {
+        code: "INVALID_TARGET",
+        message: "Comment internal state could not be updated on the current anchor."
+      }
+    };
   }
-  upsertCommentEntity2(store, identity2.commentId, {
-    importedId: identity2.importedId,
-    isInternal: input2.isInternal
-  });
-  return {
-    success: true,
-    updated: [toCommentAddress2(identity2.commentId)]
-  };
+  return { success: true, updated: [toCommentAddress2(identity2.commentId)] };
 }
-function setCommentActiveHandler2(editor, input2) {
+function setCommentActiveHandler2(editor, input2, options) {
   const setActiveComment = requireEditorCommand2(editor.commands?.setActiveComment, "comments.setActive (setActiveComment)");
   let resolvedCommentId = null;
   if (input2.commentId != null) {
     resolvedCommentId = resolveCommentIdentity2(editor, input2.commentId).commentId;
   }
-  const didSet = setActiveComment({ commentId: resolvedCommentId });
-  if (!didSet) {
+  const receipt2 = executeDomainCommand(editor, () => Boolean(setActiveComment({ commentId: resolvedCommentId })), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
       failure: {
@@ -195272,28 +197047,29 @@ function listCommentsHandler2(editor, query2) {
     total: matches3.length
   };
 }
-function createCommentsAdapter2(editor) {
+function createCommentsWrapper(editor) {
   return {
-    add: (input2) => addCommentHandler2(editor, input2),
-    edit: (input2) => editCommentHandler2(editor, input2),
-    reply: (input2) => replyToCommentHandler2(editor, input2),
-    move: (input2) => moveCommentHandler2(editor, input2),
-    resolve: (input2) => resolveCommentHandler2(editor, input2),
-    remove: (input2) => removeCommentHandler2(editor, input2),
-    setInternal: (input2) => setCommentInternalHandler2(editor, input2),
-    setActive: (input2) => setCommentActiveHandler2(editor, input2),
+    add: (input2, options) => addCommentHandler2(editor, input2, options),
+    edit: (input2, options) => editCommentHandler2(editor, input2, options),
+    reply: (input2, options) => replyToCommentHandler2(editor, input2, options),
+    move: (input2, options) => moveCommentHandler2(editor, input2, options),
+    resolve: (input2, options) => resolveCommentHandler2(editor, input2, options),
+    remove: (input2, options) => removeCommentHandler2(editor, input2, options),
+    setInternal: (input2, options) => setCommentInternalHandler2(editor, input2, options),
+    setActive: (input2, options) => setCommentActiveHandler2(editor, input2, options),
     goTo: (input2) => goToCommentHandler2(editor, input2),
     get: (input2) => getCommentHandler2(editor, input2),
     list: (query2) => listCommentsHandler2(editor, query2)
   };
 }
-var init_comments_adapter = __esm(() => {
+var init_comments_wrappers = __esm(() => {
   init_dist4();
   init_wrapper();
   init_errors3();
   init_mutation_helpers();
   init_index_cache();
   init_adapter_utils();
+  init_plan_wrappers();
   init_comment_target_resolver();
 });
 
@@ -195443,10 +197219,6 @@ function resolveTrackedChange2(editor, id2) {
   const grouped = groupTrackedChanges2(editor);
   return grouped.find((item) => item.id === id2) ?? null;
 }
-function toCanonicalTrackedChangeId2(editor, rawId) {
-  const grouped = groupTrackedChanges2(editor);
-  return grouped.find((item) => item.rawId === rawId)?.id ?? null;
-}
 function buildTrackedChangeCanonicalIdMap2(editor) {
   const grouped = groupTrackedChanges2(editor);
   const map6 = new Map;
@@ -195490,9 +197262,9 @@ var init_tracked_change_refs = __esm(() => {
   init_tracked_change_resolver();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/create-adapter.ts
-function resolveParagraphInsertPosition2(editor, input2) {
-  const location3 = input2.at ?? { kind: "documentEnd" };
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/create-wrappers.ts
+function resolveCreateInsertPosition(editor, at, operationLabel) {
+  const location3 = at ?? { kind: "documentEnd" };
   if (location3.kind === "documentStart")
     return 0;
   if (location3.kind === "documentEnd")
@@ -195501,30 +197273,30 @@ function resolveParagraphInsertPosition2(editor, input2) {
   const hasTarget = "target" in location3 && location3.target != null;
   const target = hasTarget ? findBlockById2(index2, location3.target) : findBlockByNodeIdOnly2(index2, location3.nodeId);
   if (!target) {
-    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Create paragraph target block was not found.", {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", `Create ${operationLabel} target block was not found.`, {
       target: hasTarget ? location3.target : location3.nodeId
     });
   }
   return location3.kind === "before" ? target.pos : target.end;
 }
-function resolveCreatedParagraph2(editor, paragraphId) {
+function resolveCreatedBlock(editor, nodeType, blockId) {
   const index2 = getBlockIndex2(editor);
-  const resolved = index2.byId.get(`paragraph:${paragraphId}`);
+  const resolved = index2.byId.get(`${nodeType}:${blockId}`);
   if (resolved)
     return resolved;
   const bySdBlockId = index2.candidates.find((candidate) => {
-    if (candidate.nodeType !== "paragraph")
+    if (candidate.nodeType !== nodeType)
       return false;
     const attrs = candidate.node.attrs;
-    return typeof attrs?.sdBlockId === "string" && attrs.sdBlockId === paragraphId;
+    return typeof attrs?.sdBlockId === "string" && attrs.sdBlockId === blockId;
   });
   if (bySdBlockId)
     return bySdBlockId;
-  const fallback = index2.candidates.find((candidate) => candidate.nodeType === "paragraph" && candidate.nodeId === paragraphId);
+  const fallback = index2.candidates.find((candidate) => candidate.nodeType === nodeType && candidate.nodeId === blockId);
   if (fallback)
     return fallback;
-  throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Created paragraph could not be resolved after insertion.", {
-    paragraphId
+  throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", `Created ${nodeType} could not be resolved after insertion.`, {
+    [`${nodeType}Id`]: blockId
   });
 }
 function buildParagraphCreateSuccess2(paragraphNodeId, trackedChangeRefs) {
@@ -195543,13 +197315,29 @@ function buildParagraphCreateSuccess2(paragraphNodeId, trackedChangeRefs) {
     trackedChangeRefs
   };
 }
-function createParagraphAdapter2(editor, input2, options) {
+function buildHeadingCreateSuccess2(headingNodeId, trackedChangeRefs) {
+  return {
+    success: true,
+    heading: {
+      kind: "block",
+      nodeType: "heading",
+      nodeId: headingNodeId
+    },
+    insertionPoint: {
+      kind: "text",
+      blockId: headingNodeId,
+      range: { start: 0, end: 0 }
+    },
+    trackedChangeRefs
+  };
+}
+function createParagraphWrapper(editor, input2, options) {
   const insertParagraphAt2 = requireEditorCommand2(editor.commands?.insertParagraphAt, "create.paragraph");
   const mode = options?.changeMode ?? "direct";
   if (mode === "tracked") {
     ensureTrackedCapability2(editor, { operation: "create.paragraph" });
   }
-  const insertAt = resolveParagraphInsertPosition2(editor, input2);
+  const insertAt = resolveCreateInsertPosition(editor, input2.at, "paragraph");
   if (options?.dryRun) {
     const canInsert = editor.can().insertParagraphAt?.({
       pos: insertAt,
@@ -195580,13 +197368,26 @@ function createParagraphAdapter2(editor, input2, options) {
     };
   }
   const paragraphId = v42();
-  const didApply = insertParagraphAt2({
-    pos: insertAt,
-    text: input2.text,
-    sdBlockId: paragraphId,
-    tracked: mode === "tracked"
-  });
-  if (!didApply) {
+  let trackedChangeRefs;
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didApply = insertParagraphAt2({
+      pos: insertAt,
+      text: input2.text,
+      sdBlockId: paragraphId,
+      tracked: mode === "tracked"
+    });
+    if (didApply) {
+      clearIndexCache2(editor);
+      try {
+        const paragraph2 = resolveCreatedBlock(editor, "paragraph", paragraphId);
+        if (mode === "tracked") {
+          trackedChangeRefs = collectTrackInsertRefsInRange2(editor, paragraph2.pos, paragraph2.end);
+        }
+      } catch {}
+    }
+    return didApply;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
       failure: {
@@ -195595,74 +197396,15 @@ function createParagraphAdapter2(editor, input2, options) {
       }
     };
   }
-  clearIndexCache2(editor);
-  try {
-    const paragraph2 = resolveCreatedParagraph2(editor, paragraphId);
-    const trackedChangeRefs = mode === "tracked" ? collectTrackInsertRefsInRange2(editor, paragraph2.pos, paragraph2.end) : undefined;
-    return buildParagraphCreateSuccess2(paragraphId, trackedChangeRefs);
-  } catch {
-    return buildParagraphCreateSuccess2(paragraphId);
-  }
-}
-function resolveHeadingInsertPosition2(editor, input2) {
-  const location3 = input2.at ?? { kind: "documentEnd" };
-  if (location3.kind === "documentStart")
-    return 0;
-  if (location3.kind === "documentEnd")
-    return editor.state.doc.content.size;
-  const index2 = getBlockIndex2(editor);
-  const hasTarget = "target" in location3 && location3.target != null;
-  const target = hasTarget ? findBlockById2(index2, location3.target) : findBlockByNodeIdOnly2(index2, location3.nodeId);
-  if (!target) {
-    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Create heading target block was not found.", {
-      target: hasTarget ? location3.target : location3.nodeId
-    });
-  }
-  return location3.kind === "before" ? target.pos : target.end;
-}
-function resolveCreatedHeading2(editor, headingId) {
-  const index2 = getBlockIndex2(editor);
-  const resolved = index2.byId.get(`heading:${headingId}`);
-  if (resolved)
-    return resolved;
-  const bySdBlockId = index2.candidates.find((candidate) => {
-    if (candidate.nodeType !== "heading")
-      return false;
-    const attrs = candidate.node.attrs;
-    return typeof attrs?.sdBlockId === "string" && attrs.sdBlockId === headingId;
-  });
-  if (bySdBlockId)
-    return bySdBlockId;
-  const fallback = index2.candidates.find((candidate) => candidate.nodeType === "heading" && candidate.nodeId === headingId);
-  if (fallback)
-    return fallback;
-  throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Created heading could not be resolved after insertion.", {
-    headingId
-  });
+  return buildParagraphCreateSuccess2(paragraphId, trackedChangeRefs);
 }
-function buildHeadingCreateSuccess2(headingNodeId, trackedChangeRefs) {
-  return {
-    success: true,
-    heading: {
-      kind: "block",
-      nodeType: "heading",
-      nodeId: headingNodeId
-    },
-    insertionPoint: {
-      kind: "text",
-      blockId: headingNodeId,
-      range: { start: 0, end: 0 }
-    },
-    trackedChangeRefs
-  };
-}
-function createHeadingAdapter2(editor, input2, options) {
+function createHeadingWrapper(editor, input2, options) {
   const insertHeadingAt2 = requireEditorCommand2(editor.commands?.insertHeadingAt, "create.heading");
   const mode = options?.changeMode ?? "direct";
   if (mode === "tracked") {
     ensureTrackedCapability2(editor, { operation: "create.heading" });
   }
-  const insertAt = resolveHeadingInsertPosition2(editor, input2);
+  const insertAt = resolveCreateInsertPosition(editor, input2.at, "heading");
   if (options?.dryRun) {
     const canInsert = editor.can().insertHeadingAt?.({
       pos: insertAt,
@@ -195694,14 +197436,27 @@ function createHeadingAdapter2(editor, input2, options) {
     };
   }
   const headingId = v42();
-  const didApply = insertHeadingAt2({
-    pos: insertAt,
-    level: input2.level,
-    text: input2.text,
-    sdBlockId: headingId,
-    tracked: mode === "tracked"
-  });
-  if (!didApply) {
+  let trackedChangeRefs;
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didApply = insertHeadingAt2({
+      pos: insertAt,
+      level: input2.level,
+      text: input2.text,
+      sdBlockId: headingId,
+      tracked: mode === "tracked"
+    });
+    if (didApply) {
+      clearIndexCache2(editor);
+      try {
+        const heading3 = resolveCreatedBlock(editor, "heading", headingId);
+        if (mode === "tracked") {
+          trackedChangeRefs = collectTrackInsertRefsInRange2(editor, heading3.pos, heading3.end);
+        }
+      } catch {}
+    }
+    return didApply;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return {
       success: false,
       failure: {
@@ -195710,22 +197465,16 @@ function createHeadingAdapter2(editor, input2, options) {
       }
     };
   }
-  clearIndexCache2(editor);
-  try {
-    const heading3 = resolveCreatedHeading2(editor, headingId);
-    const trackedChangeRefs = mode === "tracked" ? collectTrackInsertRefsInRange2(editor, heading3.pos, heading3.end) : undefined;
-    return buildHeadingCreateSuccess2(headingId, trackedChangeRefs);
-  } catch {
-    return buildHeadingCreateSuccess2(headingId);
-  }
+  return buildHeadingCreateSuccess2(headingId, trackedChangeRefs);
 }
-var init_create_adapter = __esm(() => {
+var init_create_wrappers = __esm(() => {
   init_wrapper();
   init_index_cache();
   init_node_address_resolver();
   init_tracked_change_refs();
   init_errors3();
   init_mutation_helpers();
+  init_plan_wrappers();
 });
 
 // ../../packages/super-editor/src/document-api-adapters/helpers/node-info-mapper.ts
@@ -196181,174 +197930,6 @@ var init_node_info_resolver = __esm(() => {
   init_node_info_mapper();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/find/common.ts
-function resolveUnknownBlockId2(attrs) {
-  if (!attrs)
-    return;
-  return toId2(attrs.sdBlockId) ?? toId2(attrs.paraId) ?? toId2(attrs.blockId) ?? toId2(attrs.id) ?? toId2(attrs.uuid);
-}
-function isDualKindType2(nodeType) {
-  return Boolean(nodeType && DUAL_KIND_TYPES2.has(nodeType));
-}
-function getAddressStartPos2(editor, index2, address2) {
-  if (address2.kind === "block") {
-    const block = findBlockById2(index2, address2);
-    return block?.pos ?? Number.MAX_SAFE_INTEGER;
-  }
-  const inlineIndex = getInlineIndex2(editor);
-  const inline = findInlineByAnchor2(inlineIndex, address2);
-  return inline?.pos ?? Number.MAX_SAFE_INTEGER;
-}
-function buildTextContext2(editor, address2, matchFrom, matchTo, textRanges) {
-  const docSize = editor.state.doc.content.size;
-  const snippetFrom = Math.max(0, matchFrom - SNIPPET_PADDING2);
-  const snippetTo = Math.min(docSize, matchTo + SNIPPET_PADDING2);
-  const rawSnippet = editor.state.doc.textBetween(snippetFrom, snippetTo, " ");
-  const snippet = rawSnippet.replace(/ {2,}/g, " ");
-  const rawPrefix = editor.state.doc.textBetween(snippetFrom, matchFrom, " ");
-  const rawMatch = editor.state.doc.textBetween(matchFrom, matchTo, " ");
-  const prefix3 = rawPrefix.replace(/ {2,}/g, " ");
-  const matchNormalized = rawMatch.replace(/ {2,}/g, " ");
-  return {
-    address: address2,
-    snippet,
-    highlightRange: {
-      start: prefix3.length,
-      end: prefix3.length + matchNormalized.length
-    },
-    textRanges: textRanges?.length ? textRanges : undefined
-  };
-}
-function toTextAddress3(editor, block, range) {
-  const blockStart = block.pos + 1;
-  const blockEnd = block.end - 1;
-  if (range.from < blockStart || range.to > blockEnd)
-    return;
-  const start2 = editor.state.doc.textBetween(blockStart, range.from, `
-`, "").length;
-  const end = editor.state.doc.textBetween(blockStart, range.to, `
-`, "").length;
-  return {
-    kind: "text",
-    blockId: block.nodeId,
-    range: { start: start2, end }
-  };
-}
-function shouldQueryBothKinds2(select2) {
-  if (select2.type === "node") {
-    return !select2.kind && isDualKindType2(select2.nodeType);
-  }
-  return false;
-}
-function sortAddressesByPosition2(editor, index2, addresses) {
-  return [...addresses].sort((a2, b3) => {
-    const aPos = getAddressStartPos2(editor, index2, a2);
-    const bPos = getAddressStartPos2(editor, index2, b3);
-    if (aPos !== bPos)
-      return aPos - bPos;
-    if (a2.kind === b3.kind)
-      return 0;
-    return a2.kind === "block" ? -1 : 1;
-  });
-}
-function collectUnknownNodeDiagnostics2(editor, index2, diagnostics) {
-  editor.state.doc.descendants((node3, pos) => {
-    if (node3.isBlock && !KNOWN_BLOCK_PM_NODE_TYPES2.has(node3.type.name)) {
-      const blockId = resolveUnknownBlockId2(node3.attrs ?? {});
-      diagnostics.push({
-        message: `Unknown block node type "${node3.type.name}" is not part of the stable Document API match set.`,
-        hint: blockId ? `Skipped unknown block with stable id "${blockId}".` : "Skipped unknown block with no stable id available."
-      });
-      return;
-    }
-    if (node3.isInline && !KNOWN_INLINE_PM_NODE_TYPES2.has(node3.type.name)) {
-      const container = findCandidateByPos2(index2.candidates, pos);
-      diagnostics.push({
-        message: `Unknown inline node type "${node3.type.name}" is not part of the stable Document API match set.`,
-        address: container ? toBlockAddress2(container) : undefined,
-        hint: container ? `Skipped unknown inline node inside block "${container.nodeType}" with id "${container.nodeId}".` : "Skipped unknown inline node outside resolvable block scope."
-      });
-    }
-  });
-}
-function isInlineQuery2(select2) {
-  if (select2.type === "node") {
-    if (select2.kind)
-      return select2.kind === "inline";
-    return Boolean(select2.nodeType && isInlineQueryType2(select2.nodeType));
-  }
-  return false;
-}
-var SNIPPET_PADDING2 = 30, DUAL_KIND_TYPES2, KNOWN_BLOCK_PM_NODE_TYPES2, KNOWN_INLINE_PM_NODE_TYPES2;
-var init_common = __esm(() => {
-  init_index_cache();
-  init_node_address_resolver();
-  init_inline_address_resolver();
-  init_adapter_utils();
-  DUAL_KIND_TYPES2 = new Set(["sdt", "image"]);
-  KNOWN_BLOCK_PM_NODE_TYPES2 = new Set([
-    "paragraph",
-    "table",
-    "tableRow",
-    "tableCell",
-    "tableHeader",
-    "structuredContentBlock",
-    "sdt",
-    "image"
-  ]);
-  KNOWN_INLINE_PM_NODE_TYPES2 = new Set([
-    "text",
-    "run",
-    "structuredContent",
-    "image",
-    "tab",
-    "lineBreak",
-    "hardBreak",
-    "hard_break",
-    "footnoteReference",
-    "bookmarkStart",
-    "bookmarkEnd",
-    "commentRangeStart",
-    "commentRangeEnd"
-  ]);
-});
-
-// ../../packages/super-editor/src/document-api-adapters/find/block-strategy.ts
-function executeBlockSelector2(index2, query2, diagnostics) {
-  const scope = resolveWithinScope2(index2, query2, diagnostics);
-  if (!scope.ok)
-    return { matches: [], total: 0 };
-  const scoped = scopeByRange2(index2.candidates, scope.range);
-  const select2 = query2.select;
-  let filtered = [];
-  if (select2.type === "node") {
-    if (select2.kind && select2.kind !== "block") {
-      addDiagnostic2(diagnostics, "Only block nodes are supported by the current adapter.");
-    } else {
-      filtered = scoped.filter((candidate) => {
-        if (select2.nodeType) {
-          if (candidate.nodeType !== select2.nodeType)
-            return false;
-        }
-        return true;
-      });
-    }
-  }
-  const addresses = filtered.map((candidate) => ({
-    kind: "block",
-    nodeType: candidate.nodeType,
-    nodeId: candidate.nodeId
-  }));
-  const paged = paginate2(addresses, query2.offset, query2.limit);
-  return {
-    matches: paged.items,
-    total: paged.total
-  };
-}
-var init_block_strategy = __esm(() => {
-  init_adapter_utils();
-});
-
 // ../../packages/super-editor/src/document-api-adapters/find/inline-strategy.ts
 function toInlineAddress2(candidate, nodeTypeOverride) {
   return {
@@ -196420,93 +198001,6 @@ var init_dual_kind_strategy = __esm(() => {
   init_inline_strategy();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/find/text-strategy.ts
-function compileRegex2(selector, diagnostics) {
-  const flags = selector.caseSensitive ? "g" : "gi";
-  try {
-    return new RegExp(selector.pattern, flags);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    addDiagnostic2(diagnostics, `Invalid text query regex: ${reason}`);
-    return null;
-  }
-}
-function buildSearchPattern2(selector, diagnostics) {
-  const mode = selector.mode ?? "contains";
-  if (mode === "regex") {
-    return compileRegex2(selector, diagnostics);
-  }
-  const escaped = selector.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const flags = selector.caseSensitive ? "g" : "gi";
-  return new RegExp(escaped, flags);
-}
-function executeTextSelector2(editor, index2, query2, diagnostics) {
-  if (query2.select.type !== "text") {
-    addDiagnostic2(diagnostics, `Text strategy received a non-text selector (type="${query2.select.type}").`);
-    return { matches: [], total: 0 };
-  }
-  const selector = query2.select;
-  if (!selector.pattern.length) {
-    addDiagnostic2(diagnostics, "Text query pattern must be non-empty.");
-    return { matches: [], total: 0 };
-  }
-  const scope = resolveWithinScope2(index2, query2, diagnostics);
-  if (!scope.ok)
-    return { matches: [], total: 0 };
-  const pattern = buildSearchPattern2(selector, diagnostics);
-  if (!pattern)
-    return { matches: [], total: 0 };
-  const search3 = requireEditorCommand2(editor.commands?.search, "find (search)");
-  const rawResult = search3(pattern, {
-    highlight: false,
-    caseSensitive: selector.caseSensitive ?? false,
-    maxMatches: Infinity
-  });
-  if (!Array.isArray(rawResult)) {
-    throw new DocumentApiAdapterError3("CAPABILITY_UNAVAILABLE", "Editor search command returned an unexpected result format.");
-  }
-  const allMatches = rawResult;
-  const scopeRange = scope.range;
-  const matches3 = scopeRange ? allMatches.filter((m3) => m3.from >= scopeRange.start && m3.to <= scopeRange.end) : allMatches;
-  const textBlocks = index2.candidates.filter(isTextBlockCandidate2);
-  const contexts = [];
-  const addresses = [];
-  for (const match2 of matches3) {
-    const ranges = match2.ranges?.length ? match2.ranges : [{ from: match2.from, to: match2.to }];
-    let source;
-    const textRanges = ranges.map((range) => {
-      const block = findCandidateByPos2(textBlocks, range.from);
-      if (!block)
-        return;
-      if (!source)
-        source = block;
-      return toTextAddress3(editor, block, range);
-    }).filter((range) => Boolean(range));
-    if (!source) {
-      source = findCandidateByPos2(textBlocks, match2.from) ?? findBlockByPos2(index2, match2.from);
-    }
-    if (!source)
-      continue;
-    const address2 = toBlockAddress2(source);
-    addresses.push(address2);
-    contexts.push(buildTextContext2(editor, address2, match2.from, match2.to, textRanges));
-  }
-  const paged = paginate2(addresses, query2.offset, query2.limit);
-  const pagedContexts = paginate2(contexts, query2.offset, query2.limit).items;
-  return {
-    matches: paged.items,
-    total: paged.total,
-    context: pagedContexts.length ? pagedContexts : undefined
-  };
-}
-var init_text_strategy = __esm(() => {
-  init_node_address_resolver();
-  init_adapter_utils();
-  init_common();
-  init_errors3();
-  init_mutation_helpers();
-});
-
 // ../../packages/super-editor/src/document-api-adapters/find-adapter.ts
 function findAdapter2(editor, query2) {
   const diagnostics = [];
@@ -196536,125 +198030,6 @@ var init_find_adapter = __esm(() => {
   init_text_strategy();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/helpers/transaction-meta.ts
-function applyDirectMutationMeta2(tr) {
-  tr.setMeta("inputType", "programmatic");
-  tr.setMeta("skipTrackChanges", true);
-  return tr;
-}
-function applyTrackedMutationMeta2(tr) {
-  tr.setMeta("inputType", "programmatic");
-  tr.setMeta("forceTrackChanges", true);
-  return tr;
-}
-
-// ../../packages/super-editor/src/document-api-adapters/helpers/text-mutation-resolution.ts
-function readTextAtResolvedRange2(editor, range) {
-  return editor.state.doc.textBetween(range.from, range.to, `
-`, OBJECT_REPLACEMENT_CHAR2);
-}
-function buildTextMutationResolution2(input2) {
-  return {
-    ...input2.requestedTarget ? { requestedTarget: input2.requestedTarget } : {},
-    target: input2.target,
-    range: { from: input2.range.from, to: input2.range.to },
-    text: input2.text
-  };
-}
-var OBJECT_REPLACEMENT_CHAR2 = "";
-
-// ../../packages/super-editor/src/document-api-adapters/format-adapter.ts
-function normalizeFormatLocator2(input2) {
-  const hasBlockId = input2.blockId !== undefined;
-  const hasStart = input2.start !== undefined;
-  const hasEnd = input2.end !== undefined;
-  if (input2.target && (hasBlockId || hasStart || hasEnd)) {
-    throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with blockId/start/end on format request.", { fields: ["target", "blockId", "start", "end"] });
-  }
-  if (!hasBlockId && (hasStart || hasEnd)) {
-    throw new DocumentApiAdapterError3("INVALID_TARGET", "start/end require blockId on format request.", {
-      fields: ["blockId", "start", "end"]
-    });
-  }
-  if (!hasBlockId)
-    return input2;
-  if (!hasStart || !hasEnd) {
-    throw new DocumentApiAdapterError3("INVALID_TARGET", "blockId requires both start and end on format request.", {
-      fields: ["blockId", "start", "end"]
-    });
-  }
-  const target = {
-    kind: "text",
-    blockId: input2.blockId,
-    range: { start: input2.start, end: input2.end }
-  };
-  return { target };
-}
-function formatMarkAdapter2(editor, markName, operationId, input2, options) {
-  const normalizedInput = normalizeFormatLocator2(input2);
-  const range = resolveTextTarget2(editor, normalizedInput.target);
-  if (!range) {
-    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Format target could not be resolved.", {
-      target: normalizedInput.target
-    });
-  }
-  const resolution = buildTextMutationResolution2({
-    requestedTarget: input2.target,
-    target: normalizedInput.target,
-    range,
-    text: readTextAtResolvedRange2(editor, range)
-  });
-  if (range.from === range.to) {
-    const label = FORMAT_OPERATION_LABEL2[operationId];
-    return {
-      success: false,
-      resolution,
-      failure: {
-        code: "INVALID_TARGET",
-        message: `${label} formatting requires a non-collapsed target range.`
-      }
-    };
-  }
-  const mark2 = requireSchemaMark2(editor, markName, operationId);
-  const mode = options?.changeMode ?? "direct";
-  if (mode === "tracked")
-    ensureTrackedCapability2(editor, { operation: operationId, requireMarks: [TrackFormatMarkName2] });
-  if (options?.dryRun) {
-    return { success: true, resolution };
-  }
-  const tr = editor.state.tr.addMark(range.from, range.to, mark2.create());
-  if (mode === "tracked")
-    applyTrackedMutationMeta2(tr);
-  else
-    applyDirectMutationMeta2(tr);
-  editor.dispatch(tr);
-  return { success: true, resolution };
-}
-function formatBoldAdapter2(editor, input2, options) {
-  return formatMarkAdapter2(editor, "bold", "format.bold", input2, options);
-}
-function formatItalicAdapter2(editor, input2, options) {
-  return formatMarkAdapter2(editor, "italic", "format.italic", input2, options);
-}
-function formatUnderlineAdapter2(editor, input2, options) {
-  return formatMarkAdapter2(editor, "underline", "format.underline", input2, options);
-}
-function formatStrikethroughAdapter2(editor, input2, options) {
-  return formatMarkAdapter2(editor, "strike", "format.strikethrough", input2, options);
-}
-var FORMAT_OPERATION_LABEL2;
-var init_format_adapter = __esm(() => {
-  init_errors3();
-  init_mutation_helpers();
-  init_adapter_utils();
-  FORMAT_OPERATION_LABEL2 = {
-    "format.bold": "Bold",
-    "format.italic": "Italic",
-    "format.underline": "Underline",
-    "format.strikethrough": "Strikethrough"
-  };
-});
-
 // ../../packages/super-editor/src/document-api-adapters/get-node-adapter.ts
 function findBlocksByTypeAndId2(blockIndex, nodeType, nodeId) {
   const byIdMatch = blockIndex.byId.get(`${nodeType}:${nodeId}`);
@@ -196814,11 +198189,13 @@ function infoAdapter2(editor, _input) {
       canGetNode: true,
       canComment: true,
       canReplace: true
-    }
+    },
+    revision: getRevision(editor)
   };
 }
 var init_info_adapter = __esm(() => {
   init_find_adapter();
+  init_revision_tracker();
 });
 
 // ../../shared/common/list-numbering/index.ts
@@ -199407,16 +200784,12 @@ var init_isList = __esm(() => {
 function generateDocxRandomId2(length3 = 8) {
   const max3 = 2147483647;
   const value = Math.floor(Math.random() * (max3 + 1));
-  return value.toString(16).padStart(length3, "0").slice(0, length3);
+  return value.toString(16).toUpperCase().padStart(length3, "0").slice(0, length3);
 }
 function generateRandomSigned32BitIntStrId2() {
   const val = Math.floor(Math.random() * 2147483647);
   return val.toString();
 }
-function generateRandom32BitHex2() {
-  const val = Math.floor(Math.random() * 2147483647);
-  return val.toString(16).toUpperCase().padStart(8, "0");
-}
 
 // ../../packages/super-editor/src/core/helpers/generateDocxListAttributes.js
 var init_generateDocxListAttributes = () => {};
@@ -215696,7 +217069,21 @@ function resolveParagraphProperties2(params3, inlineProps, tableInfo) {
     specialHandling: {
       tabStops: (target, source) => {
         if (target.tabStops != null && source.tabStops != null) {
-          return [...target.tabStops, ...source.tabStops];
+          const sourceArr = source.tabStops;
+          const clearPositions = new Set;
+          for (const ts of sourceArr) {
+            if (ts.tab?.tabType === "clear" && ts.tab.pos != null) {
+              clearPositions.add(ts.tab.pos);
+            }
+          }
+          const targetArr = target.tabStops;
+          const merged = targetArr.filter((ts) => !(ts.tab?.pos != null && clearPositions.has(ts.tab.pos)));
+          for (const ts of sourceArr) {
+            if (ts.tab?.tabType !== "clear") {
+              merged.push(ts);
+            }
+          }
+          return merged;
         }
         return source.tabStops;
       }
@@ -226257,7 +227644,7 @@ var init_constants = __esm(() => {
 var prepareCommentParaIds2 = (comment2) => {
   const newComment = {
     ...comment2,
-    commentParaId: generateRandom32BitHex2()
+    commentParaId: generateDocxRandomId2()
   };
   return newComment;
 }, getCommentDefinition2 = (comment2, commentId, allComments, editor) => {
@@ -226391,7 +227778,7 @@ var prepareCommentParaIds2 = (comment2) => {
   if (extensibleUpdated)
     extensibleUpdated.elements[0].elements = [];
   comments.forEach((comment2) => {
-    const newDurableId = generateRandom32BitHex2();
+    const newDurableId = generateDocxRandomId2();
     if (documentIdsUpdated) {
       documentIdsUpdated.elements[0].elements.push({
         type: "element",
@@ -229953,7 +231340,7 @@ var init_list_item_resolver = __esm(() => {
   init_index_cache();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/lists-adapter.ts
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/lists-wrappers.ts
 function toListsFailure2(code7, message, details) {
   return { success: false, failure: { code: code7, message, details } };
 }
@@ -230030,14 +231417,14 @@ function withListTarget2(editor, input2) {
   }
   throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "List item target was not found.", { nodeId });
 }
-function listsListAdapter2(editor, query2) {
+function listsListWrapper(editor, query2) {
   return listListItems2(editor, query2);
 }
-function listsGetAdapter2(editor, input2) {
+function listsGetWrapper(editor, input2) {
   const item = resolveListItem2(editor, input2.address);
   return listItemProjectionToInfo2(item);
 }
-function listsInsertAdapter2(editor, input2, options) {
+function listsInsertWrapper(editor, input2, options) {
   const target = withListTarget2(editor, input2);
   const changeMode = options?.changeMode ?? "direct";
   const mode = changeMode === "tracked" ? "tracked" : "direct";
@@ -230056,24 +231443,30 @@ function listsInsertAdapter2(editor, input2, options) {
     };
   }
   const createdId = v42();
-  const didApply = insertListItemAt2({
-    pos: target.candidate.pos,
-    position: input2.position,
-    text: input2.text ?? "",
-    sdBlockId: createdId,
-    tracked: mode === "tracked"
-  });
-  if (!didApply) {
+  let created = null;
+  const receipt2 = executeDomainCommand(editor, () => {
+    const didApply = insertListItemAt2({
+      pos: target.candidate.pos,
+      position: input2.position,
+      text: input2.text ?? "",
+      sdBlockId: createdId,
+      tracked: mode === "tracked"
+    });
+    if (didApply) {
+      clearIndexCache2(editor);
+      try {
+        created = resolveInsertedListItem2(editor, createdId);
+      } catch {}
+    }
+    return didApply;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List item insertion could not be applied at the requested target.", {
       target: input2.target,
       position: input2.position
     });
   }
-  clearIndexCache2(editor);
-  let created;
-  try {
-    created = resolveInsertedListItem2(editor, createdId);
-  } catch {
+  if (!created) {
     return {
       success: true,
       item: { kind: "block", nodeType: "listItem", nodeId: createdId },
@@ -230095,7 +231488,7 @@ function listsInsertAdapter2(editor, input2, options) {
     trackedChangeRefs: mode === "tracked" ? collectTrackInsertRefsInRange2(editor, created.candidate.pos, created.candidate.end) : undefined
   };
 }
-function listsSetTypeAdapter2(editor, input2, options) {
+function listsSetTypeWrapper(editor, input2, options) {
   rejectTrackedMode2("lists.setType", options);
   const target = withListTarget2(editor, input2);
   if (target.kind === input2.kind) {
@@ -230108,22 +231501,18 @@ function listsSetTypeAdapter2(editor, input2, options) {
   if (options?.dryRun) {
     return { success: true, item: target.address };
   }
-  const didApply = setListTypeAt2({
-    pos: target.candidate.pos,
-    kind: input2.kind
+  const receipt2 = executeDomainCommand(editor, () => setListTypeAt2({ pos: target.candidate.pos, kind: input2.kind }), {
+    expectedRevision: options?.expectedRevision
   });
-  if (!didApply) {
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List type conversion could not be applied.", {
       target: input2.target,
       kind: input2.kind
     });
   }
-  return {
-    success: true,
-    item: target.address
-  };
+  return { success: true, item: target.address };
 }
-function listsIndentAdapter2(editor, input2, options) {
+function listsIndentWrapper(editor, input2, options) {
   rejectTrackedMode2("lists.indent", options);
   const target = withListTarget2(editor, input2);
   if (isAtMaximumLevel2(editor, target)) {
@@ -230138,16 +231527,15 @@ function listsIndentAdapter2(editor, input2, options) {
       target: input2.target
     });
   }
-  const didApply = increaseListIndent2();
-  if (!didApply) {
+  const receipt2 = executeDomainCommand(editor, () => increaseListIndent2(), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List indentation could not be applied.", { target: input2.target });
   }
-  return {
-    success: true,
-    item: target.address
-  };
+  return { success: true, item: target.address };
 }
-function listsOutdentAdapter2(editor, input2, options) {
+function listsOutdentWrapper(editor, input2, options) {
   rejectTrackedMode2("lists.outdent", options);
   const target = withListTarget2(editor, input2);
   if ((target.level ?? 0) <= 0) {
@@ -230162,16 +231550,15 @@ function listsOutdentAdapter2(editor, input2, options) {
       target: input2.target
     });
   }
-  const didApply = decreaseListIndent2();
-  if (!didApply) {
+  const receipt2 = executeDomainCommand(editor, () => decreaseListIndent2(), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List outdent could not be applied.", { target: input2.target });
   }
-  return {
-    success: true,
-    item: target.address
-  };
+  return { success: true, item: target.address };
 }
-function listsRestartAdapter2(editor, input2, options) {
+function listsRestartWrapper(editor, input2, options) {
   rejectTrackedMode2("lists.restart", options);
   const target = withListTarget2(editor, input2);
   if (target.numId == null) {
@@ -230193,16 +231580,15 @@ function listsRestartAdapter2(editor, input2, options) {
       target: input2.target
     });
   }
-  const didApply = restartNumbering2();
-  if (!didApply) {
+  const receipt2 = executeDomainCommand(editor, () => restartNumbering2(), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List restart could not be applied.", { target: input2.target });
   }
-  return {
-    success: true,
-    item: target.address
-  };
+  return { success: true, item: target.address };
 }
-function listsExitAdapter2(editor, input2, options) {
+function listsExitWrapper(editor, input2, options) {
   rejectTrackedMode2("lists.exit", options);
   const target = withListTarget2(editor, input2);
   const exitListItemAt2 = requireEditorCommand2(editor.commands?.exitListItemAt, "lists.exit (exitListItemAt)");
@@ -230216,8 +231602,10 @@ function listsExitAdapter2(editor, input2, options) {
       }
     };
   }
-  const didApply = exitListItemAt2({ pos: target.candidate.pos });
-  if (!didApply) {
+  const receipt2 = executeDomainCommand(editor, () => exitListItemAt2({ pos: target.candidate.pos }), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
     return toListsFailure2("INVALID_TARGET", "List exit could not be applied.", { target: input2.target });
   }
   return {
@@ -230229,17 +231617,18 @@ function listsExitAdapter2(editor, input2, options) {
     }
   };
 }
-var init_lists_adapter = __esm(() => {
+var init_lists_wrappers = __esm(() => {
   init_wrapper();
   init_errors3();
   init_mutation_helpers();
+  init_plan_wrappers();
   init_index_cache();
   init_tracked_change_refs();
   init_list_item_resolver();
   init_list_numbering_helpers();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/track-changes-adapter.ts
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/track-changes-wrappers.ts
 function buildTrackChangeInfo2(editor, change) {
   const excerpt = normalizeExcerpt2(editor.state.doc.textBetween(change.from, change.to, " ", ""));
   const type = resolveTrackedChangeType2(change);
@@ -230281,7 +231670,7 @@ function toNoOpReceipt2(message, details) {
     }
   };
 }
-function trackChangesListAdapter2(editor, input2) {
+function trackChangesListWrapper(editor, input2) {
   const query2 = input2;
   const grouped = filterByType2(groupTrackedChanges2(editor), query2?.type);
   const paged = paginate2(grouped, query2?.offset, query2?.limit);
@@ -230293,277 +231682,341 @@ function trackChangesListAdapter2(editor, input2) {
     changes: changes.length ? changes : undefined
   };
 }
-function trackChangesGetAdapter2(editor, input2) {
+function trackChangesGetWrapper(editor, input2) {
   const { id: id2 } = input2;
   return buildTrackChangeInfo2(editor, requireTrackChangeById2(editor, id2));
 }
-function trackChangesAcceptAdapter2(editor, input2) {
+function trackChangesAcceptWrapper(editor, input2, options) {
   const { id: id2 } = input2;
   const change = requireTrackChangeById2(editor, id2);
   const acceptById = requireEditorCommand2(editor.commands?.acceptTrackedChangeById, "Accept tracked change");
-  const didAccept = Boolean(acceptById(change.rawId));
-  if (didAccept)
-    return { success: true };
-  return toNoOpReceipt2(`Accept tracked change "${id2}" produced no change.`, { id: id2 });
+  const receipt2 = executeDomainCommand(editor, () => Boolean(acceptById(change.rawId)), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toNoOpReceipt2(`Accept tracked change "${id2}" produced no change.`, { id: id2 });
+  }
+  return { success: true };
 }
-function trackChangesRejectAdapter2(editor, input2) {
+function trackChangesRejectWrapper(editor, input2, options) {
   const { id: id2 } = input2;
   const change = requireTrackChangeById2(editor, id2);
   const rejectById = requireEditorCommand2(editor.commands?.rejectTrackedChangeById, "Reject tracked change");
-  const didReject = Boolean(rejectById(change.rawId));
-  if (didReject)
-    return { success: true };
-  return toNoOpReceipt2(`Reject tracked change "${id2}" produced no change.`, { id: id2 });
+  const receipt2 = executeDomainCommand(editor, () => Boolean(rejectById(change.rawId)), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toNoOpReceipt2(`Reject tracked change "${id2}" produced no change.`, { id: id2 });
+  }
+  return { success: true };
 }
-function trackChangesAcceptAllAdapter2(editor, _input) {
+function trackChangesAcceptAllWrapper(editor, _input, options) {
   const acceptAll = requireEditorCommand2(editor.commands?.acceptAllTrackedChanges, "Accept all tracked changes");
   if (groupTrackedChanges2(editor).length === 0) {
     return toNoOpReceipt2("Accept all tracked changes produced no change.");
   }
-  const didAcceptAll = Boolean(acceptAll());
-  if (didAcceptAll)
-    return { success: true };
-  return toNoOpReceipt2("Accept all tracked changes produced no change.");
+  const receipt2 = executeDomainCommand(editor, () => Boolean(acceptAll()), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toNoOpReceipt2("Accept all tracked changes produced no change.");
+  }
+  return { success: true };
 }
-function trackChangesRejectAllAdapter2(editor, _input) {
+function trackChangesRejectAllWrapper(editor, _input, options) {
   const rejectAll = requireEditorCommand2(editor.commands?.rejectAllTrackedChanges, "Reject all tracked changes");
   if (groupTrackedChanges2(editor).length === 0) {
     return toNoOpReceipt2("Reject all tracked changes produced no change.");
   }
-  const didRejectAll = Boolean(rejectAll());
-  if (didRejectAll)
-    return { success: true };
-  return toNoOpReceipt2("Reject all tracked changes produced no change.");
+  const receipt2 = executeDomainCommand(editor, () => Boolean(rejectAll()), {
+    expectedRevision: options?.expectedRevision
+  });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toNoOpReceipt2("Reject all tracked changes produced no change.");
+  }
+  return { success: true };
 }
-var init_track_changes_adapter = __esm(() => {
+var init_track_changes_wrappers = __esm(() => {
   init_errors3();
   init_mutation_helpers();
+  init_plan_wrappers();
   init_adapter_utils();
   init_tracked_change_resolver();
 });
 
-// ../../packages/super-editor/src/document-api-adapters/write-adapter.ts
-function validateWriteRequest2(request, resolvedTarget) {
-  if (request.kind === "insert") {
-    if (!request.text) {
-      return {
-        code: "INVALID_TARGET",
-        message: "Insert operations require non-empty text."
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/preview.ts
+function previewPlan(editor, input2) {
+  const evaluatedRevision = getRevision(editor);
+  checkRevision(editor, input2.expectedRevision);
+  if (!input2.steps?.length) {
+    throw planError("INVALID_INPUT", "plan must contain at least one step");
+  }
+  const failures = [];
+  const stepPreviews = [];
+  let currentPhase = "compile";
+  try {
+    const compiled = compilePlan(editor, input2.steps);
+    currentPhase = "execute";
+    const tr = editor.state.tr;
+    const { stepOutcomes, assertFailures } = runMutationsOnTransaction(editor, tr, compiled, {
+      throwOnAssertFailure: false
+    });
+    for (const outcome of stepOutcomes) {
+      const preview = {
+        stepId: outcome.stepId,
+        op: outcome.op
       };
+      if (outcome.data && "resolutions" in outcome.data && outcome.data.domain === "text") {
+        preview.resolutions = outcome.data.resolutions;
+      }
+      stepPreviews.push(preview);
     }
-    if (resolvedTarget.range.from !== resolvedTarget.range.to) {
-      return {
-        code: "INVALID_TARGET",
-        message: "Insert operations require a collapsed target range."
-      };
+    for (const failure of assertFailures) {
+      failures.push({
+        code: "PRECONDITION_FAILED",
+        stepId: failure.stepId,
+        phase: "assert",
+        message: `assert "${failure.stepId}" expected ${failure.expectedCount} matches but found ${failure.actualCount}`,
+        details: { expectedCount: failure.expectedCount, actualCount: failure.actualCount }
+      });
+    }
+  } catch (error) {
+    if (error instanceof PlanError) {
+      failures.push({
+        code: error.code,
+        stepId: error.stepId ?? "",
+        phase: currentPhase,
+        message: error.message,
+        details: error.details
+      });
+    } else {
+      throw error;
     }
-    return null;
   }
-  if (request.kind === "replace") {
-    if (request.text == null || request.text.length === 0) {
-      return {
-        code: "INVALID_TARGET",
-        message: "Replace operations require non-empty text. Use delete for removals."
-      };
+  return {
+    evaluatedRevision,
+    steps: stepPreviews,
+    valid: failures.length === 0,
+    failures: failures.length > 0 ? failures : undefined
+  };
+}
+var init_preview = __esm(() => {
+  init_revision_tracker();
+  init_compiler();
+  init_executor();
+  init_errors4();
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/query-match-adapter.ts
+function buildStyleSummary(captured) {
+  const totalChars = captured.runs.reduce((sum, r2) => sum + r2.charCount, 0);
+  const marks = {};
+  for (const markName of CORE_MARK_NAMES2) {
+    let activeChars = 0;
+    for (const run2 of captured.runs) {
+      if (run2.marks.some((m4) => m4.type.name === markName)) {
+        activeChars += run2.charCount;
+      }
     }
-    if (resolvedTarget.resolution.text === request.text) {
-      return {
-        code: "NO_OP",
-        message: "Replace operation produced no change."
-      };
+    if (activeChars > 0) {
+      marks[markName] = totalChars > 0 && activeChars > totalChars / 2;
     }
-    return null;
   }
-  if (resolvedTarget.range.from === resolvedTarget.range.to) {
-    return {
-      code: "NO_OP",
-      message: "Delete operation produced no change for a collapsed range."
-    };
+  return { marks, isUniform: captured.isUniform };
+}
+function captureMatchStyle(editor, textRanges) {
+  if (!textRanges.length)
+    return;
+  const index2 = getBlockIndex2(editor);
+  const allRuns = [];
+  let allUniform = true;
+  for (const range of textRanges) {
+    const candidate = index2.candidates.find((c2) => c2.nodeId === range.blockId);
+    if (!candidate)
+      continue;
+    const captured = captureRunsInRange(editor, candidate.pos, range.range.start, range.range.end);
+    allRuns.push(...captured.runs);
+    if (!captured.isUniform)
+      allUniform = false;
   }
-  return null;
+  if (allUniform && allRuns.length > 1) {
+    const ref2 = allRuns[0].marks;
+    for (let i4 = 1;i4 < allRuns.length; i4++) {
+      const cur = allRuns[i4].marks;
+      if (ref2.length !== cur.length || !ref2.every((m4, j3) => cur[j3] && m4.eq(cur[j3]))) {
+        allUniform = false;
+        break;
+      }
+    }
+  }
+  return buildStyleSummary({ runs: allRuns, isUniform: allUniform });
 }
-function normalizeWriteLocator2(request) {
-  if (request.kind === "insert") {
-    const hasBlockId = request.blockId !== undefined;
-    const hasOffset = request.offset !== undefined;
-    if (hasOffset && request.target) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with offset on insert request.", {
-        fields: ["target", "offset"]
-      });
+function queryMatchAdapter(editor, input2) {
+  const evaluatedRevision = getRevision(editor);
+  const require2 = input2.require ?? "any";
+  if ((require2 === "first" || require2 === "exactlyOne") && (input2.limit !== undefined || input2.offset !== undefined)) {
+    throw planError("INVALID_INPUT", `limit/offset are not valid when require is "${require2}"`);
+  }
+  const query2 = {
+    select: input2.select,
+    within: input2.within,
+    includeNodes: input2.includeNodes,
+    limit: input2.limit,
+    offset: input2.offset
+  };
+  const result = findAdapter2(editor, query2);
+  const totalMatches = result.total;
+  if (require2 === "first") {
+    if (totalMatches === 0) {
+      throw planError("MATCH_NOT_FOUND", "selector matched zero ranges");
     }
-    if (hasOffset && !hasBlockId) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", "offset requires blockId on insert request.", {
-        fields: ["offset", "blockId"]
-      });
+  } else if (require2 === "exactlyOne") {
+    if (totalMatches === 0) {
+      throw planError("MATCH_NOT_FOUND", "selector matched zero ranges");
     }
-    if (!hasBlockId)
-      return request;
-    if (request.target) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", "Cannot combine target with blockId on insert request.", {
-        fields: ["target", "blockId"]
+    if (totalMatches > 1) {
+      throw planError("AMBIGUOUS_MATCH", `selector matched ${totalMatches} ranges, expected exactly one`, undefined, {
+        matchCount: totalMatches
       });
     }
-    const effectiveOffset = request.offset ?? 0;
-    const target = {
-      kind: "text",
-      blockId: request.blockId,
-      range: { start: effectiveOffset, end: effectiveOffset }
-    };
-    return { kind: "insert", target, text: request.text };
-  }
-  if (request.kind === "replace" || request.kind === "delete") {
-    const hasBlockId = request.blockId !== undefined;
-    const hasStart = request.start !== undefined;
-    const hasEnd = request.end !== undefined;
-    if (request.target && (hasBlockId || hasStart || hasEnd)) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", `Cannot combine target with blockId/start/end on ${request.kind} request.`, { fields: ["target", "blockId", "start", "end"] });
+  } else if (require2 === "all") {
+    if (totalMatches === 0) {
+      throw planError("MATCH_NOT_FOUND", "selector matched zero ranges");
     }
-    if (!hasBlockId && (hasStart || hasEnd)) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", `start/end require blockId on ${request.kind} request.`, {
-        fields: ["blockId", "start", "end"]
-      });
+  }
+  const matchResults = result.matches.map((address2, idx) => {
+    const matchResult = { address: address2 };
+    const ctx2 = result.context?.[idx];
+    if (ctx2?.textRanges?.length) {
+      matchResult.textRanges = ctx2.textRanges;
     }
-    if (!hasBlockId)
-      return request;
-    if (!hasStart || !hasEnd) {
-      throw new DocumentApiAdapterError3("INVALID_TARGET", `blockId requires both start and end on ${request.kind} request.`, { fields: ["blockId", "start", "end"] });
+    if (input2.includeStyle && matchResult.textRanges?.length) {
+      matchResult.style = captureMatchStyle(editor, matchResult.textRanges);
     }
-    const target = {
-      kind: "text",
-      blockId: request.blockId,
-      range: { start: request.start, end: request.end }
-    };
-    if (request.kind === "replace") {
-      return { kind: "replace", target, text: request.text };
+    if (input2.select.type === "text") {
+      const refData = {
+        rev: evaluatedRevision,
+        addr: address2,
+        ranges: ctx2?.textRanges
+      };
+      matchResult.ref = `text:${btoa(JSON.stringify(refData))}`;
+      matchResult.refStability = "ephemeral";
+    } else {
+      if (address2.kind === "block") {
+        matchResult.ref = address2.nodeId;
+        matchResult.refStability = "stable";
+      }
     }
-    return { kind: "delete", target, text: "" };
-  }
-  return request;
-}
-function resolveWriteTarget2(editor, request) {
-  const requestedTarget = request.target;
-  if (request.kind === "insert" && !request.target) {
-    const fallback = resolveDefaultInsertTarget2(editor);
-    if (!fallback)
-      return null;
-    const text5 = readTextAtResolvedRange2(editor, fallback.range);
-    return {
-      requestedTarget,
-      effectiveTarget: fallback.target,
-      range: fallback.range,
-      resolution: buildTextMutationResolution2({
-        requestedTarget,
-        target: fallback.target,
-        range: fallback.range,
-        text: text5
-      })
-    };
-  }
-  const target = request.target;
-  if (!target)
-    return null;
-  const range = resolveTextTarget2(editor, target);
-  if (!range)
-    return null;
-  const text4 = readTextAtResolvedRange2(editor, range);
+    return matchResult;
+  });
+  const truncated = require2 === "first" ? matchResults.slice(0, 1) : matchResults;
   return {
-    requestedTarget,
-    effectiveTarget: target,
-    range,
-    resolution: buildTextMutationResolution2({
-      requestedTarget,
-      target,
-      range,
-      text: text4
-    })
+    evaluatedRevision,
+    matches: truncated,
+    totalMatches
   };
 }
-function applyDirectWrite2(editor, request, resolvedTarget) {
-  if (request.kind === "delete") {
-    const tr2 = applyDirectMutationMeta2(editor.state.tr.delete(resolvedTarget.range.from, resolvedTarget.range.to));
-    editor.dispatch(tr2);
-    return { success: true, resolution: resolvedTarget.resolution };
-  }
-  const tr = applyDirectMutationMeta2(editor.state.tr.insertText(request.text ?? "", resolvedTarget.range.from, resolvedTarget.range.to));
-  editor.dispatch(tr);
-  return { success: true, resolution: resolvedTarget.resolution };
-}
-function applyTrackedWrite2(editor, request, resolvedTarget) {
-  ensureTrackedCapability2(editor, { operation: "write" });
-  const insertTrackedChange = editor.commands.insertTrackedChange;
-  const text4 = request.kind === "delete" ? "" : request.text ?? "";
-  const changeId = v42();
-  const didApply = insertTrackedChange({
-    from: resolvedTarget.range.from,
-    to: request.kind === "insert" ? resolvedTarget.range.from : resolvedTarget.range.to,
-    text: text4,
-    id: changeId
+var CORE_MARK_NAMES2;
+var init_query_match_adapter = __esm(() => {
+  init_find_adapter();
+  init_index_cache();
+  init_style_resolver();
+  init_revision_tracker();
+  init_errors4();
+  CORE_MARK_NAMES2 = ["bold", "italic", "underline", "strike"];
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/register-executors.ts
+function sortTargetsByPosition(targets) {
+  return [...targets].sort((a2, b4) => {
+    if (a2.blockId === b4.blockId)
+      return a2.from - b4.from;
+    return a2.blockId < b4.blockId ? -1 : 1;
   });
-  if (!didApply) {
-    return {
-      success: false,
-      resolution: resolvedTarget.resolution,
-      failure: {
-        code: "NO_OP",
-        message: "Tracked write command did not apply a change."
-      }
-    };
-  }
-  const publicChangeId = toCanonicalTrackedChangeId2(editor, changeId);
-  return {
-    success: true,
-    resolution: resolvedTarget.resolution,
-    ...publicChangeId ? {
-      inserted: [
-        {
-          kind: "entity",
-          entityType: "trackedChange",
-          entityId: publicChangeId
-        }
-      ]
-    } : {}
-  };
 }
-function toFailureReceipt2(failure, resolvedTarget) {
+function buildTextResolution(target) {
   return {
-    success: false,
-    resolution: resolvedTarget.resolution,
-    failure
+    target: {
+      kind: "text",
+      blockId: target.blockId,
+      range: { start: target.from, end: target.to }
+    },
+    range: { from: target.from, to: target.to },
+    text: target.text
   };
 }
-function writeAdapter2(editor, request, options) {
-  const normalizedRequest = normalizeWriteLocator2(request);
-  const resolvedTarget = resolveWriteTarget2(editor, normalizedRequest);
-  if (!resolvedTarget) {
-    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Mutation target could not be resolved.", {
-      target: normalizedRequest.target
-    });
-  }
-  const validationFailure = validateWriteRequest2(normalizedRequest, resolvedTarget);
-  if (validationFailure) {
-    return toFailureReceipt2(validationFailure, resolvedTarget);
-  }
-  const mode = options?.changeMode ?? "direct";
-  if (options?.dryRun) {
-    if (mode === "tracked")
-      ensureTrackedCapability2(editor, { operation: "write" });
-    return { success: true, resolution: resolvedTarget.resolution };
-  }
-  if (mode === "tracked") {
-    return applyTrackedWrite2(editor, normalizedRequest, resolvedTarget);
+function executeWithTargetIteration(ctx2, targets, step, executeFn) {
+  const sortedTargets = sortTargetsByPosition(targets);
+  let overallChanged = false;
+  const resolutions = [];
+  for (const target of sortedTargets) {
+    resolutions.push(buildTextResolution(target));
+    const { changed } = executeFn(ctx2.editor, ctx2.tr, target, step, ctx2.mapping);
+    if (changed)
+      overallChanged = true;
   }
-  return applyDirectWrite2(editor, normalizedRequest, resolvedTarget);
+  const effect2 = overallChanged ? "changed" : "noop";
+  const data = { domain: "text", resolutions };
+  return { stepId: step.id, op: step.op, effect: effect2, matchCount: targets.length, data };
 }
-var init_write_adapter = __esm(() => {
-  init_wrapper();
-  init_errors3();
-  init_mutation_helpers();
-  init_adapter_utils();
-  init_tracked_change_resolver();
+function registerBuiltInExecutors() {
+  if (registered)
+    return;
+  registered = true;
+  registerStepExecutor("text.rewrite", {
+    execute: (ctx2, targets, step) => executeWithTargetIteration(ctx2, targets, step, (e, tr, t, s2, m4) => executeTextRewrite(e, tr, t, s2, m4))
+  });
+  registerStepExecutor("text.insert", {
+    execute: (ctx2, targets, step) => executeWithTargetIteration(ctx2, targets, step, (e, tr, t, s2, m4) => executeTextInsert(e, tr, t, s2, m4))
+  });
+  registerStepExecutor("text.delete", {
+    execute: (ctx2, targets, step) => executeWithTargetIteration(ctx2, targets, step, (e, tr, t, s2, m4) => executeTextDelete(e, tr, t, s2, m4))
+  });
+  registerStepExecutor("style.apply", {
+    execute: (ctx2, targets, step) => executeWithTargetIteration(ctx2, targets, step, (e, tr, t, s2, m4) => executeStyleApply(e, tr, t, s2, m4))
+  });
+  registerStepExecutor("create.paragraph", {
+    execute: (ctx2, targets, step) => executeCreateStep(ctx2.editor, ctx2.tr, step, targets, ctx2.mapping)
+  });
+  registerStepExecutor("create.heading", {
+    execute: (ctx2, targets, step) => executeCreateStep(ctx2.editor, ctx2.tr, step, targets, ctx2.mapping)
+  });
+  registerStepExecutor("domain.command", {
+    execute(ctx2, _targets, step) {
+      const handler3 = step._handler;
+      if (!handler3) {
+        return {
+          stepId: step.id,
+          op: step.op,
+          effect: "noop",
+          matchCount: 0,
+          data: { domain: "command", commandDispatched: false }
+        };
+      }
+      const success = handler3();
+      if (success)
+        ctx2.commandDispatched = true;
+      return {
+        stepId: step.id,
+        op: step.op,
+        effect: success ? "changed" : "noop",
+        matchCount: success ? 1 : 0,
+        data: { domain: "command", commandDispatched: success }
+      };
+    }
+  });
+}
+var registered = false;
+var init_register_executors = __esm(() => {
+  init_executor_registry();
+  init_executor();
 });
 
 // ../../packages/super-editor/src/document-api-adapters/index.ts
 function getDocumentApiAdapters2(editor) {
+  registerBuiltInExecutors();
+  initRevision(editor);
+  trackRevisions(editor);
   return {
     find: {
       find: (query2) => findAdapter2(editor, query2)
@@ -230581,51 +232034,62 @@ function getDocumentApiAdapters2(editor) {
     capabilities: {
       get: () => getDocumentApiCapabilities2(editor)
     },
-    comments: createCommentsAdapter2(editor),
+    comments: createCommentsWrapper(editor),
     write: {
-      write: (request, options) => writeAdapter2(editor, request, options)
+      write: (request, options) => writeWrapper(editor, request, options)
     },
     format: {
-      bold: (input2, options) => formatBoldAdapter2(editor, input2, options),
-      italic: (input2, options) => formatItalicAdapter2(editor, input2, options),
-      underline: (input2, options) => formatUnderlineAdapter2(editor, input2, options),
-      strikethrough: (input2, options) => formatStrikethroughAdapter2(editor, input2, options)
+      bold: (input2, options) => formatBoldWrapper(editor, input2, options),
+      italic: (input2, options) => formatItalicWrapper(editor, input2, options),
+      underline: (input2, options) => formatUnderlineWrapper(editor, input2, options),
+      strikethrough: (input2, options) => formatStrikethroughWrapper(editor, input2, options)
     },
     trackChanges: {
-      list: (query2) => trackChangesListAdapter2(editor, query2),
-      get: (input2) => trackChangesGetAdapter2(editor, input2),
-      accept: (input2) => trackChangesAcceptAdapter2(editor, input2),
-      reject: (input2) => trackChangesRejectAdapter2(editor, input2),
-      acceptAll: (input2) => trackChangesAcceptAllAdapter2(editor, input2),
-      rejectAll: (input2) => trackChangesRejectAllAdapter2(editor, input2)
+      list: (query2) => trackChangesListWrapper(editor, query2),
+      get: (input2) => trackChangesGetWrapper(editor, input2),
+      accept: (input2, options) => trackChangesAcceptWrapper(editor, input2, options),
+      reject: (input2, options) => trackChangesRejectWrapper(editor, input2, options),
+      acceptAll: (input2, options) => trackChangesAcceptAllWrapper(editor, input2, options),
+      rejectAll: (input2, options) => trackChangesRejectAllWrapper(editor, input2, options)
     },
     create: {
-      paragraph: (input2, options) => createParagraphAdapter2(editor, input2, options),
-      heading: (input2, options) => createHeadingAdapter2(editor, input2, options)
+      paragraph: (input2, options) => createParagraphWrapper(editor, input2, options),
+      heading: (input2, options) => createHeadingWrapper(editor, input2, options)
     },
     lists: {
-      list: (query2) => listsListAdapter2(editor, query2),
-      get: (input2) => listsGetAdapter2(editor, input2),
-      insert: (input2, options) => listsInsertAdapter2(editor, input2, options),
-      setType: (input2, options) => listsSetTypeAdapter2(editor, input2, options),
-      indent: (input2, options) => listsIndentAdapter2(editor, input2, options),
-      outdent: (input2, options) => listsOutdentAdapter2(editor, input2, options),
-      restart: (input2, options) => listsRestartAdapter2(editor, input2, options),
-      exit: (input2, options) => listsExitAdapter2(editor, input2, options)
+      list: (query2) => listsListWrapper(editor, query2),
+      get: (input2) => listsGetWrapper(editor, input2),
+      insert: (input2, options) => listsInsertWrapper(editor, input2, options),
+      setType: (input2, options) => listsSetTypeWrapper(editor, input2, options),
+      indent: (input2, options) => listsIndentWrapper(editor, input2, options),
+      outdent: (input2, options) => listsOutdentWrapper(editor, input2, options),
+      restart: (input2, options) => listsRestartWrapper(editor, input2, options),
+      exit: (input2, options) => listsExitWrapper(editor, input2, options)
+    },
+    query: {
+      match: (input2) => queryMatchAdapter(editor, input2)
+    },
+    mutations: {
+      preview: (input2) => previewPlan(editor, input2),
+      apply: (input2) => executePlan(editor, input2)
     }
   };
 }
 var init_document_api_adapters = __esm(() => {
   init_capabilities_adapter();
-  init_comments_adapter();
-  init_create_adapter();
+  init_comments_wrappers();
+  init_create_wrappers();
   init_find_adapter();
-  init_format_adapter();
+  init_plan_wrappers();
   init_get_node_adapter();
   init_info_adapter();
-  init_lists_adapter();
-  init_track_changes_adapter();
-  init_write_adapter();
+  init_lists_wrappers();
+  init_track_changes_wrappers();
+  init_executor();
+  init_preview();
+  init_query_match_adapter();
+  init_revision_tracker();
+  init_register_executors();
 });
 
 // ../../node_modules/.pnpm/@hocuspocus+common@2.15.3/node_modules/@hocuspocus/common/dist/hocuspocus-common.esm.js
@@ -234568,7 +236032,8 @@ var init_invoke_input = __esm(() => {
     "lists.outdent": "input",
     "lists.restart": "input",
     "lists.exit": "input",
-    "create.paragraph": "input"
+    "create.paragraph": "input",
+    "create.heading": "input"
   };
   PARAM_RENAMES = {
     getNodeById: { id: "nodeId" },
@@ -235328,6 +236793,7 @@ function buildDocBackedMetadata() {
       mergedParams.push(param);
     }
     const overrides = PARAM_FLAG_OVERRIDES[cliOpId];
+    const schemaOverrides = PARAM_SCHEMA_OVERRIDES[cliOpId];
     const exclusions = PARAM_EXCLUSIONS[cliOpId];
     for (const param of schemaParams) {
       if (exclusions?.has(param.name))
@@ -235339,6 +236805,9 @@ function buildDocBackedMetadata() {
         if (override.flag)
           param.flag = override.flag;
       }
+      if (schemaOverrides?.[param.name]) {
+        param.schema = schemaOverrides[param.name];
+      }
       if (seenNames.has(param.name))
         continue;
       seenNames.add(param.name);
@@ -235399,7 +236868,7 @@ function deriveOptionSpecs(params4) {
   }
   return specs;
 }
-var DOC_PARAM, SESSION_PARAM, OUT_PARAM, FORCE_PARAM, DRY_RUN_PARAM, CHANGE_MODE_PARAM, EXPECTED_REVISION_PARAM, OPERATION_CONSTRAINTS, PARAM_FLAG_OVERRIDES, PARAM_EXCLUSIONS, EXTRA_CLI_PARAMS, CLI_ONLY_METADATA, CLI_OPERATION_METADATA, CLI_OPERATION_OPTION_SPECS;
+var DOC_PARAM, SESSION_PARAM, OUT_PARAM, FORCE_PARAM, DRY_RUN_PARAM, CHANGE_MODE_PARAM, EXPECTED_REVISION_PARAM, OPERATION_CONSTRAINTS, PARAM_FLAG_OVERRIDES, PARAM_SCHEMA_OVERRIDES, PARAM_EXCLUSIONS, EXTRA_CLI_PARAMS, CLI_ONLY_METADATA, CLI_OPERATION_METADATA, CLI_OPERATION_OPTION_SPECS;
 var init_operation_params = __esm(() => {
   init_src();
   init_operation_set();
@@ -235485,6 +236954,14 @@ var init_operation_params = __esm(() => {
       address: { flag: "address-json" }
     }
   };
+  PARAM_SCHEMA_OVERRIDES = {
+    "doc.mutations.preview": {
+      steps: { type: "json" }
+    },
+    "doc.mutations.apply": {
+      steps: { type: "json" }
+    }
+  };
   PARAM_EXCLUSIONS = {
     "doc.find": new Set(["select"])
   };
@@ -235511,7 +236988,8 @@ var init_operation_params = __esm(() => {
     "doc.lists.outdent": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
     "doc.lists.restart": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
     "doc.lists.exit": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
-    "doc.create.paragraph": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }]
+    "doc.create.paragraph": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.create.heading": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }]
   };
   CLI_ONLY_METADATA = {
     "doc.open": {