@superdoc-dev/cli 0.2.0-next.55 → 0.2.0-next.57

package/dist/index.js

@@ -1956,19 +1956,49 @@ var init_operation_definitions = __esm(() => {
       referenceDocPath: "lists/insert.mdx",
       referenceGroup: "lists"
     },
-    "lists.setType": {
-      memberPath: "lists.setType",
-      description: "Change the list type (ordered, unordered) of a target list.",
-      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if the list already has the requested type.",
+    "lists.create": {
+      memberPath: "lists.create",
+      description: "Create a new list from one or more paragraphs, or convert existing paragraphs into a new list.",
+      expectedResult: "Returns a ListsCreateResult with the new listId and the first item address.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "non-idempotent",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/create.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.attach": {
+      memberPath: "lists.attach",
+      description: "Convert non-list paragraphs to list items under an existing list sequence.",
+      expectedResult: "Returns a ListsMutateItemResult confirming attachment.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/attach.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.detach": {
+      memberPath: "lists.detach",
+      description: "Remove numbering properties from list items, converting them to plain paragraphs.",
+      expectedResult: "Returns a ListsDetachResult confirming the item was converted to a plain paragraph.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
         idempotency: "conditional",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        possibleFailureCodes: ["INVALID_TARGET"],
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
       }),
-      referenceDocPath: "lists/set-type.mdx",
+      referenceDocPath: "lists/detach.mdx",
       referenceGroup: "lists"
     },
     "lists.indent": {
@@ -1980,7 +2010,7 @@ var init_operation_definitions = __esm(() => {
         idempotency: "conditional",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
       }),
       referenceDocPath: "lists/indent.mdx",
@@ -1995,31 +2025,135 @@ var init_operation_definitions = __esm(() => {
         idempotency: "conditional",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
       }),
       referenceDocPath: "lists/outdent.mdx",
       referenceGroup: "lists"
     },
-    "lists.restart": {
-      memberPath: "lists.restart",
-      description: "Restart numbering of an ordered list at the target item.",
-      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if numbering already restarts at the target item.",
+    "lists.join": {
+      memberPath: "lists.join",
+      description: "Merge two adjacent list sequences into one.",
+      expectedResult: "Returns a ListsJoinResult with the resulting listId of the merged sequence.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: [
+          "INVALID_TARGET",
+          "NO_ADJACENT_SEQUENCE",
+          "INCOMPATIBLE_DEFINITIONS",
+          "ALREADY_SAME_SEQUENCE"
+        ],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/join.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.canJoin": {
+      memberPath: "lists.canJoin",
+      description: "Check whether two adjacent list sequences can be joined.",
+      expectedResult: "Returns a ListsCanJoinResult indicating feasibility and reason if not possible.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: ["TARGET_NOT_FOUND", "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/can-join.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.separate": {
+      memberPath: "lists.separate",
+      description: "Split a list sequence at the target item, creating a new sequence from that point forward.",
+      expectedResult: "Returns a ListsSeparateResult with the new listId and numId.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/separate.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevel": {
+      memberPath: "lists.setLevel",
+      description: "Set the absolute nesting level (0..8) of a list item.",
+      expectedResult: "Returns a ListsMutateItemResult receipt; reports NO_OP if already at the target level.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE", "NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/set-level.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setValue": {
+      memberPath: "lists.setValue",
+      description: "Set an explicit numbering value at the target item. Mid-sequence targets are atomically separated first.",
+      expectedResult: "Returns a ListsMutateItemResult receipt.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/set-value.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.continuePrevious": {
+      memberPath: "lists.continuePrevious",
+      description: "Continue numbering from the nearest compatible previous list sequence.",
+      expectedResult: "Returns a ListsMutateItemResult receipt.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
         idempotency: "conditional",
         supportsDryRun: true,
         supportsTrackedMode: false,
-        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        possibleFailureCodes: ["INVALID_TARGET", "NO_COMPATIBLE_PREVIOUS", "ALREADY_CONTINUOUS"],
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
       }),
-      referenceDocPath: "lists/restart.mdx",
+      referenceDocPath: "lists/continue-previous.mdx",
       referenceGroup: "lists"
     },
-    "lists.exit": {
-      memberPath: "lists.exit",
-      description: "Exit a list context, converting the target item to a paragraph.",
-      expectedResult: "Returns a ListsExitResult confirming the item was converted to a plain paragraph.",
+    "lists.canContinuePrevious": {
+      memberPath: "lists.canContinuePrevious",
+      description: "Check whether the target sequence can continue numbering from a previous compatible sequence.",
+      expectedResult: "Returns a ListsCanContinuePreviousResult indicating feasibility.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: ["TARGET_NOT_FOUND", "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "lists/can-continue-previous.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.setLevelRestart": {
+      memberPath: "lists.setLevelRestart",
+      description: "Set the restart behavior for a specific list level.",
+      expectedResult: "Returns a ListsMutateItemResult receipt.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        possibleFailureCodes: ["INVALID_TARGET", "LEVEL_OUT_OF_RANGE"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
+      }),
+      referenceDocPath: "lists/set-level-restart.mdx",
+      referenceGroup: "lists"
+    },
+    "lists.convertToText": {
+      memberPath: "lists.convertToText",
+      description: "Convert list items to plain paragraphs, optionally prepending the rendered marker text.",
+      expectedResult: "Returns a ListsConvertToTextResult confirming the conversion.",
       requiresDocumentContext: true,
       metadata: mutationOperation({
         idempotency: "conditional",
@@ -2028,7 +2162,7 @@ var init_operation_definitions = __esm(() => {
         possibleFailureCodes: ["INVALID_TARGET"],
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET"]
       }),
-      referenceDocPath: "lists/exit.mdx",
+      referenceDocPath: "lists/convert-to-text.mdx",
       referenceGroup: "lists"
     },
     "comments.create": {
@@ -3525,11 +3659,6 @@ function listsMutateItemResultSchemaFor(operationId) {
     oneOf: [listsMutateItemSuccessSchema, listsFailureSchemaFor(operationId)]
   };
 }
-function listsExitResultSchemaFor(operationId) {
-  return {
-    oneOf: [listsExitSuccessSchema, listsFailureSchemaFor(operationId)]
-  };
-}
 function sectionMutationFailureSchemaFor(operationId) {
   return objectSchema({
     success: { const: false },
@@ -3802,7 +3931,19 @@ var init_schemas = __esm(() => {
       }),
       ref: { type: "string" },
       runs: arraySchema(ref("MatchRun"))
-    }, ["blockId", "nodeType", "range", "text", "ref", "runs"])
+    }, ["blockId", "nodeType", "range", "text", "ref", "runs"]),
+    BlockAddress: objectSchema({
+      kind: { const: "block" },
+      nodeType: { const: "paragraph" },
+      nodeId: { type: "string" }
+    }, ["kind", "nodeType", "nodeId"]),
+    BlockRange: objectSchema({
+      from: ref("BlockAddress"),
+      to: ref("BlockAddress")
+    }, ["from", "to"]),
+    BlockAddressOrRange: {
+      oneOf: [ref("BlockAddress"), ref("BlockRange")]
+    }
   };
   rangeSchema = ref("Range");
   positionSchema = ref("Position");
@@ -3957,22 +4098,24 @@ var init_schemas = __esm(() => {
   listInsertPositionSchema = { enum: ["before", "after"] };
   listItemInfoSchema = objectSchema({
     address: listItemAddressSchema,
+    listId: { type: "string" },
     marker: { type: "string" },
     ordinal: { type: "integer" },
     path: arraySchema({ type: "integer" }),
     level: { type: "integer" },
     kind: listKindSchema,
     text: { type: "string" }
-  }, ["address"]);
+  }, ["address", "listId"]);
   listItemDomainItemSchema = discoveryItemSchema({
     address: listItemAddressSchema,
+    listId: { type: "string" },
     marker: { type: "string" },
     ordinal: { type: "integer" },
     path: arraySchema({ type: "integer" }),
     level: { type: "integer" },
     kind: listKindSchema,
     text: { type: "string" }
-  }, ["address"]);
+  }, ["address", "listId"]);
   listsListResultSchema = discoveryResultSchema(listItemDomainItemSchema);
   sectionBreakTypeSchema = { enum: ["continuous", "nextPage", "evenPage", "oddPage"] };
   sectionOrientationSchema = { enum: ["portrait", "landscape"] };
@@ -5066,14 +5209,61 @@ var init_schemas = __esm(() => {
       success: listsInsertSuccessSchema,
       failure: listsFailureSchemaFor("lists.insert")
     },
-    "lists.setType": {
+    "lists.create": {
+      input: {
+        type: "object",
+        properties: {
+          mode: { enum: ["empty", "fromParagraphs"] },
+          at: ref("BlockAddress"),
+          target: ref("BlockAddressOrRange"),
+          kind: listKindSchema,
+          level: { type: "integer", minimum: 0, maximum: 8 }
+        },
+        required: ["mode", "kind"],
+        additionalProperties: false,
+        if: { properties: { mode: { const: "empty" } } },
+        then: { required: ["mode", "kind", "at"] },
+        else: { required: ["mode", "kind", "target"] }
+      },
+      output: {
+        oneOf: [
+          objectSchema({ success: { const: true }, listId: { type: "string" }, item: listItemAddressSchema }, [
+            "success",
+            "listId",
+            "item"
+          ]),
+          listsFailureSchemaFor("lists.create")
+        ]
+      },
+      success: objectSchema({ success: { const: true }, listId: { type: "string" }, item: listItemAddressSchema }, [
+        "success",
+        "listId",
+        "item"
+      ]),
+      failure: listsFailureSchemaFor("lists.create")
+    },
+    "lists.attach": {
       input: objectSchema({
-        target: listItemAddressSchema,
-        kind: listKindSchema
-      }, ["target", "kind"]),
-      output: listsMutateItemResultSchemaFor("lists.setType"),
+        target: ref("BlockAddressOrRange"),
+        attachTo: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 }
+      }, ["target", "attachTo"]),
+      output: listsMutateItemResultSchemaFor("lists.attach"),
       success: listsMutateItemSuccessSchema,
-      failure: listsFailureSchemaFor("lists.setType")
+      failure: listsFailureSchemaFor("lists.attach")
+    },
+    "lists.detach": {
+      input: objectSchema({
+        target: listItemAddressSchema
+      }, ["target"]),
+      output: {
+        oneOf: [
+          objectSchema({ success: { const: true }, paragraph: ref("ParagraphAddress") }, ["success", "paragraph"]),
+          listsFailureSchemaFor("lists.detach")
+        ]
+      },
+      success: objectSchema({ success: { const: true }, paragraph: ref("ParagraphAddress") }, ["success", "paragraph"]),
+      failure: listsFailureSchemaFor("lists.detach")
     },
     "lists.indent": {
       input: objectSchema({
@@ -5091,21 +5281,113 @@ var init_schemas = __esm(() => {
       success: listsMutateItemSuccessSchema,
       failure: listsFailureSchemaFor("lists.outdent")
     },
-    "lists.restart": {
+    "lists.join": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        direction: { enum: ["withPrevious", "withNext"] }
+      }, ["target", "direction"]),
+      output: {
+        oneOf: [
+          objectSchema({ success: { const: true }, listId: { type: "string" } }, ["success", "listId"]),
+          listsFailureSchemaFor("lists.join")
+        ]
+      },
+      success: objectSchema({ success: { const: true }, listId: { type: "string" } }, ["success", "listId"]),
+      failure: listsFailureSchemaFor("lists.join")
+    },
+    "lists.canJoin": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        direction: { enum: ["withPrevious", "withNext"] }
+      }, ["target", "direction"]),
+      output: objectSchema({
+        canJoin: { type: "boolean" },
+        reason: { enum: ["NO_ADJACENT_SEQUENCE", "INCOMPATIBLE_DEFINITIONS", "ALREADY_SAME_SEQUENCE"] },
+        adjacentListId: { type: "string" }
+      }, ["canJoin"])
+    },
+    "lists.separate": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        copyOverrides: { type: "boolean" }
+      }, ["target"]),
+      output: {
+        oneOf: [
+          objectSchema({ success: { const: true }, listId: { type: "string" }, numId: { type: "integer" } }, [
+            "success",
+            "listId",
+            "numId"
+          ]),
+          listsFailureSchemaFor("lists.separate")
+        ]
+      },
+      success: objectSchema({ success: { const: true }, listId: { type: "string" }, numId: { type: "integer" } }, [
+        "success",
+        "listId",
+        "numId"
+      ]),
+      failure: listsFailureSchemaFor("lists.separate")
+    },
+    "lists.setLevel": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 }
+      }, ["target", "level"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevel"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevel")
+    },
+    "lists.setValue": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        value: { type: ["integer", "null"] }
+      }, ["target", "value"]),
+      output: listsMutateItemResultSchemaFor("lists.setValue"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setValue")
+    },
+    "lists.continuePrevious": {
       input: objectSchema({
         target: listItemAddressSchema
       }, ["target"]),
-      output: listsMutateItemResultSchemaFor("lists.restart"),
+      output: listsMutateItemResultSchemaFor("lists.continuePrevious"),
       success: listsMutateItemSuccessSchema,
-      failure: listsFailureSchemaFor("lists.restart")
+      failure: listsFailureSchemaFor("lists.continuePrevious")
     },
-    "lists.exit": {
+    "lists.canContinuePrevious": {
       input: objectSchema({
         target: listItemAddressSchema
       }, ["target"]),
-      output: listsExitResultSchemaFor("lists.exit"),
-      success: listsExitSuccessSchema,
-      failure: listsFailureSchemaFor("lists.exit")
+      output: objectSchema({
+        canContinue: { type: "boolean" },
+        reason: { enum: ["NO_PREVIOUS_LIST", "INCOMPATIBLE_DEFINITIONS", "ALREADY_CONTINUOUS"] },
+        previousListId: { type: "string" }
+      }, ["canContinue"])
+    },
+    "lists.setLevelRestart": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        level: { type: "integer", minimum: 0, maximum: 8 },
+        restartAfterLevel: { type: ["integer", "null"] },
+        scope: { enum: ["definition", "instance"] }
+      }, ["target", "level", "restartAfterLevel"]),
+      output: listsMutateItemResultSchemaFor("lists.setLevelRestart"),
+      success: listsMutateItemSuccessSchema,
+      failure: listsFailureSchemaFor("lists.setLevelRestart")
+    },
+    "lists.convertToText": {
+      input: objectSchema({
+        target: listItemAddressSchema,
+        includeMarker: { type: "boolean" }
+      }, ["target"]),
+      output: {
+        oneOf: [
+          objectSchema({ success: { const: true }, paragraph: ref("ParagraphAddress") }, ["success", "paragraph"]),
+          listsFailureSchemaFor("lists.convertToText")
+        ]
+      },
+      success: objectSchema({ success: { const: true }, paragraph: ref("ParagraphAddress") }, ["success", "paragraph"]),
+      failure: listsFailureSchemaFor("lists.convertToText")
     },
     "comments.create": {
       input: objectSchema({
@@ -6757,10 +7039,6 @@ function executeListsInsert(adapter, input, options) {
   validateListTarget(input, "lists.insert");
   return adapter.insert(input, normalizeMutationOptions(options));
 }
-function executeListsSetType(adapter, input, options) {
-  validateListTarget(input, "lists.setType");
-  return adapter.setType(input, normalizeMutationOptions(options));
-}
 function executeListsIndent(adapter, input, options) {
   validateListTarget(input, "lists.indent");
   return adapter.indent(input, normalizeMutationOptions(options));
@@ -6769,13 +7047,52 @@ function executeListsOutdent(adapter, input, options) {
   validateListTarget(input, "lists.outdent");
   return adapter.outdent(input, normalizeMutationOptions(options));
 }
-function executeListsRestart(adapter, input, options) {
-  validateListTarget(input, "lists.restart");
-  return adapter.restart(input, normalizeMutationOptions(options));
+function executeListsCreate(adapter, input, options) {
+  return adapter.create(input, normalizeMutationOptions(options));
+}
+function executeListsAttach(adapter, input, options) {
+  validateListTarget(input, "lists.attach");
+  return adapter.attach(input, normalizeMutationOptions(options));
 }
-function executeListsExit(adapter, input, options) {
-  validateListTarget(input, "lists.exit");
-  return adapter.exit(input, normalizeMutationOptions(options));
+function executeListsDetach(adapter, input, options) {
+  validateListTarget(input, "lists.detach");
+  return adapter.detach(input, normalizeMutationOptions(options));
+}
+function executeListsJoin(adapter, input, options) {
+  validateListTarget(input, "lists.join");
+  return adapter.join(input, normalizeMutationOptions(options));
+}
+function executeListsCanJoin(adapter, input) {
+  validateListTarget(input, "lists.canJoin");
+  return adapter.canJoin(input);
+}
+function executeListsSeparate(adapter, input, options) {
+  validateListTarget(input, "lists.separate");
+  return adapter.separate(input, normalizeMutationOptions(options));
+}
+function executeListsSetLevel(adapter, input, options) {
+  validateListTarget(input, "lists.setLevel");
+  return adapter.setLevel(input, normalizeMutationOptions(options));
+}
+function executeListsSetValue(adapter, input, options) {
+  validateListTarget(input, "lists.setValue");
+  return adapter.setValue(input, normalizeMutationOptions(options));
+}
+function executeListsContinuePrevious(adapter, input, options) {
+  validateListTarget(input, "lists.continuePrevious");
+  return adapter.continuePrevious(input, normalizeMutationOptions(options));
+}
+function executeListsCanContinuePrevious(adapter, input) {
+  validateListTarget(input, "lists.canContinuePrevious");
+  return adapter.canContinuePrevious(input);
+}
+function executeListsSetLevelRestart(adapter, input, options) {
+  validateListTarget(input, "lists.setLevelRestart");
+  return adapter.setLevelRestart(input, normalizeMutationOptions(options));
+}
+function executeListsConvertToText(adapter, input, options) {
+  validateListTarget(input, "lists.convertToText");
+  return adapter.convertToText(input, normalizeMutationOptions(options));
 }
 var init_lists = __esm(() => {
   init_errors2();
@@ -7094,11 +7411,20 @@ function buildDispatchTable(api) {
     "lists.list": (input) => api.lists.list(input),
     "lists.get": (input) => api.lists.get(input),
     "lists.insert": (input, options) => api.lists.insert(input, options),
-    "lists.setType": (input, options) => api.lists.setType(input, options),
+    "lists.create": (input, options) => api.lists.create(input, options),
+    "lists.attach": (input, options) => api.lists.attach(input, options),
+    "lists.detach": (input, options) => api.lists.detach(input, options),
     "lists.indent": (input, options) => api.lists.indent(input, options),
     "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),
+    "lists.join": (input, options) => api.lists.join(input, options),
+    "lists.canJoin": (input) => api.lists.canJoin(input),
+    "lists.separate": (input, options) => api.lists.separate(input, options),
+    "lists.setLevel": (input, options) => api.lists.setLevel(input, options),
+    "lists.setValue": (input, options) => api.lists.setValue(input, options),
+    "lists.continuePrevious": (input, options) => api.lists.continuePrevious(input, options),
+    "lists.canContinuePrevious": (input) => api.lists.canContinuePrevious(input),
+    "lists.setLevelRestart": (input, options) => api.lists.setLevelRestart(input, options),
+    "lists.convertToText": (input, options) => api.lists.convertToText(input, options),
     "sections.list": (input) => api.sections.list(input),
     "sections.get": (input) => api.sections.get(input),
     "sections.setBreakType": (input, options) => api.sections.setBreakType(input, options),
@@ -7864,8 +8190,14 @@ function createDocumentApi(adapters) {
       insert(input, options) {
         return executeListsInsert(adapters.lists, input, options);
       },
-      setType(input, options) {
-        return executeListsSetType(adapters.lists, input, options);
+      create(input, options) {
+        return executeListsCreate(adapters.lists, input, options);
+      },
+      attach(input, options) {
+        return executeListsAttach(adapters.lists, input, options);
+      },
+      detach(input, options) {
+        return executeListsDetach(adapters.lists, input, options);
       },
       indent(input, options) {
         return executeListsIndent(adapters.lists, input, options);
@@ -7873,11 +8205,32 @@ function createDocumentApi(adapters) {
       outdent(input, options) {
         return executeListsOutdent(adapters.lists, input, options);
       },
-      restart(input, options) {
-        return executeListsRestart(adapters.lists, input, options);
+      join(input, options) {
+        return executeListsJoin(adapters.lists, input, options);
+      },
+      canJoin(input) {
+        return executeListsCanJoin(adapters.lists, input);
+      },
+      separate(input, options) {
+        return executeListsSeparate(adapters.lists, input, options);
+      },
+      setLevel(input, options) {
+        return executeListsSetLevel(adapters.lists, input, options);
+      },
+      setValue(input, options) {
+        return executeListsSetValue(adapters.lists, input, options);
+      },
+      continuePrevious(input, options) {
+        return executeListsContinuePrevious(adapters.lists, input, options);
       },
-      exit(input, options) {
-        return executeListsExit(adapters.lists, input, options);
+      canContinuePrevious(input) {
+        return executeListsCanContinuePrevious(adapters.lists, input);
+      },
+      setLevelRestart(input, options) {
+        return executeListsSetLevelRestart(adapters.lists, input, options);
+      },
+      convertToText(input, options) {
+        return executeListsConvertToText(adapters.lists, input, options);
       }
     },
     sections: {
@@ -8248,17 +8601,28 @@ async function pathExists(path) {
 var init_guards = () => {};
 
 // src/lib/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { copyFile, mkdir, open, readdir, readFile as readFile2, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { homedir, hostname } from "node:os";
 import { join, resolve } from "node:path";
 function getStateRoot() {
+  const scopedOverride = STATE_DIR_OVERRIDE_STORAGE.getStore();
+  if (scopedOverride && scopedOverride.length > 0) {
+    return scopedOverride;
+  }
   const override = process.env.SUPERDOC_CLI_STATE_DIR;
   if (override && override.length > 0) {
     return resolve(override);
   }
   return join(homedir(), ".superdoc-cli", "state", CONTEXT_VERSION);
 }
+async function withStateDirOverride(stateDir, operation) {
+  if (stateDir == null || stateDir.length === 0) {
+    return operation();
+  }
+  return STATE_DIR_OVERRIDE_STORAGE.run(resolve(stateDir), operation);
+}
 function getContextPaths(contextId) {
   const normalizedContextId = validateSessionId(contextId, "session id");
   const stateRoot = getStateRoot();
@@ -8776,11 +9140,12 @@ function createInitialContextMetadata(io, paths, contextId, input) {
     sourceSnapshot: input.sourceSnapshot
   };
 }
-var CONTEXT_VERSION = "v1", ACTIVE_SESSION_FILENAME = "active-session", DEFAULT_LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_INTERVAL_MS = 50;
+var CONTEXT_VERSION = "v1", ACTIVE_SESSION_FILENAME = "active-session", DEFAULT_LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_INTERVAL_MS = 50, STATE_DIR_OVERRIDE_STORAGE;
 var init_context = __esm(() => {
   init_errors();
   init_guards();
   init_session();
+  STATE_DIR_OVERRIDE_STORAGE = new AsyncLocalStorage;
 });
 
 // src/cli/operation-hints.ts
@@ -8838,11 +9203,20 @@ var init_operation_hints = __esm(() => {
     "lists.list": "listed items",
     "lists.get": "resolved list item",
     "lists.insert": "inserted list item",
-    "lists.setType": "set list type",
     "lists.indent": "indented list item",
     "lists.outdent": "outdented list item",
-    "lists.restart": "restarted list numbering",
-    "lists.exit": "exited list item",
+    "lists.create": "created list",
+    "lists.attach": "attached to list",
+    "lists.detach": "detached from list",
+    "lists.join": "joined lists",
+    "lists.canJoin": "checked join feasibility",
+    "lists.separate": "separated list",
+    "lists.setLevel": "set list level",
+    "lists.setValue": "set list value",
+    "lists.continuePrevious": "continued previous list",
+    "lists.canContinuePrevious": "checked continue feasibility",
+    "lists.setLevelRestart": "set level restart",
+    "lists.convertToText": "converted list to text",
     "comments.create": "created comment",
     "comments.patch": "patched comment",
     "comments.delete": "deleted comment",
@@ -8929,11 +9303,20 @@ var init_operation_hints = __esm(() => {
     "lists.list": "listResult",
     "lists.get": "listItemInfo",
     "lists.insert": "listsMutationResult",
-    "lists.setType": "listsMutationResult",
     "lists.indent": "listsMutationResult",
     "lists.outdent": "listsMutationResult",
-    "lists.restart": "listsMutationResult",
-    "lists.exit": "listsMutationResult",
+    "lists.create": "listsMutationResult",
+    "lists.attach": "listsMutationResult",
+    "lists.detach": "listsMutationResult",
+    "lists.join": "listsMutationResult",
+    "lists.canJoin": "plain",
+    "lists.separate": "listsMutationResult",
+    "lists.setLevel": "listsMutationResult",
+    "lists.setValue": "listsMutationResult",
+    "lists.continuePrevious": "listsMutationResult",
+    "lists.canContinuePrevious": "plain",
+    "lists.setLevelRestart": "listsMutationResult",
+    "lists.convertToText": "listsMutationResult",
     "comments.create": "commentReceipt",
     "comments.patch": "commentReceipt",
     "comments.delete": "commentReceipt",
@@ -9020,11 +9403,20 @@ var init_operation_hints = __esm(() => {
     "lists.list": "result",
     "lists.get": "item",
     "lists.insert": "result",
-    "lists.setType": "result",
     "lists.indent": "result",
     "lists.outdent": "result",
-    "lists.restart": "result",
-    "lists.exit": "result",
+    "lists.create": "result",
+    "lists.attach": "result",
+    "lists.detach": "result",
+    "lists.join": "result",
+    "lists.canJoin": "result",
+    "lists.separate": "result",
+    "lists.setLevel": "result",
+    "lists.setValue": "result",
+    "lists.continuePrevious": "result",
+    "lists.canContinuePrevious": "result",
+    "lists.setLevelRestart": "result",
+    "lists.convertToText": "result",
     "comments.create": "receipt",
     "comments.patch": "receipt",
     "comments.delete": "receipt",
@@ -9118,11 +9510,20 @@ var init_operation_hints = __esm(() => {
     "lists.list": "lists",
     "lists.get": "lists",
     "lists.insert": "lists",
-    "lists.setType": "lists",
     "lists.indent": "lists",
     "lists.outdent": "lists",
-    "lists.restart": "lists",
-    "lists.exit": "lists",
+    "lists.create": "lists",
+    "lists.attach": "lists",
+    "lists.detach": "lists",
+    "lists.join": "lists",
+    "lists.canJoin": "lists",
+    "lists.separate": "lists",
+    "lists.setLevel": "lists",
+    "lists.setValue": "lists",
+    "lists.continuePrevious": "lists",
+    "lists.canContinuePrevious": "lists",
+    "lists.setLevelRestart": "lists",
+    "lists.convertToText": "lists",
     "comments.create": "comments",
     "comments.patch": "comments",
     "comments.delete": "comments",
@@ -12156,11 +12557,18 @@ var init_capabilities_adapter = __esm(() => {
     "create.paragraph": ["insertParagraphAt"],
     "create.heading": ["insertHeadingAt"],
     "lists.insert": ["insertListItemAt"],
-    "lists.setType": ["setListTypeAt"],
-    "lists.indent": ["setTextSelection", "increaseListIndent"],
-    "lists.outdent": ["setTextSelection", "decreaseListIndent"],
-    "lists.restart": ["setTextSelection", "restartNumbering"],
-    "lists.exit": ["exitListItemAt"],
+    "lists.indent": [],
+    "lists.outdent": [],
+    "lists.create": [],
+    "lists.attach": [],
+    "lists.detach": [],
+    "lists.join": [],
+    "lists.separate": [],
+    "lists.setLevel": [],
+    "lists.setValue": [],
+    "lists.continuePrevious": [],
+    "lists.setLevelRestart": [],
+    "lists.convertToText": [],
     "blocks.delete": ["deleteBlockNodeById"],
     "comments.create": ["addComment", "setTextSelection", "addCommentReply"],
     "comments.patch": ["editComment", "moveComment", "resolveComment", "setCommentInternal"],
@@ -67900,6 +68308,47 @@ var init_footnotesExporter = __esm(() => {
   init_relationship_helpers();
 });
 
+// ../../packages/super-editor/src/core/super-converter/export-helpers/strip-orphaned-numbering.js
+function collectReferencedNumIds(convertedXml) {
+  const numIds = new Set;
+  function walkElements(elements) {
+    if (!Array.isArray(elements))
+      return;
+    for (const el of elements) {
+      if (el.name === "w:numId" && el.attributes?.["w:val"] != null) {
+        numIds.add(Number(el.attributes["w:val"]));
+      }
+      if (el.elements)
+        walkElements(el.elements);
+    }
+  }
+  for (const [path2, xml] of Object.entries(convertedXml)) {
+    if (path2.startsWith("word/") && path2 !== "word/numbering.xml" && xml?.elements) {
+      walkElements(xml.elements);
+    }
+  }
+  return numIds;
+}
+function getAbstractNumIdFromDef(numDef) {
+  const abstractEl = numDef.elements?.find((el) => el.name === "w:abstractNumId");
+  if (abstractEl?.attributes?.["w:val"] != null) {
+    return Number(abstractEl.attributes["w:val"]);
+  }
+  return;
+}
+function filterOrphanedNumberingDefinitions(numbering, referencedNumIds) {
+  const liveDefinitions = Object.values(numbering.definitions).filter((def) => referencedNumIds.has(Number(def.attributes?.["w:numId"])));
+  const referencedAbstractIds = new Set;
+  for (const def of liveDefinitions) {
+    const abstractId = getAbstractNumIdFromDef(def);
+    if (abstractId != null) {
+      referencedAbstractIds.add(abstractId);
+    }
+  }
+  const liveAbstracts = Object.values(numbering.abstracts).filter((abs2) => referencedAbstractIds.has(Number(abs2.attributes?.["w:abstractNumId"])));
+  return { liveAbstracts, liveDefinitions };
+}
+
 // ../../packages/super-editor/src/core/super-converter/SuperConverter.js
 function generateCustomXml() {
   return DEFAULT_CUSTOM_XML;
@@ -68690,13 +69139,12 @@ var init_SuperConverter = __esm(() => {
     #exportNumberingFile() {
       const numberingPath = "word/numbering.xml";
       let numberingXml = this.convertedXml[numberingPath];
-      const newNumbering = this.numbering;
       if (!numberingXml)
         numberingXml = baseNumbering;
       const currentNumberingXml = numberingXml.elements[0];
-      const newAbstracts = Object.values(newNumbering.abstracts).map((entry) => entry);
-      const newNumDefs = Object.values(newNumbering.definitions).map((entry) => entry);
-      currentNumberingXml.elements = [...newAbstracts, ...newNumDefs];
+      const referencedNumIds = collectReferencedNumIds(this.convertedXml);
+      const { liveAbstracts, liveDefinitions } = filterOrphanedNumberingDefinitions(this.numbering, referencedNumIds);
+      currentNumberingXml.elements = [...liveAbstracts, ...liveDefinitions];
       this.convertedXml[numberingPath] = numberingXml;
     }
     #prepareCommentsXmlFilesForExport({ defs, exportType, commentsWithParaIds }) {
@@ -69816,7 +70264,7 @@ var generateNewListDefinition = ({ numId, listType, level, start, text: text5, f
       "w:abstractNumId": String(newAbstractId)
     }
   }));
-  if (level && start && text5 && fmt) {
+  if (level != null && start != null && text5 != null && fmt != null) {
     if (newNumbering.definitions[numId]) {
       const abstractId = newNumbering.definitions[numId]?.elements[0]?.attributes["w:val"];
       newAbstractId = abstractId;
@@ -70094,6 +70542,153 @@ var generateNewListDefinition = ({ numId, listType, level, start, text: text5, f
   return true;
 }, replaceListWithNode = ({ tr, from: from3, to, newNode }) => {
   tr.replaceWith(from3, to, newNode);
+}, setLvlOverride = (editor, numId, ilvl, overrides) => {
+  const numbering = editor.converter.numbering;
+  const numDef = numbering.definitions[numId];
+  if (!numDef)
+    return;
+  const ilvlStr = String(ilvl);
+  if (!numDef.elements)
+    numDef.elements = [];
+  let overrideEl = numDef.elements.find((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvlStr);
+  if (!overrideEl) {
+    overrideEl = {
+      type: "element",
+      name: "w:lvlOverride",
+      attributes: { "w:ilvl": ilvlStr },
+      elements: []
+    };
+    numDef.elements.push(overrideEl);
+  }
+  if (!overrideEl.elements)
+    overrideEl.elements = [];
+  if (overrides.startOverride != null) {
+    const startEl = overrideEl.elements.find((el) => el.name === "w:startOverride");
+    if (startEl) {
+      startEl.attributes["w:val"] = String(overrides.startOverride);
+    } else {
+      overrideEl.elements.push({
+        type: "element",
+        name: "w:startOverride",
+        attributes: { "w:val": String(overrides.startOverride) }
+      });
+    }
+  }
+  if ("lvlRestart" in overrides) {
+    let lvlEl = overrideEl.elements.find((el) => el.name === "w:lvl");
+    if (!lvlEl) {
+      lvlEl = {
+        type: "element",
+        name: "w:lvl",
+        attributes: { "w:ilvl": ilvlStr },
+        elements: []
+      };
+      overrideEl.elements.push(lvlEl);
+    }
+    if (!lvlEl.elements)
+      lvlEl.elements = [];
+    if (overrides.lvlRestart === null) {
+      lvlEl.elements = lvlEl.elements.filter((el) => el.name !== "w:lvlRestart");
+    } else {
+      const restartEl = lvlEl.elements.find((el) => el.name === "w:lvlRestart");
+      if (restartEl) {
+        restartEl.attributes["w:val"] = String(overrides.lvlRestart);
+      } else {
+        lvlEl.elements.push({
+          type: "element",
+          name: "w:lvlRestart",
+          attributes: { "w:val": String(overrides.lvlRestart) }
+        });
+      }
+    }
+  }
+  numbering.definitions[numId] = numDef;
+  editor.converter.numbering = { ...numbering };
+  syncTranslatedDefinition(editor, numId, numDef);
+  emitDefinitionChange(editor, numDef);
+}, removeLvlOverride = (editor, numId, ilvl) => {
+  const numbering = editor.converter.numbering;
+  const numDef = numbering.definitions[numId];
+  if (!numDef?.elements)
+    return;
+  const ilvlStr = String(ilvl);
+  const idx = numDef.elements.findIndex((el) => el.name === "w:lvlOverride" && el.attributes?.["w:ilvl"] === ilvlStr);
+  if (idx === -1)
+    return;
+  numDef.elements.splice(idx, 1);
+  numbering.definitions[numId] = numDef;
+  editor.converter.numbering = { ...numbering };
+  syncTranslatedDefinition(editor, numId, numDef);
+  emitDefinitionChange(editor, numDef);
+}, syncTranslatedDefinition = (editor, numId, rawNumDef) => {
+  const translated = { ...editor.converter.translatedNumbering || {} };
+  if (!translated.definitions)
+    translated.definitions = {};
+  translated.definitions[numId] = translator195.encode({ nodes: [rawNumDef] });
+  editor.converter.translatedNumbering = translated;
+}, emitDefinitionChange = (editor, numDef) => {
+  editor.emit("list-definitions-change", {
+    change: { numDef, editor },
+    numbering: editor.converter.numbering,
+    editor
+  });
+}, createNumDefinition = (editor, abstractNumId, options = {}) => {
+  const numId = getNewListId(editor, "definitions");
+  const numDef = getBasicNumIdTag(numId, abstractNumId);
+  if (options.copyOverridesFrom != null) {
+    const sourceNumDef = editor.converter.numbering.definitions[options.copyOverridesFrom];
+    if (sourceNumDef?.elements) {
+      const overrideEls = sourceNumDef.elements.filter((el) => el.name === "w:lvlOverride");
+      if (overrideEls.length > 0) {
+        numDef.elements = [...numDef.elements, ...JSON.parse(JSON.stringify(overrideEls))];
+      }
+    }
+  }
+  const numbering = editor.converter.numbering;
+  numbering.definitions[numId] = numDef;
+  editor.converter.numbering = { ...numbering };
+  syncTranslatedDefinition(editor, numId, numDef);
+  emitDefinitionChange(editor, numDef);
+  return { numId, numDef };
+}, setLvlRestartOnAbstract = (editor, abstractNumId, ilvl, restartAfterLevel) => {
+  const numbering = editor.converter.numbering;
+  const abstract = numbering.abstracts[abstractNumId];
+  if (!abstract?.elements)
+    return;
+  const ilvlStr = String(ilvl);
+  const lvlEl = abstract.elements.find((el) => el.name === "w:lvl" && el.attributes?.["w:ilvl"] === ilvlStr);
+  if (!lvlEl)
+    return;
+  if (!lvlEl.elements)
+    lvlEl.elements = [];
+  if (restartAfterLevel === null) {
+    lvlEl.elements = lvlEl.elements.filter((el) => el.name !== "w:lvlRestart");
+  } else {
+    const restartEl = lvlEl.elements.find((el) => el.name === "w:lvlRestart");
+    if (restartEl) {
+      restartEl.attributes["w:val"] = String(restartAfterLevel);
+    } else {
+      lvlEl.elements.push({
+        type: "element",
+        name: "w:lvlRestart",
+        attributes: { "w:val": String(restartAfterLevel) }
+      });
+    }
+  }
+  numbering.abstracts[abstractNumId] = abstract;
+  editor.converter.numbering = { ...numbering };
+  const translated = { ...editor.converter.translatedNumbering || {} };
+  if (!translated.abstracts)
+    translated.abstracts = {};
+  translated.abstracts[abstractNumId] = translator181.encode({ nodes: [abstract] });
+  editor.converter.translatedNumbering = translated;
+  const definitions = numbering.definitions || {};
+  for (const [, numDef] of Object.entries(definitions)) {
+    const absId = numDef?.elements?.find((el) => el.name === "w:abstractNumId")?.attributes?.["w:val"];
+    if (absId != null && Number(absId) === abstractNumId) {
+      emitDefinitionChange(editor, numDef);
+    }
+  }
 }, ListHelpers;
 var init_list_numbering_helpers = __esm(() => {
   init_listImporter();
@@ -70111,6 +70706,10 @@ var init_list_numbering_helpers = __esm(() => {
     getNewListId,
     hasListDefinition,
     removeListDefinitions,
+    setLvlOverride,
+    removeLvlOverride,
+    createNumDefinition,
+    setLvlRestartOnAbstract,
     createNewList,
     createSchemaOrderedListNode,
     createListItemNodeJSON,
@@ -73205,6 +73804,220 @@ var init_blocks_wrappers = __esm(() => {
   REJECTED_NODE_TYPES = new Set(["tableRow", "tableCell"]);
 });
 
+// ../../packages/super-editor/src/document-api-adapters/helpers/list-sequence-helpers.ts
+function resolveBlock(editor, nodeId) {
+  const index2 = getBlockIndex(editor);
+  const matches2 = index2.candidates.filter((c) => c.nodeId === nodeId && (c.nodeType === "paragraph" || c.nodeType === "listItem"));
+  if (matches2.length === 0) {
+    throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "Block target was not found.", { nodeId });
+  }
+  if (matches2.length > 1) {
+    throw new DocumentApiAdapterError("INVALID_TARGET", "Block target id is ambiguous.", {
+      nodeId,
+      count: matches2.length
+    });
+  }
+  return matches2[0];
+}
+function resolveBlocksInRange(editor, fromId, toId2) {
+  const from3 = resolveBlock(editor, fromId);
+  const to = resolveBlock(editor, toId2);
+  if (from3.pos > to.pos) {
+    throw new DocumentApiAdapterError("INVALID_TARGET", 'Block range "from" must precede "to" in document order.', {
+      from: fromId,
+      to: toId2
+    });
+  }
+  const index2 = getBlockIndex(editor);
+  return index2.candidates.filter((c) => (c.nodeType === "paragraph" || c.nodeType === "listItem") && c.pos >= from3.pos && c.pos <= to.pos);
+}
+function getAbstractNumId(editor, numId) {
+  const converter = editor;
+  const definitions = converter.converter?.numbering?.definitions;
+  if (!definitions)
+    return;
+  const numDef = definitions[numId];
+  if (!numDef?.elements)
+    return;
+  const abstractEl = numDef.elements.find((el) => el.name === "w:abstractNumId");
+  const val = abstractEl?.attributes?.["w:val"];
+  return val != null ? Number(val) : undefined;
+}
+function getAllListItemProjections(editor) {
+  const index2 = getBlockIndex(editor);
+  return index2.candidates.filter((c) => c.nodeType === "listItem").map((c) => projectListItemCandidate(editor, c));
+}
+function getContiguousSequence(editor, target) {
+  if (target.numId == null)
+    return [target];
+  const allItems = getAllListItemProjections(editor);
+  const targetIdx = allItems.findIndex((item) => item.address.nodeId === target.address.nodeId);
+  if (targetIdx === -1)
+    return [target];
+  const numId = target.numId;
+  let startIdx = targetIdx;
+  for (let i = targetIdx - 1;i >= 0; i--) {
+    if (allItems[i].numId !== numId)
+      break;
+    startIdx = i;
+  }
+  let endIdx = targetIdx;
+  for (let i = targetIdx + 1;i < allItems.length; i++) {
+    if (allItems[i].numId !== numId)
+      break;
+    endIdx = i;
+  }
+  return allItems.slice(startIdx, endIdx + 1);
+}
+function getSequenceFromTarget(editor, target) {
+  const sequence = getContiguousSequence(editor, target);
+  const targetIdx = sequence.findIndex((item) => item.address.nodeId === target.address.nodeId);
+  return sequence.slice(targetIdx);
+}
+function isFirstInSequence(editor, target) {
+  const sequence = getContiguousSequence(editor, target);
+  return sequence.length > 0 && sequence[0].address.nodeId === target.address.nodeId;
+}
+function computeSequenceId(editor, projection) {
+  if (projection.numId == null)
+    return "";
+  const sequence = getContiguousSequence(editor, projection);
+  const anchor = sequence[0]?.address.nodeId ?? projection.address.nodeId;
+  return `${projection.numId}:${anchor}`;
+}
+function computeSequenceIdMap(items) {
+  const map5 = new Map;
+  let currentNumId;
+  let currentAnchor;
+  for (const item of items) {
+    if (item.numId == null) {
+      map5.set(item.address.nodeId, "");
+      currentNumId = undefined;
+      currentAnchor = undefined;
+      continue;
+    }
+    if (item.numId !== currentNumId) {
+      currentNumId = item.numId;
+      currentAnchor = item.address.nodeId;
+    }
+    map5.set(item.address.nodeId, `${currentNumId}:${currentAnchor}`);
+  }
+  return map5;
+}
+function findAdjacentSequence(editor, target, direction) {
+  if (target.numId == null)
+    return null;
+  const allItems = getAllListItemProjections(editor);
+  const sequence = getContiguousSequence(editor, target);
+  if (direction === "withNext") {
+    const lastInSequence = sequence[sequence.length - 1];
+    const lastIdx = allItems.findIndex((item) => item.address.nodeId === lastInSequence.address.nodeId);
+    for (let i = lastIdx + 1;i < allItems.length; i++) {
+      const item = allItems[i];
+      if (item.numId != null) {
+        const adjSequence = getContiguousSequence(editor, item);
+        return {
+          sequence: adjSequence,
+          numId: item.numId,
+          abstractNumId: getAbstractNumId(editor, item.numId)
+        };
+      }
+    }
+  } else {
+    const firstInSequence = sequence[0];
+    const firstIdx = allItems.findIndex((item) => item.address.nodeId === firstInSequence.address.nodeId);
+    for (let i = firstIdx - 1;i >= 0; i--) {
+      const item = allItems[i];
+      if (item.numId != null) {
+        const adjSequence = getContiguousSequence(editor, item);
+        return {
+          sequence: adjSequence,
+          numId: item.numId,
+          abstractNumId: getAbstractNumId(editor, item.numId)
+        };
+      }
+    }
+  }
+  return null;
+}
+function findPreviousCompatibleSequence(editor, target) {
+  if (target.numId == null)
+    return null;
+  const targetAbstractId = getAbstractNumId(editor, target.numId);
+  if (targetAbstractId == null)
+    return null;
+  const allItems = getAllListItemProjections(editor);
+  const sequence = getContiguousSequence(editor, target);
+  const firstInSequence = sequence[0];
+  const firstIdx = allItems.findIndex((item) => item.address.nodeId === firstInSequence.address.nodeId);
+  for (let i = firstIdx - 1;i >= 0; i--) {
+    const item = allItems[i];
+    if (item.numId == null)
+      continue;
+    const itemAbstractId = getAbstractNumId(editor, item.numId);
+    if (itemAbstractId === targetAbstractId && item.numId !== target.numId) {
+      return {
+        sequence: getContiguousSequence(editor, item),
+        numId: item.numId
+      };
+    }
+  }
+  return null;
+}
+function evaluateCanJoin(editor, target, direction) {
+  const adjacent = findAdjacentSequence(editor, target, direction);
+  if (!adjacent) {
+    return { canJoin: false, reason: "NO_ADJACENT_SEQUENCE" };
+  }
+  if (adjacent.numId === target.numId) {
+    return { canJoin: false, reason: "ALREADY_SAME_SEQUENCE" };
+  }
+  const targetAbstractId = target.numId != null ? getAbstractNumId(editor, target.numId) : undefined;
+  if (targetAbstractId == null || adjacent.abstractNumId == null || targetAbstractId !== adjacent.abstractNumId) {
+    return { canJoin: false, reason: "INCOMPATIBLE_DEFINITIONS" };
+  }
+  const adjacentAnchor = adjacent.sequence[0]?.address.nodeId ?? "";
+  return { canJoin: true, adjacentListId: `${adjacent.numId}:${adjacentAnchor}` };
+}
+function evaluateCanContinuePrevious(editor, target) {
+  if (target.numId == null) {
+    return { canContinue: false, reason: "NO_PREVIOUS_LIST" };
+  }
+  const targetAbstractId = getAbstractNumId(editor, target.numId);
+  if (targetAbstractId == null) {
+    return { canContinue: false, reason: "NO_PREVIOUS_LIST" };
+  }
+  const allItems = getAllListItemProjections(editor);
+  const sequence = getContiguousSequence(editor, target);
+  const firstInSequence = sequence[0];
+  const firstIdx = allItems.findIndex((item) => item.address.nodeId === firstInSequence.address.nodeId);
+  let foundAnyPrevious = false;
+  for (let i = firstIdx - 1;i >= 0; i--) {
+    const item = allItems[i];
+    if (item.numId == null)
+      continue;
+    foundAnyPrevious = true;
+    const itemAbstractId = getAbstractNumId(editor, item.numId);
+    if (itemAbstractId !== targetAbstractId)
+      continue;
+    if (item.numId === target.numId) {
+      return { canContinue: false, reason: "ALREADY_CONTINUOUS" };
+    }
+    const prevSequence = getContiguousSequence(editor, item);
+    const prevAnchor = prevSequence[0]?.address.nodeId ?? item.address.nodeId;
+    return { canContinue: true, previousListId: `${item.numId}:${prevAnchor}` };
+  }
+  if (!foundAnyPrevious) {
+    return { canContinue: false, reason: "NO_PREVIOUS_LIST" };
+  }
+  return { canContinue: false, reason: "INCOMPATIBLE_DEFINITIONS" };
+}
+var init_list_sequence_helpers = __esm(() => {
+  init_list_item_resolver();
+  init_index_cache();
+  init_errors3();
+});
+
 // ../../packages/super-editor/src/document-api-adapters/helpers/list-item-resolver.ts
 function toPath(value) {
   if (!Array.isArray(value))
@@ -73270,9 +74083,10 @@ function projectListItemCandidate(editor, candidate) {
     text: getListText(candidate)
   };
 }
-function listItemProjectionToInfo(projection) {
+function listItemProjectionToInfo(projection, listId) {
   return {
     address: projection.address,
+    listId,
     marker: projection.marker,
     ordinal: projection.ordinal,
     path: projection.path,
@@ -73317,9 +74131,6 @@ function isWithinScope(candidate, scope) {
     return true;
   return candidate.pos >= scope.start && candidate.end <= scope.end;
 }
-function listItemCandidatesInScope(index2, scope) {
-  return index2.candidates.filter((candidate) => candidate.nodeType === "listItem" && isWithinScope(candidate, scope));
-}
 function listListItems(editor, query2) {
   if (query2?.within && query2.within.kind !== "block") {
     throw new DocumentApiAdapterError("INVALID_TARGET", "lists.list only supports block within scopes.", {
@@ -73329,25 +74140,28 @@ function listListItems(editor, query2) {
   validatePaginationInput(query2?.offset, query2?.limit);
   const index2 = getBlockIndex(editor);
   const scope = resolveBlockScopeRange(index2, query2?.within);
-  const candidates = listItemCandidatesInScope(index2, scope);
+  const allCandidates = index2.candidates.filter((candidate) => candidate.nodeType === "listItem");
+  const allProjections = allCandidates.map((candidate) => projectListItemCandidate(editor, candidate));
+  const projections = allProjections.filter((projection) => isWithinScope(projection.candidate, scope));
   const safeOffset = query2?.offset ?? 0;
   const safeLimit = query2?.limit ?? Number.POSITIVE_INFINITY;
   const pageEnd = safeOffset + safeLimit;
   const evaluatedRevision = getRevision(editor);
+  const sequenceIds = computeSequenceIdMap(allProjections);
   let total = 0;
   const items = [];
-  for (const candidate of candidates) {
-    const projection = projectListItemCandidate(editor, candidate);
+  for (const projection of projections) {
     if (!matchesListQuery(projection, query2))
       continue;
     const currentIndex = total;
     total += 1;
     if (currentIndex < safeOffset || currentIndex >= pageEnd)
       continue;
-    const info = listItemProjectionToInfo(projection);
+    const listId = sequenceIds.get(projection.address.nodeId) ?? "";
+    const info = listItemProjectionToInfo(projection, listId);
     const handle2 = buildResolvedHandle(info.address.nodeId, "stable", "list");
     const { address: address2, marker, ordinal, path: path2, level, kind, text: text5 } = info;
-    items.push(buildDiscoveryItem(info.address.nodeId, handle2, { address: address2, marker, ordinal, path: path2, level, kind, text: text5 }));
+    items.push(buildDiscoveryItem(info.address.nodeId, handle2, { address: address2, listId, marker, ordinal, path: path2, level, kind, text: text5 }));
   }
   return buildDiscoveryResult({
     evaluatedRevision,
@@ -73379,12 +74193,24 @@ var init_list_item_resolver = __esm(() => {
   init_revision_tracker();
   init_index_cache();
   init_adapter_utils();
+  init_list_sequence_helpers();
 });
 
 // ../../packages/super-editor/src/document-api-adapters/plan-engine/lists-wrappers.ts
 function toListsFailure(code3, message, details) {
   return { success: false, failure: { code: code3, message, details } };
 }
+function dispatchEditorTransaction(editor, tr) {
+  if (typeof editor.dispatch === "function") {
+    editor.dispatch(tr);
+    return;
+  }
+  if (typeof editor.view?.dispatch === "function") {
+    editor.view.dispatch(tr);
+    return;
+  }
+  throw new DocumentApiAdapterError("INTERNAL_ERROR", "Cannot apply list mutation because no transaction dispatcher is available.", { reason: "missing_dispatch" });
+}
 function resolveInsertedListItem(editor, sdBlockId) {
   const index2 = getBlockIndex(editor);
   const byNodeId = index2.candidates.find((candidate) => candidate.nodeType === "listItem" && candidate.nodeId === sdBlockId);
@@ -73401,54 +74227,71 @@ function resolveInsertedListItem(editor, sdBlockId) {
   }
   throw new DocumentApiAdapterError("TARGET_NOT_FOUND", `Inserted list item with sdBlockId "${sdBlockId}" could not be resolved after insertion.`);
 }
-function selectionAnchorPos(item) {
-  return item.candidate.pos + 1;
-}
-function setSelectionToListItem(editor, item) {
-  const setTextSelection = requireEditorCommand(editor.commands?.setTextSelection, "lists (setTextSelection)");
-  const anchor = selectionAnchorPos(item);
-  return Boolean(setTextSelection({ from: anchor, to: anchor }));
+function withListTarget(editor, input) {
+  return resolveListItem(editor, input.target);
 }
-function isAtMaximumLevel(editor, item) {
-  if (item.numId == null || item.level == null)
-    return false;
-  return !ListHelpers.hasListDefinition(editor, item.numId, item.level + 1);
+function hasLevelOverride(editor, numId, level) {
+  const converter = editor;
+  const definition3 = converter.converter?.numbering?.definitions?.[numId];
+  const ilvl = String(level);
+  return definition3?.elements?.some((element) => element.name === "w:lvlOverride" && element.attributes?.["w:ilvl"] === ilvl) ?? false;
 }
-function isRestartNoOp(editor, item) {
-  if (item.ordinal !== 1)
-    return false;
-  if (item.numId == null)
-    return false;
-  const index2 = getBlockIndex(editor);
-  const currentIndex = index2.candidates.findIndex((candidate) => candidate.nodeType === "listItem" && candidate.nodeId === item.address.nodeId);
-  if (currentIndex <= 0)
+function executeSetLevel(editor, target, newLevel, options) {
+  if (target.numId == null) {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", {
+      target: target.address
+    });
+  }
+  if (newLevel < 0 || newLevel > 8) {
+    return toListsFailure("LEVEL_OUT_OF_RANGE", "Level must be between 0 and 8.", { level: newLevel });
+  }
+  if (target.level === newLevel) {
+    return toListsFailure("NO_OP", "Item is already at the requested level.", {
+      target: target.address,
+      level: newLevel
+    });
+  }
+  if (!ListHelpers.hasListDefinition(editor, target.numId, newLevel)) {
+    return toListsFailure("LEVEL_OUT_OF_RANGE", "Target level is not defined in the active numbering definition.", {
+      target: target.address,
+      level: newLevel
+    });
+  }
+  if (options?.dryRun) {
+    return { success: true, item: target.address };
+  }
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    updateNumberingProperties({ numId: target.numId, ilvl: newLevel }, target.candidate.node, target.candidate.pos, editor, tr);
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
     return true;
-  for (let cursor = currentIndex - 1;cursor >= 0; cursor -= 1) {
-    const previous3 = index2.candidates[cursor];
-    if (previous3.node.type.name !== "paragraph") {
-      return true;
-    }
-    if (previous3.nodeType !== "listItem") {
-      return true;
-    }
-    const previousProjection = resolveListItem(editor, {
-      kind: "block",
-      nodeType: "listItem",
-      nodeId: previous3.nodeId
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toListsFailure("INVALID_TARGET", "Level change could not be applied.", {
+      target: target.address,
+      level: newLevel
     });
-    return previousProjection.numId !== item.numId || previousProjection.level !== item.level;
   }
-  return true;
+  return { success: true, item: target.address };
 }
-function withListTarget(editor, input) {
-  return resolveListItem(editor, input.target);
+function isBlockRange(target) {
+  return typeof target === "object" && target !== null && "from" in target;
 }
 function listsListWrapper(editor, query2) {
   return listListItems(editor, query2);
 }
 function listsGetWrapper(editor, input) {
   const item = resolveListItem(editor, input.address);
-  return listItemProjectionToInfo(item);
+  return listItemProjectionToInfo(item, computeSequenceId(editor, item));
+}
+function listsCanJoinWrapper(editor, input) {
+  const target = resolveListItem(editor, input.target);
+  return evaluateCanJoin(editor, target, input.direction);
+}
+function listsCanContinuePreviousWrapper(editor, input) {
+  const target = resolveListItem(editor, input.target);
+  return evaluateCanContinuePrevious(editor, target);
 }
 function listsInsertWrapper(editor, input, options) {
   const target = withListTarget(editor, input);
@@ -73492,7 +74335,8 @@ function listsInsertWrapper(editor, input, options) {
       position: input.position
     });
   }
-  if (!created) {
+  const resolved = created;
+  if (!resolved) {
     return {
       success: true,
       item: { kind: "block", nodeType: "listItem", nodeId: createdId },
@@ -73505,143 +74349,416 @@ function listsInsertWrapper(editor, input, options) {
   }
   return {
     success: true,
-    item: created.address,
+    item: resolved.address,
     insertionPoint: {
       kind: "text",
-      blockId: created.address.nodeId,
+      blockId: resolved.address.nodeId,
       range: { start: 0, end: 0 }
     },
-    trackedChangeRefs: mode === "tracked" ? collectTrackInsertRefsInRange(editor, created.candidate.pos, created.candidate.end) : undefined
+    trackedChangeRefs: mode === "tracked" ? collectTrackInsertRefsInRange(editor, resolved.candidate.pos, resolved.candidate.end) : undefined
   };
 }
-function listsSetTypeWrapper(editor, input, options) {
-  rejectTrackedMode("lists.setType", options);
+function listsIndentWrapper(editor, input, options) {
+  rejectTrackedMode("lists.indent", options);
   const target = withListTarget(editor, input);
-  if (target.kind === input.kind) {
-    return toListsFailure("NO_OP", "List item already has the requested list kind.", {
+  const currentLevel = target.level ?? 0;
+  return executeSetLevel(editor, target, currentLevel + 1, options);
+}
+function listsOutdentWrapper(editor, input, options) {
+  rejectTrackedMode("lists.outdent", options);
+  const target = withListTarget(editor, input);
+  const currentLevel = target.level ?? 0;
+  if (currentLevel <= 0) {
+    return toListsFailure("NO_OP", "List item is already at level 0.", { target: input.target });
+  }
+  return executeSetLevel(editor, target, currentLevel - 1, options);
+}
+function listsCreateWrapper(editor, input, options) {
+  rejectTrackedMode("lists.create", options);
+  const raw = input;
+  if (input.mode === "empty" && raw.at == null) {
+    return toListsFailure("INVALID_TARGET", 'Mode "empty" requires an "at" field.', { mode: "empty" });
+  }
+  if (input.mode === "fromParagraphs" && raw.target == null) {
+    return toListsFailure("INVALID_TARGET", 'Mode "fromParagraphs" requires a "target" field.', {
+      mode: "fromParagraphs"
+    });
+  }
+  const level = input.level ?? 0;
+  if (level < 0 || level > 8) {
+    return toListsFailure("LEVEL_OUT_OF_RANGE", "Level must be between 0 and 8.", { level });
+  }
+  const listType = input.kind === "ordered" ? "orderedList" : "bulletList";
+  if (input.mode === "empty") {
+    const block = resolveBlock(editor, input.at.nodeId);
+    if (block.nodeType === "listItem") {
+      return toListsFailure("INVALID_TARGET", "Target paragraph is already a list item.", { target: input.at });
+    }
+    if (options?.dryRun) {
+      return { success: true, listId: "(dry-run)", item: { kind: "block", nodeType: "listItem", nodeId: "(dry-run)" } };
+    }
+    let numId2;
+    const receipt3 = executeDomainCommand(editor, () => {
+      numId2 = ListHelpers.getNewListId(editor);
+      ListHelpers.generateNewListDefinition({ numId: numId2, listType, editor });
+      const { tr } = editor.state;
+      updateNumberingProperties({ numId: numId2, ilvl: level }, block.node, block.pos, editor, tr);
+      dispatchEditorTransaction(editor, tr);
+      clearIndexCache(editor);
+      return true;
+    }, { expectedRevision: options?.expectedRevision });
+    if (receipt3.steps[0]?.effect !== "changed") {
+      return toListsFailure("INVALID_TARGET", "List creation could not be applied.", { mode: input.mode });
+    }
+    return {
+      success: true,
+      listId: `${numId2}:${block.nodeId}`,
+      item: { kind: "block", nodeType: "listItem", nodeId: block.nodeId }
+    };
+  }
+  const targets = isBlockRange(input.target) ? resolveBlocksInRange(editor, input.target.from.nodeId, input.target.to.nodeId) : [resolveBlock(editor, input.target.nodeId)];
+  if (targets.length === 0) {
+    return toListsFailure("INVALID_TARGET", "No paragraphs found in the specified range.", { target: input.target });
+  }
+  const alreadyListItem = targets.find((t) => t.nodeType === "listItem");
+  if (alreadyListItem) {
+    return toListsFailure("INVALID_TARGET", "One or more target paragraphs are already list items.", {
+      nodeId: alreadyListItem.nodeId
+    });
+  }
+  if (options?.dryRun) {
+    return {
+      success: true,
+      listId: "(dry-run)",
+      item: { kind: "block", nodeType: "listItem", nodeId: targets[0].nodeId }
+    };
+  }
+  let numId;
+  const receipt2 = executeDomainCommand(editor, () => {
+    numId = ListHelpers.getNewListId(editor);
+    ListHelpers.generateNewListDefinition({ numId, listType, editor });
+    const { tr } = editor.state;
+    for (const block of targets) {
+      updateNumberingProperties({ numId, ilvl: level }, block.node, block.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toListsFailure("INVALID_TARGET", "List creation could not be applied.", { mode: input.mode });
+  }
+  return {
+    success: true,
+    listId: `${numId}:${targets[0].nodeId}`,
+    item: { kind: "block", nodeType: "listItem", nodeId: targets[0].nodeId }
+  };
+}
+function listsAttachWrapper(editor, input, options) {
+  rejectTrackedMode("lists.attach", options);
+  const attachTo = resolveListItem(editor, input.attachTo);
+  if (attachTo.numId == null) {
+    return toListsFailure("INVALID_TARGET", "attachTo target must be a list item with numbering metadata.", {
+      attachTo: input.attachTo
+    });
+  }
+  const numId = attachTo.numId;
+  const level = input.level ?? attachTo.level ?? 0;
+  const targets = isBlockRange(input.target) ? resolveBlocksInRange(editor, input.target.from.nodeId, input.target.to.nodeId) : [resolveBlock(editor, input.target.nodeId)];
+  if (targets.length === 0) {
+    return toListsFailure("INVALID_TARGET", "No paragraphs found in the specified target.", { target: input.target });
+  }
+  const alreadyListItem = targets.find((t) => t.nodeType === "listItem");
+  if (alreadyListItem) {
+    return toListsFailure("INVALID_TARGET", "Target paragraphs are already list items.", {
+      nodeId: alreadyListItem.nodeId
+    });
+  }
+  if (options?.dryRun) {
+    return { success: true, item: { kind: "block", nodeType: "listItem", nodeId: targets[0].nodeId } };
+  }
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    for (const block of targets) {
+      updateNumberingProperties({ numId, ilvl: level }, block.node, block.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toListsFailure("INVALID_TARGET", "List attachment could not be applied.", { target: input.target });
+  }
+  return { success: true, item: { kind: "block", nodeType: "listItem", nodeId: targets[0].nodeId } };
+}
+function listsDetachWrapper(editor, input, options) {
+  rejectTrackedMode("lists.detach", options);
+  const target = resolveListItem(editor, input.target);
+  if (options?.dryRun) {
+    return { success: true, paragraph: { kind: "block", nodeType: "paragraph", nodeId: target.address.nodeId } };
+  }
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    updateNumberingProperties(null, target.candidate.node, target.candidate.pos, editor, tr);
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toListsFailure("INVALID_TARGET", "List detach could not be applied.", { target: input.target });
+  }
+  return { success: true, paragraph: { kind: "block", nodeType: "paragraph", nodeId: target.address.nodeId } };
+}
+function listsJoinWrapper(editor, input, options) {
+  rejectTrackedMode("lists.join", options);
+  const target = resolveListItem(editor, input.target);
+  if (target.numId == null) {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input.target });
+  }
+  const canJoinResult = evaluateCanJoin(editor, target, input.direction);
+  if (!canJoinResult.canJoin) {
+    return toListsFailure(canJoinResult.reason, `Cannot join: ${canJoinResult.reason}`, {
       target: input.target,
-      kind: input.kind
+      direction: input.direction
     });
   }
-  const setListTypeAt = requireEditorCommand(editor.commands?.setListTypeAt, "lists.setType (setListTypeAt)");
+  const adjacent = findAdjacentSequence(editor, target, input.direction);
+  let absorbingNumId;
+  let absorbedItems;
+  let anchorNodeId;
+  if (input.direction === "withPrevious") {
+    absorbingNumId = adjacent.numId;
+    absorbedItems = getContiguousSequence(editor, target);
+    anchorNodeId = adjacent.sequence[0]?.address.nodeId ?? target.address.nodeId;
+  } else {
+    absorbingNumId = target.numId;
+    absorbedItems = adjacent.sequence;
+    const targetSequence = getContiguousSequence(editor, target);
+    anchorNodeId = targetSequence[0]?.address.nodeId ?? target.address.nodeId;
+  }
+  const mergedListId = `${absorbingNumId}:${anchorNodeId}`;
   if (options?.dryRun) {
-    return { success: true, item: target.address };
+    return { success: true, listId: mergedListId };
   }
-  const receipt2 = executeDomainCommand(editor, () => setListTypeAt({ pos: target.candidate.pos, kind: input.kind }), {
-    expectedRevision: options?.expectedRevision
-  });
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    for (const item of absorbedItems) {
+      const currentLevel = item.level ?? 0;
+      updateNumberingProperties({ numId: absorbingNumId, ilvl: currentLevel }, item.candidate.node, item.candidate.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
   if (receipt2.steps[0]?.effect !== "changed") {
-    return toListsFailure("INVALID_TARGET", "List type conversion could not be applied.", {
+    return toListsFailure("INVALID_TARGET", "List join could not be applied.", {
       target: input.target,
-      kind: input.kind
+      direction: input.direction
     });
   }
-  return { success: true, item: target.address };
+  return { success: true, listId: mergedListId };
 }
-function listsIndentWrapper(editor, input, options) {
-  rejectTrackedMode("lists.indent", options);
-  const target = withListTarget(editor, input);
-  if (isAtMaximumLevel(editor, target)) {
-    return toListsFailure("NO_OP", "List item is already at the maximum supported level.", { target: input.target });
+function listsSeparateWrapper(editor, input, options) {
+  rejectTrackedMode("lists.separate", options);
+  const target = resolveListItem(editor, input.target);
+  if (target.numId == null) {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input.target });
   }
-  const increaseListIndent = requireEditorCommand(editor.commands?.increaseListIndent, "lists.indent (increaseListIndent)");
-  if (options?.dryRun) {
-    return { success: true, item: target.address };
+  if (isFirstInSequence(editor, target)) {
+    return toListsFailure("NO_OP", "Target is already the first item in its sequence.", { target: input.target });
   }
-  if (!setSelectionToListItem(editor, target)) {
-    return toListsFailure("INVALID_TARGET", "List item target could not be selected for indentation.", {
+  const copyOverrides = input.copyOverrides !== false;
+  const abstractNumId = getAbstractNumId(editor, target.numId);
+  if (abstractNumId == null) {
+    return toListsFailure("INVALID_TARGET", "Could not resolve abstract definition for target.", {
       target: input.target
     });
   }
-  const receipt2 = executeDomainCommand(editor, () => increaseListIndent(), {
-    expectedRevision: options?.expectedRevision
-  });
+  const itemsToReassign = getSequenceFromTarget(editor, target);
+  if (options?.dryRun) {
+    return { success: true, listId: "(dry-run)", numId: 0 };
+  }
+  let newNumId;
+  const receipt2 = executeDomainCommand(editor, () => {
+    const result = ListHelpers.createNumDefinition(editor, abstractNumId, {
+      copyOverridesFrom: copyOverrides ? target.numId : undefined
+    });
+    newNumId = result.numId;
+    const { tr } = editor.state;
+    for (const item of itemsToReassign) {
+      const currentLevel = item.level ?? 0;
+      updateNumberingProperties({ numId: newNumId, ilvl: currentLevel }, item.candidate.node, item.candidate.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
   if (receipt2.steps[0]?.effect !== "changed") {
-    return toListsFailure("INVALID_TARGET", "List indentation could not be applied.", { target: input.target });
+    return toListsFailure("INVALID_TARGET", "List separation could not be applied.", { target: input.target });
   }
-  return { success: true, item: target.address };
+  return { success: true, listId: `${newNumId}:${target.address.nodeId}`, numId: newNumId };
 }
-function listsOutdentWrapper(editor, input, options) {
-  rejectTrackedMode("lists.outdent", options);
-  const target = withListTarget(editor, input);
-  if ((target.level ?? 0) <= 0) {
-    return toListsFailure("NO_OP", "List item is already at level 0.", { target: input.target });
+function listsSetLevelWrapper(editor, input, options) {
+  rejectTrackedMode("lists.setLevel", options);
+  const target = resolveListItem(editor, input.target);
+  return executeSetLevel(editor, target, input.level, options);
+}
+function listsSetValueWrapper(editor, input, options) {
+  rejectTrackedMode("lists.setValue", options);
+  const target = resolveListItem(editor, input.target);
+  if (target.numId == null) {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input.target });
   }
-  const decreaseListIndent = requireEditorCommand(editor.commands?.decreaseListIndent, "lists.outdent (decreaseListIndent)");
+  const level = target.level ?? 0;
   if (options?.dryRun) {
     return { success: true, item: target.address };
   }
-  if (!setSelectionToListItem(editor, target)) {
-    return toListsFailure("INVALID_TARGET", "List item target could not be selected for outdent.", {
+  if (input.value === null) {
+    if (!hasLevelOverride(editor, target.numId, level)) {
+      return toListsFailure("NO_OP", "No startOverride to remove.", { target: input.target });
+    }
+    const receipt3 = executeDomainCommand(editor, () => {
+      ListHelpers.removeLvlOverride(editor, target.numId, level);
+      dispatchEditorTransaction(editor, editor.state.tr);
+      return true;
+    }, { expectedRevision: options?.expectedRevision });
+    if (receipt3.steps[0]?.effect !== "changed") {
+      return toListsFailure("NO_OP", "No startOverride to remove.", { target: input.target });
+    }
+    return { success: true, item: target.address };
+  }
+  const isFirst = isFirstInSequence(editor, target);
+  if (isFirst) {
+    const receipt3 = executeDomainCommand(editor, () => {
+      ListHelpers.setLvlOverride(editor, target.numId, level, { startOverride: input.value });
+      dispatchEditorTransaction(editor, editor.state.tr);
+      return true;
+    }, { expectedRevision: options?.expectedRevision });
+    if (receipt3.steps[0]?.effect !== "changed") {
+      return toListsFailure("INVALID_TARGET", "setValue could not be applied.", { target: input.target });
+    }
+    return { success: true, item: target.address };
+  }
+  const abstractNumId = getAbstractNumId(editor, target.numId);
+  if (abstractNumId == null) {
+    return toListsFailure("INVALID_TARGET", "Could not resolve abstract definition for target.", {
       target: input.target
     });
   }
-  const receipt2 = executeDomainCommand(editor, () => decreaseListIndent(), {
-    expectedRevision: options?.expectedRevision
-  });
+  const itemsToReassign = getSequenceFromTarget(editor, target);
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { numId: newNumId } = ListHelpers.createNumDefinition(editor, abstractNumId, {
+      copyOverridesFrom: target.numId
+    });
+    ListHelpers.setLvlOverride(editor, newNumId, level, { startOverride: input.value });
+    const { tr } = editor.state;
+    for (const item of itemsToReassign) {
+      const currentLevel = item.level ?? 0;
+      updateNumberingProperties({ numId: newNumId, ilvl: currentLevel }, item.candidate.node, item.candidate.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
   if (receipt2.steps[0]?.effect !== "changed") {
-    return toListsFailure("INVALID_TARGET", "List outdent could not be applied.", { target: input.target });
+    return toListsFailure("INVALID_TARGET", "setValue could not be applied.", { target: input.target });
   }
   return { success: true, item: target.address };
 }
-function listsRestartWrapper(editor, input, options) {
-  rejectTrackedMode("lists.restart", options);
-  const target = withListTarget(editor, input);
+function listsContinuePreviousWrapper(editor, input, options) {
+  rejectTrackedMode("lists.continuePrevious", options);
+  const target = resolveListItem(editor, input.target);
   if (target.numId == null) {
-    return toListsFailure("INVALID_TARGET", "List restart requires numbering metadata on the target item.", {
-      target: input.target
-    });
-  }
-  if (isRestartNoOp(editor, target)) {
-    return toListsFailure("NO_OP", "List item is already the start of a sequence that effectively starts at 1.", {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input.target });
+  }
+  const canContinue = evaluateCanContinuePrevious(editor, target);
+  if (!canContinue.canContinue) {
+    const reasonToFailureCode = {
+      NO_PREVIOUS_LIST: "NO_COMPATIBLE_PREVIOUS",
+      INCOMPATIBLE_DEFINITIONS: "NO_COMPATIBLE_PREVIOUS",
+      ALREADY_CONTINUOUS: "ALREADY_CONTINUOUS"
+    };
+    const code3 = reasonToFailureCode[canContinue.reason] ?? "INVALID_TARGET";
+    return toListsFailure(code3, `Cannot continue previous: ${canContinue.reason}`, {
       target: input.target
     });
   }
-  const restartNumbering = requireEditorCommand(editor.commands?.restartNumbering, "lists.restart (restartNumbering)");
+  const previous3 = findPreviousCompatibleSequence(editor, target);
   if (options?.dryRun) {
     return { success: true, item: target.address };
   }
-  if (!setSelectionToListItem(editor, target)) {
-    return toListsFailure("INVALID_TARGET", "List item target could not be selected for restart.", {
-      target: input.target
-    });
-  }
-  const receipt2 = executeDomainCommand(editor, () => restartNumbering(), {
-    expectedRevision: options?.expectedRevision
-  });
+  const sequence = getContiguousSequence(editor, target);
+  const level = target.level ?? 0;
+  const receipt2 = executeDomainCommand(editor, () => {
+    ListHelpers.removeLvlOverride(editor, target.numId, level);
+    const { tr } = editor.state;
+    for (const item of sequence) {
+      const currentLevel = item.level ?? 0;
+      updateNumberingProperties({ numId: previous3.numId, ilvl: currentLevel }, item.candidate.node, item.candidate.pos, editor, tr);
+    }
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
   if (receipt2.steps[0]?.effect !== "changed") {
-    return toListsFailure("INVALID_TARGET", "List restart could not be applied.", { target: input.target });
+    return toListsFailure("INVALID_TARGET", "continuePrevious could not be applied.", { target: input.target });
   }
   return { success: true, item: target.address };
 }
-function listsExitWrapper(editor, input, options) {
-  rejectTrackedMode("lists.exit", options);
-  const target = withListTarget(editor, input);
-  const exitListItemAt = requireEditorCommand(editor.commands?.exitListItemAt, "lists.exit (exitListItemAt)");
+function listsSetLevelRestartWrapper(editor, input, options) {
+  rejectTrackedMode("lists.setLevelRestart", options);
+  const target = resolveListItem(editor, input.target);
+  if (target.numId == null) {
+    return toListsFailure("INVALID_TARGET", "Target must have numbering metadata.", { target: input.target });
+  }
+  if (input.level < 0 || input.level > 8) {
+    return toListsFailure("LEVEL_OUT_OF_RANGE", "Level must be between 0 and 8.", { level: input.level });
+  }
   if (options?.dryRun) {
-    return {
-      success: true,
-      paragraph: {
-        kind: "block",
-        nodeType: "paragraph",
-        nodeId: "(dry-run)"
-      }
-    };
+    return { success: true, item: target.address };
   }
-  const receipt2 = executeDomainCommand(editor, () => exitListItemAt({ pos: target.candidate.pos }), {
-    expectedRevision: options?.expectedRevision
-  });
+  const scope = input.scope ?? "definition";
+  const receipt2 = executeDomainCommand(editor, () => {
+    if (scope === "instance") {
+      ListHelpers.setLvlOverride(editor, target.numId, input.level, {
+        lvlRestart: input.restartAfterLevel
+      });
+    } else {
+      const abstractNumId = getAbstractNumId(editor, target.numId);
+      if (abstractNumId == null)
+        return false;
+      ListHelpers.setLvlRestartOnAbstract(editor, abstractNumId, input.level, input.restartAfterLevel);
+    }
+    dispatchEditorTransaction(editor, editor.state.tr);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
   if (receipt2.steps[0]?.effect !== "changed") {
-    return toListsFailure("INVALID_TARGET", "List exit could not be applied.", { target: input.target });
+    return toListsFailure("INVALID_TARGET", "setLevelRestart could not be applied.", { target: input.target });
   }
-  return {
-    success: true,
-    paragraph: {
-      kind: "block",
-      nodeType: "paragraph",
-      nodeId: target.address.nodeId
+  return { success: true, item: target.address };
+}
+function listsConvertToTextWrapper(editor, input, options) {
+  rejectTrackedMode("lists.convertToText", options);
+  const target = resolveListItem(editor, input.target);
+  const includeMarker = input.includeMarker ?? false;
+  if (options?.dryRun) {
+    return { success: true, paragraph: { kind: "block", nodeType: "paragraph", nodeId: target.address.nodeId } };
+  }
+  const receipt2 = executeDomainCommand(editor, () => {
+    const { tr } = editor.state;
+    if (includeMarker && target.marker) {
+      const startPos = target.candidate.pos + 1;
+      tr.insertText(target.marker, startPos);
     }
-  };
+    updateNumberingProperties(null, target.candidate.node, target.candidate.pos, editor, tr);
+    dispatchEditorTransaction(editor, tr);
+    clearIndexCache(editor);
+    return true;
+  }, { expectedRevision: options?.expectedRevision });
+  if (receipt2.steps[0]?.effect !== "changed") {
+    return toListsFailure("INVALID_TARGET", "convertToText could not be applied.", { target: input.target });
+  }
+  return { success: true, paragraph: { kind: "block", nodeType: "paragraph", nodeId: target.address.nodeId } };
 }
 var init_lists_wrappers = __esm(() => {
   init_wrapper();
@@ -73651,7 +74768,9 @@ var init_lists_wrappers = __esm(() => {
   init_index_cache();
   init_tracked_change_refs();
   init_list_item_resolver();
+  init_list_sequence_helpers();
   init_list_numbering_helpers();
+  init_changeListLevel();
 });
 
 // ../../packages/super-editor/src/document-api-adapters/plan-engine/preview.ts
@@ -80698,6 +81817,22 @@ function runTocCommand(editor, command, args2, expectedRevision) {
   const executeCommand = toTocEditorCommand(command);
   return runTocAction(editor, () => executeCommand(args2), expectedRevision);
 }
+function normalizeTocContent(content3, editor) {
+  if (!Array.isArray(content3))
+    return null;
+  return content3.map((entry) => entry && typeof entry === "object" && typeof entry.type === "string" ? editor.state.schema.nodeFromJSON(entry) : entry);
+}
+function dispatchEditorTransaction2(editor, tr) {
+  if (typeof editor.dispatch === "function") {
+    editor.dispatch(tr);
+    return;
+  }
+  if (typeof editor.view?.dispatch === "function") {
+    editor.view.dispatch(tr);
+    return;
+  }
+  throw new Error("No transaction dispatcher available.");
+}
 function receiptApplied(receipt2) {
   return receipt2.steps[0]?.effect === "changed";
 }
@@ -80733,20 +81868,49 @@ function withRightAlign(config33, rightAlignPageNumbers) {
     return config33;
   return { ...config33, display: { ...config33.display, rightAlignPageNumbers } };
 }
-function materializeTocContent(doc, config33) {
+function sanitizeTocContentForSchema(content3, editor) {
+  if (editor.state.schema?.marks?.tocPageNumber)
+    return content3;
+  return content3.map((paragraph2) => {
+    const paragraphContent = paragraph2.content;
+    if (!Array.isArray(paragraphContent))
+      return paragraph2;
+    let changed = false;
+    const sanitizedContent = paragraphContent.map((node3) => {
+      if (!node3 || typeof node3 !== "object")
+        return node3;
+      const typedNode = node3;
+      const marks = typedNode.marks;
+      if (!Array.isArray(marks))
+        return node3;
+      const filteredMarks = marks.filter((mark) => mark?.type !== "tocPageNumber");
+      if (filteredMarks.length === marks.length)
+        return node3;
+      changed = true;
+      if (filteredMarks.length === 0) {
+        const { marks: _removed, ...rest } = typedNode;
+        return rest;
+      }
+      return { ...typedNode, marks: filteredMarks };
+    });
+    return changed ? { ...paragraph2, content: sanitizedContent } : paragraph2;
+  });
+}
+function materializeTocContent(doc, config33, editor) {
   const sources = collectTocSources(doc, config33);
   const entryParagraphs = buildTocEntryParagraphs(sources, config33);
-  return entryParagraphs.length > 0 ? entryParagraphs : NO_ENTRIES_PLACEHOLDER;
+  const content3 = entryParagraphs.length > 0 ? entryParagraphs : NO_ENTRIES_PLACEHOLDER;
+  return sanitizeTocContentForSchema(content3, editor);
 }
 function tocConfigureWrapper(editor, input, options) {
   rejectTrackedMode("toc.configure", options);
-  const command = requireEditorCommand(editor.commands?.setTableOfContentsInstructionById, "toc.configure");
   const resolved = resolveTocTarget(editor.state.doc, input.target);
   const currentConfig = parseTocInstruction(resolved.node.attrs?.instruction ?? "");
   const patched = applyTocPatchTyped(currentConfig, input.patch);
+  const instruction = serializeTocInstruction(patched);
   const rightAlignChanged = input.patch.rightAlignPageNumbers !== undefined && input.patch.rightAlignPageNumbers !== resolved.node.attrs?.rightAlignPageNumbers;
   const effectiveRightAlign = input.patch.rightAlignPageNumbers ?? resolved.node.attrs?.rightAlignPageNumbers;
-  const nextContent = materializeTocContent(editor.state.doc, withRightAlign(patched, effectiveRightAlign));
+  const nextContent = materializeTocContent(editor.state.doc, withRightAlign(patched, effectiveRightAlign), editor);
   if (areTocConfigsEqual(currentConfig, patched) && !rightAlignChanged) {
     return tocFailure("NO_OP", "Configuration patch produced no change.");
   }
@@ -80754,12 +81918,31 @@ function tocConfigureWrapper(editor, input, options) {
     return tocSuccess(resolved.nodeId);
   }
   const shouldRefreshContent = !isTocContentUnchanged(resolved.node, nextContent);
+  const command = editor.commands?.setTableOfContentsInstructionById;
   const commandNodeId = resolved.commandNodeId ?? resolved.nodeId;
-  const receipt2 = runTocCommand(editor, command, {
+  const receipt2 = typeof command === "function" ? runTocCommand(editor, command, {
     sdBlockId: commandNodeId,
-    instruction: serializeTocInstruction(patched),
+    instruction,
     ...shouldRefreshContent ? { content: nextContent } : {},
     ...rightAlignChanged ? { rightAlignPageNumbers: input.patch.rightAlignPageNumbers } : {}
+  }, options?.expectedRevision) : runTocAction(editor, () => {
+    try {
+      const { tr } = editor.state;
+      tr.setNodeMarkup(resolved.pos, undefined, {
+        ...resolved.node.attrs,
+        instruction,
+        ...rightAlignChanged ? { rightAlignPageNumbers: input.patch.rightAlignPageNumbers } : {}
+      });
+      if (shouldRefreshContent) {
+        const from3 = resolved.pos + 1;
+        const to = resolved.pos + resolved.node.nodeSize - 1;
+        tr.replaceWith(from3, to, normalizeTocContent(nextContent, editor) ?? []);
+      }
+      dispatchEditorTransaction2(editor, tr);
+      return true;
+    } catch {
+      return false;
+    }
   }, options?.expectedRevision);
   if (!receiptApplied(receipt2)) {
     return tocFailure("NO_OP", "Configuration change could not be applied.");
@@ -80776,20 +81959,31 @@ function tocUpdateWrapper(editor, input, options) {
   return tocUpdateAll(editor, input, options);
 }
 function tocUpdateAll(editor, input, options) {
-  const command = requireEditorCommand(editor.commands?.replaceTableOfContentsContentById, "toc.update");
   const resolved = resolveTocTarget(editor.state.doc, input.target);
   const config33 = parseTocInstruction(resolved.node.attrs?.instruction ?? "");
   const rightAlign = resolved.node.attrs?.rightAlignPageNumbers;
-  const content3 = materializeTocContent(editor.state.doc, withRightAlign(config33, rightAlign));
+  const content3 = materializeTocContent(editor.state.doc, withRightAlign(config33, rightAlign), editor);
   if (isTocContentUnchanged(resolved.node, content3)) {
     return tocFailure("NO_OP", "TOC update produced no change.");
   }
   if (options?.dryRun) {
     return tocSuccess(resolved.nodeId);
   }
-  const receipt2 = runTocCommand(editor, command, {
+  const command = editor.commands?.replaceTableOfContentsContentById;
+  const receipt2 = typeof command === "function" ? runTocCommand(editor, command, {
     sdBlockId: resolved.commandNodeId ?? resolved.nodeId,
     content: content3
+  }, options?.expectedRevision) : runTocAction(editor, () => {
+    try {
+      const { tr } = editor.state;
+      const from3 = resolved.pos + 1;
+      const to = resolved.pos + resolved.node.nodeSize - 1;
+      tr.replaceWith(from3, to, normalizeTocContent(content3, editor) ?? []);
+      dispatchEditorTransaction2(editor, tr);
+      return true;
+    } catch {
+      return false;
+    }
   }, options?.expectedRevision);
   return receiptApplied(receipt2) ? tocSuccess(resolved.nodeId) : tocFailure("NO_OP", "TOC update produced no change.");
 }
@@ -80806,7 +82000,6 @@ function getPageMap(editor) {
   return tocStorage.pageMap;
 }
 function tocUpdatePageNumbers(editor, input, options) {
-  const command = requireEditorCommand(editor.commands?.replaceTableOfContentsContentById, "toc.update");
   const resolved = resolveTocTarget(editor.state.doc, input.target);
   const config33 = parseTocInstruction(resolved.node.attrs?.instruction ?? "");
   if (deriveIncludePageNumbers(config33.display.omitPageNumberLevels, config33.source.outlineLevels) === false) {
@@ -80826,9 +82019,21 @@ function tocUpdatePageNumbers(editor, input, options) {
   if (options?.dryRun) {
     return tocSuccess(resolved.nodeId);
   }
-  const receipt2 = runTocCommand(editor, command, {
+  const command = editor.commands?.replaceTableOfContentsContentById;
+  const receipt2 = typeof command === "function" ? runTocCommand(editor, command, {
     sdBlockId: resolved.commandNodeId ?? resolved.nodeId,
     content: updatedContent
+  }, options?.expectedRevision) : runTocAction(editor, () => {
+    try {
+      const { tr } = editor.state;
+      const from3 = resolved.pos + 1;
+      const to = resolved.pos + resolved.node.nodeSize - 1;
+      tr.replaceWith(from3, to, normalizeTocContent(updatedContent, editor) ?? []);
+      dispatchEditorTransaction2(editor, tr);
+      return true;
+    } catch {
+      return false;
+    }
   }, options?.expectedRevision);
   return receiptApplied(receipt2) ? tocSuccess(resolved.nodeId) : tocFailure("NO_OP", "Page number update produced no change.");
 }
@@ -80872,19 +82077,27 @@ function buildPageNumberUpdatedContent(tocNode, pageMap) {
 }
 function tocRemoveWrapper(editor, input, options) {
   rejectTrackedMode("toc.remove", options);
-  const command = requireEditorCommand(editor.commands?.deleteTableOfContentsById, "toc.remove");
   const resolved = resolveTocTarget(editor.state.doc, input.target);
   if (options?.dryRun) {
     return tocSuccess(resolved.nodeId);
   }
-  const receipt2 = runTocCommand(editor, command, {
+  const command = editor.commands?.deleteTableOfContentsById;
+  const receipt2 = typeof command === "function" ? runTocCommand(editor, command, {
     sdBlockId: resolved.commandNodeId ?? resolved.nodeId
+  }, options?.expectedRevision) : runTocAction(editor, () => {
+    try {
+      const { tr } = editor.state;
+      tr.delete(resolved.pos, resolved.pos + resolved.node.nodeSize);
+      dispatchEditorTransaction2(editor, tr);
+      return true;
+    } catch {
+      return false;
+    }
   }, options?.expectedRevision);
   return receiptApplied(receipt2) ? tocSuccess(resolved.nodeId) : tocFailure("NO_OP", "TOC removal produced no change.");
 }
 function createTableOfContentsWrapper(editor, input, options) {
   rejectTrackedMode("create.tableOfContents", options);
-  const command = requireEditorCommand(editor.commands?.insertTableOfContentsAt, "create.tableOfContents");
   const at = input.at ?? { kind: "documentEnd" };
   let pos;
   if (at.kind === "documentStart") {
@@ -80896,17 +82109,42 @@ function createTableOfContentsWrapper(editor, input, options) {
   }
   const config33 = input.config ? applyTocPatchTyped(DEFAULT_TOC_CONFIG, input.config) : DEFAULT_TOC_CONFIG;
   const instruction = serializeTocInstruction(config33);
-  const content3 = materializeTocContent(editor.state.doc, withRightAlign(config33, input.config?.rightAlignPageNumbers));
+  const content3 = materializeTocContent(editor.state.doc, withRightAlign(config33, input.config?.rightAlignPageNumbers), editor);
   const sdBlockId = v4();
   if (options?.dryRun) {
     return { success: true, toc: buildTocAddress("(dry-run)") };
   }
-  const receipt2 = runTocCommand(editor, command, {
+  const command = editor.commands?.insertTableOfContentsAt;
+  const receipt2 = typeof command === "function" ? runTocCommand(editor, command, {
     pos,
     instruction,
     sdBlockId,
     content: content3,
     ...input.config?.rightAlignPageNumbers !== undefined ? { rightAlignPageNumbers: input.config.rightAlignPageNumbers } : {}
+  }, options?.expectedRevision) : runTocAction(editor, () => {
+    const tocType = editor.state.schema.nodes.tableOfContents;
+    const paragraphType = editor.state.schema.nodes.paragraph;
+    if (!tocType || !paragraphType)
+      return false;
+    const defaultContent = [
+      paragraphType.create({}, editor.state.schema.text("Update table of contents to populate entries."))
+    ];
+    const materializedContent = normalizeTocContent(content3, editor) ?? defaultContent;
+    const tocNode = tocType.create({
+      instruction,
+      sdBlockId,
+      ...input.config?.rightAlignPageNumbers !== undefined ? { rightAlignPageNumbers: input.config.rightAlignPageNumbers } : {}
+    }, materializedContent);
+    try {
+      const { tr } = editor.state;
+      tr.insert(pos, tocNode);
+      dispatchEditorTransaction2(editor, tr);
+      return true;
+    } catch (error) {
+      if (error instanceof RangeError)
+        return false;
+      throw error;
+    }
   }, options?.expectedRevision);
   if (!receiptApplied(receipt2)) {
     return {
@@ -81282,11 +82520,20 @@ function assembleDocumentApiAdapters(editor) {
       list: (query2) => listsListWrapper(editor, query2),
       get: (input) => listsGetWrapper(editor, input),
       insert: (input, options) => listsInsertWrapper(editor, input, options),
-      setType: (input, options) => listsSetTypeWrapper(editor, input, options),
+      create: (input, options) => listsCreateWrapper(editor, input, options),
+      attach: (input, options) => listsAttachWrapper(editor, input, options),
+      detach: (input, options) => listsDetachWrapper(editor, input, options),
       indent: (input, options) => listsIndentWrapper(editor, input, options),
       outdent: (input, options) => listsOutdentWrapper(editor, input, options),
-      restart: (input, options) => listsRestartWrapper(editor, input, options),
-      exit: (input, options) => listsExitWrapper(editor, input, options)
+      join: (input, options) => listsJoinWrapper(editor, input, options),
+      canJoin: (input) => listsCanJoinWrapper(editor, input),
+      separate: (input, options) => listsSeparateWrapper(editor, input, options),
+      setLevel: (input, options) => listsSetLevelWrapper(editor, input, options),
+      setValue: (input, options) => listsSetValueWrapper(editor, input, options),
+      continuePrevious: (input, options) => listsContinuePreviousWrapper(editor, input, options),
+      canContinuePrevious: (input) => listsCanContinuePreviousWrapper(editor, input),
+      setLevelRestart: (input, options) => listsSetLevelRestartWrapper(editor, input, options),
+      convertToText: (input, options) => listsConvertToTextWrapper(editor, input, options)
     },
     sections: {
       list: (query2) => sectionsListAdapter2(editor, query2),
@@ -85606,11 +86853,20 @@ var init_invoke_input = __esm(() => {
     getNode: "address",
     "lists.list": "query",
     "lists.insert": "input",
-    "lists.setType": "input",
     "lists.indent": "input",
     "lists.outdent": "input",
-    "lists.restart": "input",
-    "lists.exit": "input",
+    "lists.create": "input",
+    "lists.attach": "input",
+    "lists.detach": "input",
+    "lists.join": "input",
+    "lists.canJoin": "input",
+    "lists.separate": "input",
+    "lists.setLevel": "input",
+    "lists.setValue": "input",
+    "lists.continuePrevious": "input",
+    "lists.canContinuePrevious": "input",
+    "lists.setLevelRestart": "input",
+    "lists.convertToText": "input",
     "create.paragraph": "input",
     "create.heading": "input"
   };
@@ -85633,11 +86889,15 @@ var init_invoke_input = __esm(() => {
   ]);
   LIST_TARGET_OPERATIONS = new Set([
     "lists.insert",
-    "lists.setType",
     "lists.indent",
     "lists.outdent",
-    "lists.restart",
-    "lists.exit"
+    "lists.detach",
+    "lists.separate",
+    "lists.setLevel",
+    "lists.setValue",
+    "lists.continuePrevious",
+    "lists.canContinuePrevious",
+    "lists.convertToText"
   ]);
 });
 
@@ -86141,6 +87401,15 @@ function buildHelperSpecs() {
 var CLI_HELPER_COMMANDS;
 var init_helper_commands = __esm(() => {
   CLI_HELPER_COMMANDS = [
+    {
+      tokens: ["lists", "exit"],
+      canonicalOperationId: "lists.detach",
+      defaultInput: {},
+      description: "Alias for lists detach.",
+      category: "lists",
+      mutates: true,
+      examples: [`superdoc lists exit --target-json '{"kind":"block","nodeType":"listItem","nodeId":"p1"}'`]
+    },
     {
       tokens: ["format", "strikethrough"],
       canonicalOperationId: "format.strike",
@@ -86761,23 +88030,47 @@ var init_operation_params = __esm(() => {
       { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
       ...LIST_TARGET_FLAT_PARAMS
     ],
-    "doc.lists.setType": [
+    "doc.lists.indent": [
       { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
       ...LIST_TARGET_FLAT_PARAMS
     ],
-    "doc.lists.indent": [
+    "doc.lists.outdent": [
       { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
       ...LIST_TARGET_FLAT_PARAMS
     ],
-    "doc.lists.outdent": [
+    "doc.lists.create": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.lists.attach": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.lists.detach": [
       { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
       ...LIST_TARGET_FLAT_PARAMS
     ],
-    "doc.lists.restart": [
+    "doc.lists.join": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.lists.canJoin": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.lists.separate": [
+      { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
+      ...LIST_TARGET_FLAT_PARAMS
+    ],
+    "doc.lists.setLevel": [
+      { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
+      ...LIST_TARGET_FLAT_PARAMS
+    ],
+    "doc.lists.setValue": [
+      { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
+      ...LIST_TARGET_FLAT_PARAMS
+    ],
+    "doc.lists.continuePrevious": [
+      { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
+      ...LIST_TARGET_FLAT_PARAMS
+    ],
+    "doc.lists.canContinuePrevious": [
+      { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
+      ...LIST_TARGET_FLAT_PARAMS
+    ],
+    "doc.lists.setLevelRestart": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }],
+    "doc.lists.convertToText": [
       { name: "input", kind: "jsonFlag", flag: "input-json", type: "json" },
       ...LIST_TARGET_FLAT_PARAMS
     ],
-    "doc.lists.exit": [{ name: "input", kind: "jsonFlag", flag: "input-json", type: "json" }, ...LIST_TARGET_FLAT_PARAMS],
     "doc.blocks.delete": [
       { name: "nodeType", kind: "flag", flag: "node-type", type: "string" },
       { name: "nodeId", kind: "flag", flag: "node-id", type: "string" }
@@ -95286,8 +96579,11 @@ async function executeParsedInvocation(parsed, io, executionMode, collabSessionP
 async function invokeCommand(argv, options = {}) {
   const io = mergeIo(options.ioOverrides);
   const startedAt = io.now();
-  const parsed = parseInvocation(argv);
-  const output = await executeParsedInvocation(parsed, io, options.executionMode ?? "oneshot", options.collabSessionPool);
+  const { parsed, output } = await withStateDirOverride(options.stateDir, async () => {
+    const parsedInvocation = parseInvocation(argv);
+    const commandOutput = await executeParsedInvocation(parsedInvocation, io, options.executionMode ?? "oneshot", options.collabSessionPool);
+    return { parsed: parsedInvocation, output: commandOutput };
+  });
   return {
     globals: parsed.globals,
     execution: output.execution,
@@ -95299,51 +96595,53 @@ async function runHostCommand(tokens, io) {
   const { runHostStdio: runHostStdio2 } = await init_server().then(() => exports_server);
   return runHostStdio2(tokens, io);
 }
-async function run(argv, ioOverrides) {
+async function run(argv, ioOverrides, options = {}) {
   const io = mergeIo(ioOverrides);
   const startedAt = io.now();
   let outputMode = "json";
-  try {
-    const parsed = parseInvocation(argv);
-    outputMode = parsed.globals.output;
-    if (parsed.rest[0] === "host") {
-      const hostTokens = parsed.rest.slice(1);
-      if (parsed.globals.help)
-        hostTokens.push("--help");
-      return await runHostCommand(hostTokens, io);
-    }
-    if (parsed.rest[0] === "install" && !parsed.globals.help) {
-      return await runInstall(parsed.rest.slice(1), io);
-    }
-    if (parsed.rest[0] === "uninstall" && !parsed.globals.help) {
-      return await runUninstall(parsed.rest.slice(1), io);
-    }
-    if (parsed.rest[0] === "call" && outputMode !== "json") {
-      throw new CliError("INVALID_ARGUMENT", "call: only --output json is supported.");
-    }
-    if (!parsed.globals.help) {
-      const legacyCompat = await tryRunLegacyCompatCommand(argv, parsed.rest, io);
-      if (legacyCompat.handled) {
-        return legacyCompat.exitCode;
+  return withStateDirOverride(options.stateDir, async () => {
+    try {
+      const parsed = parseInvocation(argv);
+      outputMode = parsed.globals.output;
+      if (parsed.rest[0] === "host") {
+        const hostTokens = parsed.rest.slice(1);
+        if (parsed.globals.help)
+          hostTokens.push("--help");
+        return await runHostCommand(hostTokens, io);
       }
-    }
-    const output = await executeParsedInvocation(parsed, io, "oneshot");
-    if (output.helpText) {
-      io.stdout(output.helpText);
+      if (parsed.rest[0] === "install" && !parsed.globals.help) {
+        return await runInstall(parsed.rest.slice(1), io);
+      }
+      if (parsed.rest[0] === "uninstall" && !parsed.globals.help) {
+        return await runUninstall(parsed.rest.slice(1), io);
+      }
+      if (parsed.rest[0] === "call" && outputMode !== "json") {
+        throw new CliError("INVALID_ARGUMENT", "call: only --output json is supported.");
+      }
+      if (!parsed.globals.help) {
+        const legacyCompat = await tryRunLegacyCompatCommand(argv, parsed.rest, io);
+        if (legacyCompat.handled) {
+          return legacyCompat.exitCode;
+        }
+      }
+      const output = await executeParsedInvocation(parsed, io, "oneshot");
+      if (output.helpText) {
+        io.stdout(output.helpText);
+        return 0;
+      }
+      if (!output.execution) {
+        throw new CliError("COMMAND_FAILED", "Command produced no execution result and no help text.");
+      }
+      const elapsedMs = io.now() - startedAt;
+      writeSuccess(io, outputMode, output.execution, elapsedMs);
       return 0;
+    } catch (error) {
+      const cliError = toCliError(error);
+      const elapsedMs = io.now() - startedAt;
+      writeFailure(io, outputMode, cliError, elapsedMs);
+      return cliError.exitCode;
     }
-    if (!output.execution) {
-      throw new CliError("COMMAND_FAILED", "Command produced no execution result and no help text.");
-    }
-    const elapsedMs = io.now() - startedAt;
-    writeSuccess(io, outputMode, output.execution, elapsedMs);
-    return 0;
-  } catch (error) {
-    const cliError = toCliError(error);
-    const elapsedMs = io.now() - startedAt;
-    writeFailure(io, outputMode, cliError, elapsedMs);
-    return cliError.exitCode;
-  }
+  });
 }
 var HELP, MANUAL_COMMANDS, EXTRA_COMMAND_KEYS, COMMAND_KEY_SET, CLI_COMMAND_KEY_SET, MANUAL_COMMAND_KEY_SET, COMMAND_OPERATION_ID_BY_KEY;
 var init_src2 = __esm(async () => {
@@ -95365,6 +96663,7 @@ var init_src2 = __esm(async () => {
   init_operation_args();
   init_install();
   init_uninstall();
+  init_context();
   init_cli();
   HELP = [
     CLI_HELP,