@superdoc-dev/cli 0.2.0-next.84 → 0.2.0-next.86

package/dist/index.js

@@ -1149,7 +1149,8 @@ var init_operation_definitions = __esm(() => {
         throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
       }),
       referenceDocPath: `format/${camelToKebab(entry.key)}.mdx`,
-      referenceGroup: "format"
+      referenceGroup: "format",
+      skipAsATool: true
     };
     return [operationId, definition];
   }));
@@ -1165,7 +1166,8 @@ var init_operation_definitions = __esm(() => {
         deterministicTargetResolution: false
       }),
       referenceDocPath: "find.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      skipAsATool: true
     },
     getNode: {
       memberPath: "getNode",
@@ -1189,7 +1191,8 @@ var init_operation_definitions = __esm(() => {
         throws: T_NOT_FOUND
       }),
       referenceDocPath: "get-node-by-id.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      essential: true
     },
     getText: {
       memberPath: "getText",
@@ -1198,7 +1201,8 @@ var init_operation_definitions = __esm(() => {
       requiresDocumentContext: true,
       metadata: readOperation(),
       referenceDocPath: "get-text.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      essential: true
     },
     getMarkdown: {
       memberPath: "getMarkdown",
@@ -2473,7 +2477,8 @@ var init_operation_definitions = __esm(() => {
         deterministicTargetResolution: true
       }),
       referenceDocPath: "query/match.mdx",
-      referenceGroup: "query"
+      referenceGroup: "query",
+      essential: true
     },
     "mutations.preview": {
       memberPath: "mutations.preview",
@@ -2502,7 +2507,8 @@ var init_operation_definitions = __esm(() => {
         deterministicTargetResolution: true
       }),
       referenceDocPath: "mutations/apply.mdx",
-      referenceGroup: "mutations"
+      referenceGroup: "mutations",
+      essential: true
     },
     "capabilities.get": {
       memberPath: "capabilities",
@@ -3323,7 +3329,8 @@ var init_operation_definitions = __esm(() => {
         throws: ["CAPABILITY_UNAVAILABLE"]
       }),
       referenceDocPath: "history/undo.mdx",
-      referenceGroup: "history"
+      referenceGroup: "history",
+      essential: true
     },
     "history.redo": {
       memberPath: "history.redo",
@@ -3541,6 +3548,93 @@ var init_operation_definitions = __esm(() => {
       }),
       referenceDocPath: "images/set-z-order.mdx",
       referenceGroup: "images"
+    },
+    "hyperlinks.list": {
+      memberPath: "hyperlinks.list",
+      description: "List all hyperlinks in the document, with optional filtering by href, anchor, or display text.",
+      expectedResult: "Returns a HyperlinksListResult with an array of hyperlink discovery items and pagination metadata.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent"
+      }),
+      referenceDocPath: "hyperlinks/list.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.get": {
+      memberPath: "hyperlinks.get",
+      description: "Retrieve details of a specific hyperlink by its inline address.",
+      expectedResult: "Returns a HyperlinkInfo object with the address, destination properties, and display text.",
+      requiresDocumentContext: true,
+      metadata: readOperation({
+        idempotency: "idempotent",
+        throws: ["TARGET_NOT_FOUND", "INVALID_TARGET"]
+      }),
+      referenceDocPath: "hyperlinks/get.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.wrap": {
+      memberPath: "hyperlinks.wrap",
+      description: "Wrap an existing text range with a hyperlink.",
+      expectedResult: "Returns a HyperlinkMutationResult with the created hyperlink address on success, or a failure code on no-op.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "hyperlinks/wrap.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.insert": {
+      memberPath: "hyperlinks.insert",
+      description: "Insert new linked text at a target position.",
+      expectedResult: "Returns a HyperlinkMutationResult with the created hyperlink address on success, or a failure code.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "non-idempotent",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "hyperlinks/insert.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.patch": {
+      memberPath: "hyperlinks.patch",
+      description: "Update hyperlink metadata (destination, tooltip, target, rel) without changing display text.",
+      expectedResult: "Returns a HyperlinkMutationResult with the updated hyperlink address on success, or NO_OP if unchanged.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "hyperlinks/patch.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.remove": {
+      memberPath: "hyperlinks.remove",
+      description: "Remove a hyperlink. Mode 'unwrap' preserves display text; 'deleteText' removes the linked content entirely.",
+      expectedResult: "Returns a HyperlinkMutationResult with the removed hyperlink address on success, or a failure code on no-op.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [...T_NOT_FOUND_CAPABLE, "INVALID_TARGET", "INVALID_INPUT"]
+      }),
+      referenceDocPath: "hyperlinks/remove.mdx",
+      referenceGroup: "hyperlinks"
     }
   };
   OPERATION_IDS = Object.freeze(Object.keys(OPERATION_DEFINITIONS));
@@ -4826,6 +4920,9 @@ function tocEntryMutationResultSchema() {
     oneOf: [tocEntryMutationSuccessSchema, tocEntryMutationFailureSchema]
   };
 }
+function hyperlinkMutationResultSchema() {
+  return { oneOf: [hyperlinkMutationSuccessSchema, hyperlinkMutationFailureSchema] };
+}
 function buildInternalContractSchemas() {
   const operations = { ...operationSchemas };
   for (const operationId of OPERATION_IDS) {
@@ -4845,7 +4942,7 @@ function buildInternalContractSchemas() {
     operations
   };
 }
-var nodeTypeValues, blockNodeTypeValues, deletableBlockNodeTypeValues, inlineNodeTypeValues, knownTargetKindValues, SHARED_DEFS, rangeSchema, positionSchema, inlineAnchorSchema, targetKindSchema, textAddressSchema, textTargetSchema, blockNodeAddressSchema, deletableBlockNodeAddressSchema, paragraphAddressSchema, headingAddressSchema, listItemAddressSchema, paragraphTargetSchema, sectionAddressSchema, inlineNodeAddressSchema, nodeAddressSchema, commentAddressSchema, trackedChangeAddressSchema, entityAddressSchema, resolvedHandleSchema, pageInfoSchema, receiptSuccessSchema, textMutationRangeSchema, textMutationResolutionSchema, textMutationSuccessSchema, matchRunSchema, matchBlockSchema, trackChangeRefSchema, createParagraphSuccessSchema, createHeadingSuccessSchema, headingLevelSchema, listsInsertSuccessSchema, listsMutateItemSuccessSchema, listsExitSuccessSchema, nodeSummarySchema, nodeInfoSchema, matchContextSchema, unknownNodeDiagnosticSchema, textSelectorSchema, nodeSelectorSchema, selectorShorthandSchema, selectSchema, findInputSchema, findItemDomainSchema, findOutputSchema, documentInfoCountsSchema, documentInfoOutlineItemSchema, documentInfoCapabilitiesSchema, documentInfoSchema, listKindSchema, listInsertPositionSchema, listItemInfoSchema, listItemDomainItemSchema, listsListResultSchema, sectionBreakTypeSchema, sectionOrientationSchema, sectionVerticalAlignSchema, sectionDirectionSchema, sectionHeaderFooterKindSchema, sectionHeaderFooterVariantSchema, sectionLineNumberRestartSchema, sectionPageNumberFormatSchema, sectionRangeDomainSchema, sectionPageMarginsSchema, sectionHeaderFooterMarginsSchema, sectionPageSetupSchema, sectionColumnsSchema, sectionLineNumberingSchema, sectionPageNumberingSchema, sectionHeaderFooterRefsSchema, sectionBorderSpecSchema, sectionPageBordersSchema, sectionInfoSchema, sectionResolvedHandleSchema, sectionDomainItemSchema, sectionsListResultSchema, sectionMutationSuccessSchema, documentMutationSuccessSchema, paragraphMutationTargetSchema, paragraphMutationSuccessSchema, createSectionBreakSuccessSchema, commentInfoSchema, commentDomainItemSchema, commentsListResultSchema, trackChangeInfoSchema, trackChangeDomainItemSchema, trackChangesListResultSchema, capabilityReasonCodeSchema, capabilityReasonsSchema, capabilityFlagSchema, operationRuntimeCapabilitySchema, operationCapabilitiesSchema, inlinePropertyCapabilitySchema, inlinePropertyCapabilitiesByKeySchema, formatCapabilitiesSchema, planEngineCapabilitiesSchema, capabilitiesOutputSchema, strictEmptyObjectSchema, insertInputSchema, tableLocatorSchema, _tableScopedRowLocatorSchema, _tableScopedColumnLocatorSchema, mergeRangeLocatorSchema, mixedRowLocatorOneOf, tableCreateLocationSchema, tableMutationSuccessSchema, createTableSuccessSchema, tableMutationFailureCodes, tableMutationFailureSchema, tableMutationResultSchema, createTableResultSchema, historyActionSuccessSchema, historyActionFailureSchema, formatInlineAliasOperationSchemas, tocMutationFailureCodes, tocMutationFailureSchema, tocMutationSuccessSchema, tocEntryMutationFailureCodes, tocEntryMutationFailureSchema, tocEntryMutationSuccessSchema, operationSchemas;
+var nodeTypeValues, blockNodeTypeValues, deletableBlockNodeTypeValues, inlineNodeTypeValues, knownTargetKindValues, SHARED_DEFS, rangeSchema, positionSchema, inlineAnchorSchema, targetKindSchema, textAddressSchema, textTargetSchema, blockNodeAddressSchema, deletableBlockNodeAddressSchema, paragraphAddressSchema, headingAddressSchema, listItemAddressSchema, paragraphTargetSchema, sectionAddressSchema, inlineNodeAddressSchema, nodeAddressSchema, commentAddressSchema, trackedChangeAddressSchema, entityAddressSchema, resolvedHandleSchema, pageInfoSchema, receiptSuccessSchema, textMutationRangeSchema, textMutationResolutionSchema, textMutationSuccessSchema, matchRunSchema, matchBlockSchema, trackChangeRefSchema, createParagraphSuccessSchema, createHeadingSuccessSchema, headingLevelSchema, listsInsertSuccessSchema, listsMutateItemSuccessSchema, listsExitSuccessSchema, nodeSummarySchema, nodeInfoSchema, matchContextSchema, unknownNodeDiagnosticSchema, textSelectorSchema, nodeSelectorSchema, selectorShorthandSchema, selectSchema, findInputSchema, findItemDomainSchema, findOutputSchema, documentInfoCountsSchema, documentInfoOutlineItemSchema, documentInfoCapabilitiesSchema, documentInfoSchema, listKindSchema, listInsertPositionSchema, listItemInfoSchema, listItemDomainItemSchema, listsListResultSchema, sectionBreakTypeSchema, sectionOrientationSchema, sectionVerticalAlignSchema, sectionDirectionSchema, sectionHeaderFooterKindSchema, sectionHeaderFooterVariantSchema, sectionLineNumberRestartSchema, sectionPageNumberFormatSchema, sectionRangeDomainSchema, sectionPageMarginsSchema, sectionHeaderFooterMarginsSchema, sectionPageSetupSchema, sectionColumnsSchema, sectionLineNumberingSchema, sectionPageNumberingSchema, sectionHeaderFooterRefsSchema, sectionBorderSpecSchema, sectionPageBordersSchema, sectionInfoSchema, sectionResolvedHandleSchema, sectionDomainItemSchema, sectionsListResultSchema, sectionMutationSuccessSchema, documentMutationSuccessSchema, paragraphMutationTargetSchema, paragraphMutationSuccessSchema, createSectionBreakSuccessSchema, commentInfoSchema, commentDomainItemSchema, commentsListResultSchema, trackChangeInfoSchema, trackChangeDomainItemSchema, trackChangesListResultSchema, capabilityReasonCodeSchema, capabilityReasonsSchema, capabilityFlagSchema, operationRuntimeCapabilitySchema, operationCapabilitiesSchema, inlinePropertyCapabilitySchema, inlinePropertyCapabilitiesByKeySchema, formatCapabilitiesSchema, planEngineCapabilitiesSchema, capabilitiesOutputSchema, strictEmptyObjectSchema, insertInputSchema, tableLocatorSchema, _tableScopedRowLocatorSchema, _tableScopedColumnLocatorSchema, mergeRangeLocatorSchema, mixedRowLocatorOneOf, tableCreateLocationSchema, tableMutationSuccessSchema, createTableSuccessSchema, tableMutationFailureCodes, tableMutationFailureSchema, tableMutationResultSchema, createTableResultSchema, historyActionSuccessSchema, historyActionFailureSchema, formatInlineAliasOperationSchemas, tocMutationFailureCodes, tocMutationFailureSchema, tocMutationSuccessSchema, tocEntryMutationFailureCodes, tocEntryMutationFailureSchema, tocEntryMutationSuccessSchema, hyperlinkTargetSchema, hyperlinkReadPropertiesSchema, hyperlinkDestinationSchema, hyperlinkSpecSchema, hyperlinkPatchSchema, hyperlinkDomainSchema, hyperlinkMutationSuccessSchema, hyperlinkMutationFailureCodes, hyperlinkMutationFailureSchema, hyperlinkInfoSchema, operationSchemas;
 var init_schemas = __esm(() => {
   init_command_catalog();
   init_types2();
@@ -5608,6 +5705,63 @@ var init_schemas = __esm(() => {
     }, ["code", "message"])
   }, ["success", "failure"]);
   tocEntryMutationSuccessSchema = objectSchema({ success: { const: true }, entry: tocEntryAddressSchema() }, ["success", "entry"]);
+  hyperlinkTargetSchema = objectSchema({
+    kind: { const: "inline" },
+    nodeType: { const: "hyperlink" },
+    anchor: ref("InlineAnchor")
+  }, ["kind", "nodeType", "anchor"]);
+  hyperlinkReadPropertiesSchema = objectSchema({
+    href: { type: "string" },
+    anchor: { type: "string" },
+    docLocation: { type: "string" },
+    tooltip: { type: "string" },
+    target: { type: "string" },
+    rel: { type: "string" }
+  });
+  hyperlinkDestinationSchema = objectSchema({
+    href: { type: "string" },
+    anchor: { type: "string" },
+    docLocation: { type: "string" }
+  });
+  hyperlinkSpecSchema = objectSchema({
+    destination: hyperlinkDestinationSchema,
+    tooltip: { type: "string" },
+    target: { type: "string" },
+    rel: { type: "string" }
+  }, ["destination"]);
+  hyperlinkPatchSchema = objectSchema({
+    href: { oneOf: [{ type: "string" }, { type: "null" }] },
+    anchor: { oneOf: [{ type: "string" }, { type: "null" }] },
+    docLocation: { oneOf: [{ type: "string" }, { type: "null" }] },
+    tooltip: { oneOf: [{ type: "string" }, { type: "null" }] },
+    target: { oneOf: [{ type: "string" }, { type: "null" }] },
+    rel: { oneOf: [{ type: "string" }, { type: "null" }] }
+  });
+  hyperlinkDomainSchema = objectSchema({
+    address: hyperlinkTargetSchema,
+    properties: hyperlinkReadPropertiesSchema,
+    text: { type: "string" }
+  }, ["address", "properties"]);
+  hyperlinkMutationSuccessSchema = objectSchema({ success: { const: true }, hyperlink: hyperlinkTargetSchema }, ["success", "hyperlink"]);
+  hyperlinkMutationFailureCodes = [
+    "NO_OP",
+    "INVALID_TARGET",
+    "TARGET_NOT_FOUND",
+    "CAPABILITY_UNAVAILABLE"
+  ];
+  hyperlinkMutationFailureSchema = objectSchema({
+    success: { const: false },
+    failure: objectSchema({
+      code: { enum: [...hyperlinkMutationFailureCodes] },
+      message: { type: "string" },
+      details: { type: "object" }
+    }, ["code", "message"])
+  }, ["success", "failure"]);
+  hyperlinkInfoSchema = objectSchema({
+    address: hyperlinkTargetSchema,
+    properties: hyperlinkReadPropertiesSchema,
+    text: { type: "string" }
+  }, ["address", "properties"]);
   operationSchemas = {
     find: {
       input: findInputSchema,
@@ -6666,42 +6820,148 @@ var init_schemas = __esm(() => {
         return discoveryResultSchema({ oneOf: [textMatchItemSchema, nodeMatchItemSchema] }, queryMatchMetaSchema);
       })()
     },
-    "mutations.preview": {
-      input: objectSchema({
-        expectedRevision: { type: "string" },
-        atomic: { const: true },
-        changeMode: { enum: ["direct", "tracked"] },
-        steps: arraySchema({ type: "object" })
-      }, ["atomic", "changeMode", "steps"]),
-      output: objectSchema({
-        evaluatedRevision: { type: "string" },
-        steps: arraySchema({ type: "object" }),
-        valid: { type: "boolean" },
-        failures: arraySchema({ type: "object" })
-      }, ["evaluatedRevision", "steps", "valid"])
-    },
-    "mutations.apply": {
-      input: objectSchema({
+    ...(() => {
+      const selectWhereSchema = objectSchema({
+        by: { const: "select", type: "string" },
+        select: { oneOf: [textSelectorSchema, nodeSelectorSchema] },
+        within: nodeAddressSchema,
+        require: { enum: ["first", "exactlyOne", "all"] }
+      }, ["by", "select", "require"]);
+      const refWhereSchema = objectSchema({
+        by: { const: "ref", type: "string" },
+        ref: { type: "string" },
+        within: nodeAddressSchema
+      }, ["by", "ref"]);
+      const stepWhereSchema = { oneOf: [selectWhereSchema, refWhereSchema] };
+      const insertWhereSchema = objectSchema({
+        by: { const: "select", type: "string" },
+        select: { oneOf: [textSelectorSchema, nodeSelectorSchema] },
+        within: nodeAddressSchema,
+        require: { enum: ["first", "exactlyOne"] }
+      }, ["by", "select", "require"]);
+      const assertWhereSchema = objectSchema({
+        by: { const: "select", type: "string" },
+        select: { oneOf: [textSelectorSchema, nodeSelectorSchema] },
+        within: nodeAddressSchema
+      }, ["by", "select"]);
+      const replacementBlockSchema = objectSchema({ text: { type: "string" } }, ["text"]);
+      const replacementPayloadSchema = {
+        oneOf: [
+          objectSchema({ text: { type: "string" } }, ["text"]),
+          objectSchema({ blocks: arraySchema(replacementBlockSchema) }, ["blocks"])
+        ]
+      };
+      const inlineDirectiveSchema = { enum: [...INLINE_DIRECTIVES] };
+      const setMarksSchema = objectSchema({
+        bold: inlineDirectiveSchema,
+        italic: inlineDirectiveSchema,
+        underline: inlineDirectiveSchema,
+        strike: inlineDirectiveSchema
+      });
+      const inlineStylePolicySchema = objectSchema({
+        mode: { enum: ["preserve", "set", "clear", "merge"], type: "string" },
+        requireUniform: { type: "boolean" },
+        onNonUniform: { enum: ["error", "useLeadingRun", "majority", "union"] },
+        setMarks: setMarksSchema
+      }, ["mode"]);
+      const paragraphStylePolicySchema = objectSchema({
+        mode: { enum: ["preserve", "set", "clear"], type: "string" }
+      }, ["mode"]);
+      const stylePolicySchema = objectSchema({
+        inline: inlineStylePolicySchema,
+        paragraph: paragraphStylePolicySchema
+      }, ["inline"]);
+      const insertStylePolicySchema = objectSchema({
+        inline: objectSchema({
+          mode: { enum: ["inherit", "set", "clear"], type: "string" },
+          setMarks: setMarksSchema
+        }, ["mode"])
+      }, ["inline"]);
+      const textRewriteStepSchema = objectSchema({
+        id: { type: "string" },
+        op: { const: "text.rewrite", type: "string" },
+        where: stepWhereSchema,
+        args: objectSchema({
+          replacement: replacementPayloadSchema,
+          style: stylePolicySchema
+        }, ["replacement"])
+      }, ["id", "op", "where", "args"]);
+      const textInsertStepSchema = objectSchema({
+        id: { type: "string" },
+        op: { const: "text.insert", type: "string" },
+        where: insertWhereSchema,
+        args: objectSchema({
+          position: { enum: ["before", "after"] },
+          content: objectSchema({ text: { type: "string" } }, ["text"]),
+          style: insertStylePolicySchema
+        }, ["position", "content"])
+      }, ["id", "op", "where", "args"]);
+      const textDeleteStepSchema = objectSchema({
+        id: { type: "string" },
+        op: { const: "text.delete", type: "string" },
+        where: stepWhereSchema,
+        args: objectSchema({})
+      }, ["id", "op", "where", "args"]);
+      const formatApplyStepSchema = objectSchema({
+        id: { type: "string" },
+        op: { const: "format.apply", type: "string" },
+        where: stepWhereSchema,
+        args: objectSchema({
+          inline: buildInlineRunPatchSchema()
+        }, ["inline"])
+      }, ["id", "op", "where", "args"]);
+      const assertStepSchema = objectSchema({
+        id: { type: "string" },
+        op: { const: "assert", type: "string" },
+        where: assertWhereSchema,
+        args: objectSchema({
+          expectCount: { type: "number" }
+        }, ["expectCount"])
+      }, ["id", "op", "where", "args"]);
+      const mutationStepSchema = {
+        oneOf: [
+          textRewriteStepSchema,
+          textInsertStepSchema,
+          textDeleteStepSchema,
+          formatApplyStepSchema,
+          assertStepSchema
+        ]
+      };
+      const mutationsInputSchema = objectSchema({
         expectedRevision: { type: "string" },
-        atomic: { const: true },
+        atomic: { const: true, type: "boolean" },
         changeMode: { enum: ["direct", "tracked"] },
-        steps: arraySchema({ type: "object" })
-      }, ["atomic", "changeMode", "steps"]),
-      output: objectSchema({
-        success: { const: true },
-        revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
-        steps: arraySchema({ type: "object" }),
-        trackedChanges: arraySchema({ type: "object" }),
-        timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
-      }, ["success", "revision", "steps", "timing"]),
-      success: objectSchema({
-        success: { const: true },
-        revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
-        steps: arraySchema({ type: "object" }),
-        timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
-      }, ["success", "revision", "steps", "timing"]),
-      failure: preApplyFailureResultSchemaFor("mutations.apply")
-    },
+        steps: arraySchema(mutationStepSchema)
+      }, ["atomic", "changeMode", "steps"]);
+      return {
+        "mutations.preview": {
+          input: mutationsInputSchema,
+          output: objectSchema({
+            evaluatedRevision: { type: "string" },
+            steps: arraySchema({ type: "object" }),
+            valid: { type: "boolean" },
+            failures: arraySchema({ type: "object" })
+          }, ["evaluatedRevision", "steps", "valid"])
+        },
+        "mutations.apply": {
+          input: mutationsInputSchema,
+          output: objectSchema({
+            success: { const: true },
+            revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
+            steps: arraySchema({ type: "object" }),
+            trackedChanges: arraySchema({ type: "object" }),
+            timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
+          }, ["success", "revision", "steps", "timing"]),
+          success: objectSchema({
+            success: { const: true },
+            revision: objectSchema({ before: { type: "string" }, after: { type: "string" } }, ["before", "after"]),
+            steps: arraySchema({ type: "object" }),
+            timing: objectSchema({ totalMs: { type: "number" } }, ["totalMs"])
+          }, ["success", "revision", "steps", "timing"]),
+          failure: preApplyFailureResultSchemaFor("mutations.apply")
+        }
+      };
+    })(),
     "capabilities.get": {
       input: strictEmptyObjectSchema,
       output: capabilitiesOutputSchema
@@ -7652,6 +7912,48 @@ var init_schemas = __esm(() => {
         success: { const: false },
         failure: objectSchema({ code: { type: "string" }, message: { type: "string" } }, ["code", "message"])
       }, ["success", "failure"])
+    },
+    "hyperlinks.list": {
+      input: objectSchema({
+        within: nodeAddressSchema,
+        hrefPattern: { type: "string" },
+        anchor: { type: "string" },
+        textPattern: { type: "string" },
+        limit: { type: "integer" },
+        offset: { type: "integer" }
+      }),
+      output: discoveryResultSchema(hyperlinkDomainSchema)
+    },
+    "hyperlinks.get": {
+      input: objectSchema({ target: hyperlinkTargetSchema }, ["target"]),
+      output: hyperlinkInfoSchema
+    },
+    "hyperlinks.wrap": {
+      input: objectSchema({ target: textAddressSchema, link: hyperlinkSpecSchema }, ["target", "link"]),
+      output: hyperlinkMutationResultSchema(),
+      success: hyperlinkMutationSuccessSchema,
+      failure: hyperlinkMutationFailureSchema
+    },
+    "hyperlinks.insert": {
+      input: objectSchema({ target: textAddressSchema, text: { type: "string" }, link: hyperlinkSpecSchema }, [
+        "text",
+        "link"
+      ]),
+      output: hyperlinkMutationResultSchema(),
+      success: hyperlinkMutationSuccessSchema,
+      failure: hyperlinkMutationFailureSchema
+    },
+    "hyperlinks.patch": {
+      input: objectSchema({ target: hyperlinkTargetSchema, patch: hyperlinkPatchSchema }, ["target", "patch"]),
+      output: hyperlinkMutationResultSchema(),
+      success: hyperlinkMutationSuccessSchema,
+      failure: hyperlinkMutationFailureSchema
+    },
+    "hyperlinks.remove": {
+      input: objectSchema({ target: hyperlinkTargetSchema, mode: { enum: ["unwrap", "deleteText"] } }, ["target"]),
+      output: hyperlinkMutationResultSchema(),
+      success: hyperlinkMutationSuccessSchema,
+      failure: hyperlinkMutationFailureSchema
     }
   };
 });
@@ -7761,6 +8063,11 @@ var init_reference_doc_map = __esm(() => {
       title: "Images",
       description: "Image lifecycle, placement, and wrap configuration.",
       pagePath: "images/index.mdx"
+    },
+    hyperlinks: {
+      title: "Hyperlinks",
+      description: "Hyperlink discovery, creation, and metadata management.",
+      pagePath: "hyperlinks/index.mdx"
     }
   };
   REFERENCE_OPERATION_GROUPS = Object.keys(GROUP_METADATA).map((key) => ({
@@ -8875,7 +9182,13 @@ function buildDispatchTable(api) {
     "images.setWrapDistances": (input, options) => api.images.setWrapDistances(input, options),
     "images.setPosition": (input, options) => api.images.setPosition(input, options),
     "images.setAnchorOptions": (input, options) => api.images.setAnchorOptions(input, options),
-    "images.setZOrder": (input, options) => api.images.setZOrder(input, options)
+    "images.setZOrder": (input, options) => api.images.setZOrder(input, options),
+    "hyperlinks.list": (input) => api.hyperlinks.list(input),
+    "hyperlinks.get": (input) => api.hyperlinks.get(input),
+    "hyperlinks.wrap": (input, options) => api.hyperlinks.wrap(input, options),
+    "hyperlinks.insert": (input, options) => api.hyperlinks.insert(input, options),
+    "hyperlinks.patch": (input, options) => api.hyperlinks.patch(input, options),
+    "hyperlinks.remove": (input, options) => api.hyperlinks.remove(input, options)
   };
 }
 var init_invoke = __esm(() => {
@@ -9516,6 +9829,116 @@ var init_toc = __esm(() => {
   init_errors2();
 });
 
+// ../../packages/document-api/src/hyperlinks/hyperlinks.ts
+function isHyperlinkTarget(value) {
+  if (!isRecord(value))
+    return false;
+  if (value.kind !== "inline" || value.nodeType !== "hyperlink")
+    return false;
+  const anchor = value.anchor;
+  if (!isRecord(anchor))
+    return false;
+  const start = anchor.start;
+  const end = anchor.end;
+  if (!isRecord(start) || !isRecord(end))
+    return false;
+  return typeof start.blockId === "string" && typeof start.offset === "number" && typeof end.blockId === "string" && typeof end.offset === "number";
+}
+function validateHyperlinkTarget(target, operationName) {
+  if (target === undefined || target === null) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} requires a target.`);
+  }
+  if (!isHyperlinkTarget(target)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} target must be a HyperlinkTarget with kind 'inline', nodeType 'hyperlink', and a valid anchor.`, { target });
+  }
+}
+function validateDestination(destination, operationName) {
+  if (!isRecord(destination)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} requires a destination object.`);
+  }
+  const hasHref = typeof destination.href === "string" && destination.href.length > 0;
+  const hasAnchor = typeof destination.anchor === "string" && destination.anchor.length > 0;
+  if (!hasHref && !hasAnchor) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} destination must have at least one of 'href' or 'anchor'.`);
+  }
+}
+function validateHyperlinkSpec(link, operationName) {
+  if (!isRecord(link)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} requires a link specification object.`);
+  }
+  validateDestination(link.destination, operationName);
+}
+function validatePatch(patch, operationName) {
+  if (!isRecord(patch)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} requires a patch object.`);
+  }
+  for (const key of Object.keys(patch)) {
+    if (!PATCH_FIELDS.has(key)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `Unknown field "${key}" on ${operationName} patch. Allowed: ${[...PATCH_FIELDS].join(", ")}.`, { field: key });
+    }
+  }
+  const hasField = Object.keys(patch).some((k) => patch[k] !== undefined);
+  if (!hasField) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch must set at least one field.`);
+  }
+  for (const key of PATCH_FIELDS) {
+    const val = patch[key];
+    if (val !== undefined && val !== null && typeof val !== "string") {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch.${key} must be a string, null, or omitted.`);
+    }
+  }
+}
+function executeHyperlinksList(adapter, query2) {
+  return adapter.list(query2);
+}
+function executeHyperlinksGet(adapter, input) {
+  validateHyperlinkTarget(input.target, "hyperlinks.get");
+  return adapter.get(input);
+}
+function executeHyperlinksWrap(adapter, input, options) {
+  if (!isTextAddress(input.target)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", "hyperlinks.wrap requires a valid TextAddress target with kind 'text', blockId, and range.");
+  }
+  if (input.target.range.start === input.target.range.end) {
+    throw new DocumentApiValidationError("INVALID_TARGET", "hyperlinks.wrap requires a non-collapsed range (start !== end).");
+  }
+  validateHyperlinkSpec(input.link, "hyperlinks.wrap");
+  return adapter.wrap(input, normalizeMutationOptions(options));
+}
+function executeHyperlinksInsert(adapter, input, options) {
+  if (typeof input.text !== "string" || input.text.length === 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "hyperlinks.insert requires a non-empty text string.");
+  }
+  if (input.target !== undefined) {
+    if (!isTextAddress(input.target)) {
+      throw new DocumentApiValidationError("INVALID_TARGET", "hyperlinks.insert target (if provided) must be a valid TextAddress with kind 'text', blockId, and range.");
+    }
+    if (input.target.range.start !== input.target.range.end) {
+      throw new DocumentApiValidationError("INVALID_TARGET", "hyperlinks.insert target must be a collapsed range (start === end) indicating the insertion point.");
+    }
+  }
+  validateHyperlinkSpec(input.link, "hyperlinks.insert");
+  return adapter.insert(input, normalizeMutationOptions(options));
+}
+function executeHyperlinksPatch(adapter, input, options) {
+  validateHyperlinkTarget(input.target, "hyperlinks.patch");
+  validatePatch(input.patch, "hyperlinks.patch");
+  return adapter.patch(input, normalizeMutationOptions(options));
+}
+function executeHyperlinksRemove(adapter, input, options) {
+  validateHyperlinkTarget(input.target, "hyperlinks.remove");
+  if (input.mode !== undefined && input.mode !== "unwrap" && input.mode !== "deleteText") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `hyperlinks.remove mode must be 'unwrap' or 'deleteText', got '${String(input.mode)}'.`);
+  }
+  return adapter.remove(input, normalizeMutationOptions(options));
+}
+var PATCH_FIELDS;
+var init_hyperlinks = __esm(() => {
+  init_errors2();
+  init_validation_primitives();
+  PATCH_FIELDS = new Set(["href", "anchor", "docLocation", "tooltip", "target", "rel"]);
+});
+
 // ../../packages/document-api/src/lists/lists.types.ts
 var LIST_KINDS, LIST_INSERT_POSITIONS;
 var init_lists_types = __esm(() => {
@@ -10045,6 +10468,26 @@ function createDocumentApi(adapters) {
         return executeTocEditEntry(adapters.toc, input, options);
       }
     },
+    hyperlinks: {
+      list(query2) {
+        return executeHyperlinksList(adapters.hyperlinks, query2);
+      },
+      get(input) {
+        return executeHyperlinksGet(adapters.hyperlinks, input);
+      },
+      wrap(input, options) {
+        return executeHyperlinksWrap(adapters.hyperlinks, input, options);
+      },
+      insert(input, options) {
+        return executeHyperlinksInsert(adapters.hyperlinks, input, options);
+      },
+      patch(input, options) {
+        return executeHyperlinksPatch(adapters.hyperlinks, input, options);
+      },
+      remove(input, options) {
+        return executeHyperlinksRemove(adapters.hyperlinks, input, options);
+      }
+    },
     query: {
       match(input) {
         return adapters.query.match(input);
@@ -10099,6 +10542,7 @@ var init_src = __esm(() => {
   init_sections();
   init_images();
   init_toc();
+  init_hyperlinks();
   init_inline_run_patch();
   init_styles();
   init_paragraphs();
@@ -11323,7 +11767,7 @@ var CLI_ONLY_OPERATION_DEFINITIONS;
 var init_cli_only_operation_definitions = __esm(() => {
   CLI_ONLY_OPERATION_DEFINITIONS = {
     open: {
-      category: "lifecycle",
+      category: "session",
       description: "Open a document and create a persistent editing session. Optionally override the document body with contentOverride + overrideType (markdown, html, or text).",
       requiresDocumentContext: false,
       intentName: "open_document",
@@ -11361,7 +11805,7 @@ var init_cli_only_operation_definitions = __esm(() => {
       }
     },
     save: {
-      category: "lifecycle",
+      category: "session",
       description: "Save the current session to the original file or a new path.",
       requiresDocumentContext: false,
       intentName: "save_document",
@@ -11400,7 +11844,7 @@ var init_cli_only_operation_definitions = __esm(() => {
       }
     },
     close: {
-      category: "lifecycle",
+      category: "session",
       description: "Close the active editing session and clean up resources.",
       requiresDocumentContext: false,
       intentName: "close_document",
@@ -11427,7 +11871,7 @@ var init_cli_only_operation_definitions = __esm(() => {
       }
     },
     status: {
-      category: "introspection",
+      category: "session",
       description: "Show the current session status and document metadata.",
       requiresDocumentContext: false,
       intentName: "get_status",
@@ -11451,10 +11895,11 @@ var init_cli_only_operation_definitions = __esm(() => {
       }
     },
     describe: {
-      category: "introspection",
+      category: "session",
       description: "List all available CLI operations and contract metadata.",
       requiresDocumentContext: false,
       intentName: "describe_commands",
+      skipAsATool: true,
       sdkMetadata: { mutates: false, idempotency: "idempotent", supportsTrackedMode: false, supportsDryRun: false },
       outputSchema: {
         type: "object",
@@ -11477,11 +11922,12 @@ var init_cli_only_operation_definitions = __esm(() => {
       }
     },
     describeCommand: {
-      category: "introspection",
+      category: "session",
       description: "Show detailed metadata for a single CLI operation.",
       requiresDocumentContext: false,
       tokenOverride: ["describe", "command"],
       intentName: "describe_command",
+      skipAsATool: true,
       sdkMetadata: { mutates: false, idempotency: "idempotent", supportsTrackedMode: false, supportsDryRun: false },
       outputSchema: {
         type: "object",
@@ -11626,11 +12072,8 @@ function toDocApiId(cliOpId) {
 function deriveCategoryFromDocApi(docApiId) {
   const group = REFERENCE_GROUP_BY_OP.get(docApiId);
   if (!group)
-    return "query";
-  if (group === "core" || group === "mutations") {
-    return COMMAND_CATALOG[docApiId].mutates ? "mutation" : "query";
-  }
-  return group;
+    return "core";
+  return REFERENCE_GROUP_TO_CATEGORY[group] ?? "core";
 }
 function cliCategory(cliOpId) {
   const docApiId = toDocApiId(cliOpId);
@@ -11668,7 +12111,7 @@ function cliCommandTokens(cliOpId) {
     return override;
   return stripped.split(".").map(camelToKebab2);
 }
-var CLI_OPERATION_DENYLIST, denySet, CLI_DOC_OPERATIONS, CLI_OPERATION_IDS, REFERENCE_GROUP_BY_OP;
+var CLI_OPERATION_DENYLIST, denySet, CLI_DOC_OPERATIONS, CLI_OPERATION_IDS, REFERENCE_GROUP_BY_OP, REFERENCE_GROUP_TO_CATEGORY;
 var init_operation_set = __esm(() => {
   init_src();
   init_cli_only_operation_definitions();
@@ -11687,6 +12130,26 @@ var init_operation_set = __esm(() => {
       REFERENCE_GROUP_BY_OP.set(opId, group.key);
     }
   }
+  REFERENCE_GROUP_TO_CATEGORY = {
+    core: "core",
+    mutations: "core",
+    query: "core",
+    blocks: "core",
+    capabilities: "core",
+    format: "format",
+    "format.paragraph": "format",
+    styles: "format",
+    "styles.paragraph": "format",
+    create: "create",
+    tables: "tables",
+    sections: "sections",
+    lists: "lists",
+    comments: "comments",
+    trackChanges: "trackChanges",
+    toc: "toc",
+    images: "images",
+    history: "history"
+  };
 });
 
 // ../../packages/superdoc/dist/chunks/rolldown-runtime-B2q5OVn9.es.js
@@ -32315,7 +32778,7 @@ var init_remark_gfm_z_sDF4ss_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-CejXSSGL.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-C3jSWLmj.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -34104,10 +34567,10 @@ function discoveryItemSchema2(domainProperties, domainRequired = []) {
   ]);
 }
 function possibleFailureCodes2(operationId) {
-  return [...COMMAND_CATALOG2[operationId].possibleFailureCodes];
+  return [...COMMAND_CATALOG3[operationId].possibleFailureCodes];
 }
 function preApplyThrowCodes2(operationId) {
-  return [...COMMAND_CATALOG2[operationId].throws.preApply];
+  return [...COMMAND_CATALOG3[operationId].throws.preApply];
 }
 function receiptFailureSchemaFor2(operationId) {
   const codes = possibleFailureCodes2(operationId);
@@ -34264,6 +34727,9 @@ function tocEntryInsertionTargetSchema2() {
 function tocEntryMutationResultSchema2() {
   return { oneOf: [tocEntryMutationSuccessSchema2, tocEntryMutationFailureSchema2] };
 }
+function hyperlinkMutationResultSchema2() {
+  return { oneOf: [hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureSchema2] };
+}
 function step2(opId, domain2, description, options = {}) {
   return {
     opId,
@@ -35087,7 +35553,13 @@ function buildDispatchTable2(api) {
     "images.setWrapDistances": (input, options) => api.images.setWrapDistances(input, options),
     "images.setPosition": (input, options) => api.images.setPosition(input, options),
     "images.setAnchorOptions": (input, options) => api.images.setAnchorOptions(input, options),
-    "images.setZOrder": (input, options) => api.images.setZOrder(input, options)
+    "images.setZOrder": (input, options) => api.images.setZOrder(input, options),
+    "hyperlinks.list": (input) => api.hyperlinks.list(input),
+    "hyperlinks.get": (input) => api.hyperlinks.get(input),
+    "hyperlinks.wrap": (input, options) => api.hyperlinks.wrap(input, options),
+    "hyperlinks.insert": (input, options) => api.hyperlinks.insert(input, options),
+    "hyperlinks.patch": (input, options) => api.hyperlinks.patch(input, options),
+    "hyperlinks.remove": (input, options) => api.hyperlinks.remove(input, options)
   };
 }
 function executeHistoryGet2(adapter) {
@@ -35612,6 +36084,91 @@ function executeTocEditEntry2(adapter, input, options) {
   validateTocEntryTarget2(input.target, "toc.editEntry");
   return adapter.editEntry(input, normalizeMutationOptions2(options));
 }
+function isHyperlinkTarget2(value) {
+  if (!isRecord3(value))
+    return false;
+  if (value.kind !== "inline" || value.nodeType !== "hyperlink")
+    return false;
+  const anchor = value.anchor;
+  if (!isRecord3(anchor))
+    return false;
+  const start = anchor.start;
+  const end = anchor.end;
+  if (!isRecord3(start) || !isRecord3(end))
+    return false;
+  return typeof start.blockId === "string" && typeof start.offset === "number" && typeof end.blockId === "string" && typeof end.offset === "number";
+}
+function validateHyperlinkTarget2(target, operationName) {
+  if (target === undefined || target === null)
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} requires a target.`);
+  if (!isHyperlinkTarget2(target))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} target must be a HyperlinkTarget with kind 'inline', nodeType 'hyperlink', and a valid anchor.`, { target });
+}
+function validateDestination2(destination, operationName) {
+  if (!isRecord3(destination))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} requires a destination object.`);
+  const hasHref = typeof destination.href === "string" && destination.href.length > 0;
+  const hasAnchor = typeof destination.anchor === "string" && destination.anchor.length > 0;
+  if (!hasHref && !hasAnchor)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} destination must have at least one of 'href' or 'anchor'.`);
+}
+function validateHyperlinkSpec2(link2, operationName) {
+  if (!isRecord3(link2))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} requires a link specification object.`);
+  validateDestination2(link2.destination, operationName);
+}
+function validatePatch2(patch, operationName) {
+  if (!isRecord3(patch))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} requires a patch object.`);
+  for (const key of Object.keys(patch))
+    if (!PATCH_FIELDS2.has(key))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `Unknown field "${key}" on ${operationName} patch. Allowed: ${[...PATCH_FIELDS2].join(", ")}.`, { field: key });
+  if (!Object.keys(patch).some((k) => patch[k] !== undefined))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch must set at least one field.`);
+  for (const key of PATCH_FIELDS2) {
+    const val = patch[key];
+    if (val !== undefined && val !== null && typeof val !== "string")
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch.${key} must be a string, null, or omitted.`);
+  }
+}
+function executeHyperlinksList2(adapter, query2) {
+  return adapter.list(query2);
+}
+function executeHyperlinksGet2(adapter, input) {
+  validateHyperlinkTarget2(input.target, "hyperlinks.get");
+  return adapter.get(input);
+}
+function executeHyperlinksWrap2(adapter, input, options) {
+  if (!isTextAddress2(input.target))
+    throw new DocumentApiValidationError2("INVALID_TARGET", "hyperlinks.wrap requires a valid TextAddress target with kind 'text', blockId, and range.");
+  if (input.target.range.start === input.target.range.end)
+    throw new DocumentApiValidationError2("INVALID_TARGET", "hyperlinks.wrap requires a non-collapsed range (start !== end).");
+  validateHyperlinkSpec2(input.link, "hyperlinks.wrap");
+  return adapter.wrap(input, normalizeMutationOptions2(options));
+}
+function executeHyperlinksInsert2(adapter, input, options) {
+  if (typeof input.text !== "string" || input.text.length === 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", "hyperlinks.insert requires a non-empty text string.");
+  if (input.target !== undefined) {
+    if (!isTextAddress2(input.target))
+      throw new DocumentApiValidationError2("INVALID_TARGET", "hyperlinks.insert target (if provided) must be a valid TextAddress with kind 'text', blockId, and range.");
+    if (input.target.range.start !== input.target.range.end)
+      throw new DocumentApiValidationError2("INVALID_TARGET", "hyperlinks.insert target must be a collapsed range (start === end) indicating the insertion point.");
+  }
+  validateHyperlinkSpec2(input.link, "hyperlinks.insert");
+  return adapter.insert(input, normalizeMutationOptions2(options));
+}
+function executeHyperlinksPatch2(adapter, input, options) {
+  validateHyperlinkTarget2(input.target, "hyperlinks.patch");
+  validatePatch2(input.patch, "hyperlinks.patch");
+  return adapter.patch(input, normalizeMutationOptions2(options));
+}
+function executeHyperlinksRemove2(adapter, input, options) {
+  validateHyperlinkTarget2(input.target, "hyperlinks.remove");
+  if (input.mode !== undefined && input.mode !== "unwrap" && input.mode !== "deleteText")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `hyperlinks.remove mode must be 'unwrap' or 'deleteText', got '${String(input.mode)}'.`);
+  return adapter.remove(input, normalizeMutationOptions2(options));
+}
 function buildFormatInlineAliasApi2(adapter) {
   return Object.fromEntries(INLINE_PROPERTY_REGISTRY2.map((entry) => {
     const key = entry.key;
@@ -36135,6 +36692,26 @@ function createDocumentApi2(adapters) {
         return executeTocEditEntry2(adapters.toc, input, options);
       }
     },
+    hyperlinks: {
+      list(query2) {
+        return executeHyperlinksList2(adapters.hyperlinks, query2);
+      },
+      get(input) {
+        return executeHyperlinksGet2(adapters.hyperlinks, input);
+      },
+      wrap(input, options) {
+        return executeHyperlinksWrap2(adapters.hyperlinks, input, options);
+      },
+      insert(input, options) {
+        return executeHyperlinksInsert2(adapters.hyperlinks, input, options);
+      },
+      patch(input, options) {
+        return executeHyperlinksPatch2(adapters.hyperlinks, input, options);
+      },
+      remove(input, options) {
+        return executeHyperlinksRemove2(adapters.hyperlinks, input, options);
+      }
+    },
     query: { match(input) {
       return adapters.query.match(input);
     } },
@@ -52323,7 +52900,7 @@ var isRegExp = (value) => {
   tracked: false,
   carrier: runAttributeCarrier2(runPropertyKey ?? key),
   schema
-}), INLINE_PROPERTY_REGISTRY2, INLINE_PROPERTY_KEY_SET2, INLINE_PROPERTY_BY_KEY2, UNDERLINE_OBJECT_ALLOWED_KEYS2, SHADING_ALLOWED_KEYS2, BORDER_ALLOWED_KEYS2, FIT_TEXT_ALLOWED_KEYS2, LANG_ALLOWED_KEYS2, RFONTS_ALLOWED_KEYS2, EAST_ASIAN_LAYOUT_ALLOWED_KEYS2, STYLISTIC_SET_ALLOWED_KEYS2, VERT_ALIGN_VALUES2, NONE_FAILURES2, NONE_THROWS2, T_NOT_FOUND2, T_NOT_FOUND_CAPABLE2, T_PLAN_ENGINE2, T_NOT_FOUND_COMMAND2, T_NOT_FOUND_COMMAND_TRACKED2, T_IMAGE_COMMAND2, T_QUERY_MATCH2, T_SECTION_CREATE2, T_SECTION_READ2, T_PARAGRAPH_MUTATION2, T_SECTION_MUTATION2, T_SECTION_SETTINGS_MUTATION2, FORMAT_INLINE_ALIAS_OPERATION_DEFINITIONS2, OPERATION_DEFINITIONS2, OPERATION_IDS2, COMMAND_CATALOG2, PARAGRAPH_ALIGNMENTS2, TAB_STOP_ALIGNMENTS2, TAB_STOP_LEADERS2, BORDER_SIDES2, CLEAR_BORDER_SIDES2, LINE_RULES2, PARAGRAPH_BLOCK_TYPES2, SET_STYLE_KEYS2, CLEAR_STYLE_KEYS2, RESET_DIRECT_FORMATTING_KEYS2, SET_ALIGNMENT_KEYS2, CLEAR_ALIGNMENT_KEYS2, SET_INDENTATION_KEYS2, CLEAR_INDENTATION_KEYS2, SET_SPACING_KEYS2, CLEAR_SPACING_KEYS2, SET_KEEP_OPTIONS_KEYS2, SET_OUTLINE_LEVEL_KEYS2, SET_FLOW_OPTIONS_KEYS2, SET_TAB_STOP_KEYS2, CLEAR_TAB_STOP_KEYS2, CLEAR_ALL_TAB_STOPS_KEYS2, SET_BORDER_KEYS2, CLEAR_BORDER_KEYS2, SET_SHADING_KEYS2, CLEAR_SHADING_KEYS2, ST_ON_OFF_ON_VALUES2, ST_ON_OFF_OFF_VALUES2, ST_UNDERLINE_VALUES2, ST_UNDERLINE_VALUE_SET2, ST_VERTICAL_ALIGN_RUN2, ST_EM2, ST_TEXT_ALIGNMENT2, ST_TEXT_DIRECTION2, ST_TEXTBOX_TIGHT_WRAP2, ST_TEXT_TRANSFORM2, ST_JUSTIFICATION2, FONT_FAMILY_SCHEMA2, COLOR_SCHEMA2, SPACING_SCHEMA2, INDENT_SCHEMA2, UNDERLINE_SCHEMA2, BORDER_PROPERTIES_SCHEMA2, SHADING_SCHEMA2, LANG_SCHEMA2, EAST_ASIAN_LAYOUT_SCHEMA2, FIT_TEXT_SCHEMA2, NUMBERING_PROPERTIES_SCHEMA2, FRAME_PR_SCHEMA2, PARAGRAPH_BORDERS_SCHEMA2, TAB_STOP_SCHEMA2, PROPERTY_REGISTRY3, ALLOWED_KEYS_BY_CHANNEL2, PROPERTY_INDEX2, EXCLUDED_KEYS2, INPUT_ALLOWED_KEYS2, TARGET_ALLOWED_KEYS2, OPTIONS_ALLOWED_KEYS2, VALID_CHANNELS2, Z_ORDER_RELATIVE_HEIGHT_MAX2 = 4294967295, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, rangeSchema2, textAddressSchema2, textTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, paragraphTargetSchema2, sectionAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchBlockSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, headingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, nodeSummarySchema2, nodeInfoSchema2, matchContextSchema2, unknownNodeDiagnosticSchema2, textSelectorSchema2, nodeSelectorSchema2, findItemDomainSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, listKindSchema2, listInsertPositionSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, capabilityReasonsSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, tableCreateLocationSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, GROUP_METADATA2, STEP_OP_CATALOG_UNFROZEN2, PUBLIC_STEP_OP_CATALOG_UNFROZEN2, PUBLIC_MUTATION_STEP_OP_IDS2, PUBLIC_MUTATION_STEP_OP_SET2, CAPABILITY_REASON_CODES2, CREATE_COMMENT_ALLOWED_KEYS2, PATCH_COMMENT_ALLOWED_KEYS2, STYLE_APPLY_INPUT_ALLOWED_KEYS2, INLINE_ALIAS_INPUT_ALLOWED_KEYS2, DELETE_INPUT_ALLOWED_KEYS2, INSERT_INPUT_ALLOWED_KEYS2, VALID_INSERT_TYPES2, REPLACE_INPUT_ALLOWED_KEYS2, SECTION_BREAK_TYPES$1, SUPPORTED_DELETE_NODE_TYPES2, REJECTED_DELETE_NODE_TYPES2, TABLE_LOCATOR_OPS2, ROW_LOCATOR_OPS2, COLUMN_LOCATOR_OPS2, MERGE_RANGE_LOCATOR_OPS2, DEFAULT_SECTIONS_LIST_LIMIT2 = 250, SECTION_BREAK_TYPES3, SECTION_ORIENTATIONS2, SECTION_VERTICAL_ALIGNS2, SECTION_DIRECTIONS2, HEADER_FOOTER_KINDS2, HEADER_FOOTER_VARIANTS2, LINE_NUMBER_RESTARTS2, PAGE_NUMBER_FORMATS2, PAGE_BORDER_DISPLAYS2, PAGE_BORDER_OFFSET_FROM_VALUES2, PAGE_BORDER_Z_ORDER_VALUES2, VALID_WRAP_TYPES2, VALID_WRAP_SIDES2, VALID_IMAGE_SIZE_UNITS2, _buffers, _defaultCollectionId = null, _nextCollectionId = 1, generateV2HandlerEntity = (handlerName, translator$208) => ({
+}), INLINE_PROPERTY_REGISTRY2, INLINE_PROPERTY_KEY_SET2, INLINE_PROPERTY_BY_KEY2, UNDERLINE_OBJECT_ALLOWED_KEYS2, SHADING_ALLOWED_KEYS2, BORDER_ALLOWED_KEYS2, FIT_TEXT_ALLOWED_KEYS2, LANG_ALLOWED_KEYS2, RFONTS_ALLOWED_KEYS2, EAST_ASIAN_LAYOUT_ALLOWED_KEYS2, STYLISTIC_SET_ALLOWED_KEYS2, VERT_ALIGN_VALUES2, NONE_FAILURES2, NONE_THROWS2, T_NOT_FOUND2, T_NOT_FOUND_CAPABLE2, T_PLAN_ENGINE2, T_NOT_FOUND_COMMAND2, T_NOT_FOUND_COMMAND_TRACKED2, T_IMAGE_COMMAND2, T_QUERY_MATCH2, T_SECTION_CREATE2, T_SECTION_READ2, T_PARAGRAPH_MUTATION2, T_SECTION_MUTATION2, T_SECTION_SETTINGS_MUTATION2, FORMAT_INLINE_ALIAS_OPERATION_DEFINITIONS2, OPERATION_DEFINITIONS2, OPERATION_IDS2, COMMAND_CATALOG3, PARAGRAPH_ALIGNMENTS2, TAB_STOP_ALIGNMENTS2, TAB_STOP_LEADERS2, BORDER_SIDES2, CLEAR_BORDER_SIDES2, LINE_RULES2, PARAGRAPH_BLOCK_TYPES2, SET_STYLE_KEYS2, CLEAR_STYLE_KEYS2, RESET_DIRECT_FORMATTING_KEYS2, SET_ALIGNMENT_KEYS2, CLEAR_ALIGNMENT_KEYS2, SET_INDENTATION_KEYS2, CLEAR_INDENTATION_KEYS2, SET_SPACING_KEYS2, CLEAR_SPACING_KEYS2, SET_KEEP_OPTIONS_KEYS2, SET_OUTLINE_LEVEL_KEYS2, SET_FLOW_OPTIONS_KEYS2, SET_TAB_STOP_KEYS2, CLEAR_TAB_STOP_KEYS2, CLEAR_ALL_TAB_STOPS_KEYS2, SET_BORDER_KEYS2, CLEAR_BORDER_KEYS2, SET_SHADING_KEYS2, CLEAR_SHADING_KEYS2, ST_ON_OFF_ON_VALUES2, ST_ON_OFF_OFF_VALUES2, ST_UNDERLINE_VALUES2, ST_UNDERLINE_VALUE_SET2, ST_VERTICAL_ALIGN_RUN2, ST_EM2, ST_TEXT_ALIGNMENT2, ST_TEXT_DIRECTION2, ST_TEXTBOX_TIGHT_WRAP2, ST_TEXT_TRANSFORM2, ST_JUSTIFICATION2, FONT_FAMILY_SCHEMA2, COLOR_SCHEMA2, SPACING_SCHEMA2, INDENT_SCHEMA2, UNDERLINE_SCHEMA2, BORDER_PROPERTIES_SCHEMA2, SHADING_SCHEMA2, LANG_SCHEMA2, EAST_ASIAN_LAYOUT_SCHEMA2, FIT_TEXT_SCHEMA2, NUMBERING_PROPERTIES_SCHEMA2, FRAME_PR_SCHEMA2, PARAGRAPH_BORDERS_SCHEMA2, TAB_STOP_SCHEMA2, PROPERTY_REGISTRY3, ALLOWED_KEYS_BY_CHANNEL2, PROPERTY_INDEX2, EXCLUDED_KEYS2, INPUT_ALLOWED_KEYS2, TARGET_ALLOWED_KEYS2, OPTIONS_ALLOWED_KEYS2, VALID_CHANNELS2, Z_ORDER_RELATIVE_HEIGHT_MAX2 = 4294967295, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, rangeSchema2, textAddressSchema2, textTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, paragraphTargetSchema2, sectionAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchBlockSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, headingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, nodeSummarySchema2, nodeInfoSchema2, matchContextSchema2, unknownNodeDiagnosticSchema2, textSelectorSchema2, nodeSelectorSchema2, findItemDomainSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, listKindSchema2, listInsertPositionSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, capabilityReasonsSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, tableCreateLocationSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, hyperlinkTargetSchema2, hyperlinkReadPropertiesSchema2, hyperlinkSpecSchema2, hyperlinkPatchSchema2, hyperlinkDomainSchema2, hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureSchema2, GROUP_METADATA2, STEP_OP_CATALOG_UNFROZEN2, PUBLIC_STEP_OP_CATALOG_UNFROZEN2, PUBLIC_MUTATION_STEP_OP_IDS2, PUBLIC_MUTATION_STEP_OP_SET2, CAPABILITY_REASON_CODES2, CREATE_COMMENT_ALLOWED_KEYS2, PATCH_COMMENT_ALLOWED_KEYS2, STYLE_APPLY_INPUT_ALLOWED_KEYS2, INLINE_ALIAS_INPUT_ALLOWED_KEYS2, DELETE_INPUT_ALLOWED_KEYS2, INSERT_INPUT_ALLOWED_KEYS2, VALID_INSERT_TYPES2, REPLACE_INPUT_ALLOWED_KEYS2, SECTION_BREAK_TYPES$1, SUPPORTED_DELETE_NODE_TYPES2, REJECTED_DELETE_NODE_TYPES2, TABLE_LOCATOR_OPS2, ROW_LOCATOR_OPS2, COLUMN_LOCATOR_OPS2, MERGE_RANGE_LOCATOR_OPS2, DEFAULT_SECTIONS_LIST_LIMIT2 = 250, SECTION_BREAK_TYPES3, SECTION_ORIENTATIONS2, SECTION_VERTICAL_ALIGNS2, SECTION_DIRECTIONS2, HEADER_FOOTER_KINDS2, HEADER_FOOTER_VARIANTS2, LINE_NUMBER_RESTARTS2, PAGE_NUMBER_FORMATS2, PAGE_BORDER_DISPLAYS2, PAGE_BORDER_OFFSET_FROM_VALUES2, PAGE_BORDER_Z_ORDER_VALUES2, VALID_WRAP_TYPES2, VALID_WRAP_SIDES2, VALID_IMAGE_SIZE_UNITS2, PATCH_FIELDS2, _buffers, _defaultCollectionId = null, _nextCollectionId = 1, generateV2HandlerEntity = (handlerName, translator$208) => ({
   handlerName,
   handler: (params) => {
     const { nodes } = params;
@@ -63712,7 +64289,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_CejXSSGL_es = __esm(() => {
+var init_SuperConverter_C3jSWLmj_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_DLE8mr0n_es();
@@ -66513,7 +67090,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         ]
       }),
       referenceDocPath: `format/${camelToKebab3(entry.key)}.mdx`,
-      referenceGroup: "format"
+      referenceGroup: "format",
+      skipAsATool: true
     }];
   }));
   OPERATION_DEFINITIONS2 = {
@@ -66528,7 +67106,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         deterministicTargetResolution: false
       }),
       referenceDocPath: "find.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      skipAsATool: true
     },
     getNode: {
       memberPath: "getNode",
@@ -66552,7 +67131,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         throws: T_NOT_FOUND2
       }),
       referenceDocPath: "get-node-by-id.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      essential: true
     },
     getText: {
       memberPath: "getText",
@@ -66561,7 +67141,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
       requiresDocumentContext: true,
       metadata: readOperation2(),
       referenceDocPath: "get-text.mdx",
-      referenceGroup: "core"
+      referenceGroup: "core",
+      essential: true
     },
     getMarkdown: {
       memberPath: "getMarkdown",
@@ -68023,7 +68604,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         deterministicTargetResolution: true
       }),
       referenceDocPath: "query/match.mdx",
-      referenceGroup: "query"
+      referenceGroup: "query",
+      essential: true
     },
     "mutations.preview": {
       memberPath: "mutations.preview",
@@ -68052,7 +68634,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         deterministicTargetResolution: true
       }),
       referenceDocPath: "mutations/apply.mdx",
-      referenceGroup: "mutations"
+      referenceGroup: "mutations",
+      essential: true
     },
     "capabilities.get": {
       memberPath: "capabilities",
@@ -68907,7 +69490,8 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
         throws: ["CAPABILITY_UNAVAILABLE"]
       }),
       referenceDocPath: "history/undo.mdx",
-      referenceGroup: "history"
+      referenceGroup: "history",
+      essential: true
     },
     "history.redo": {
       memberPath: "history.redo",
@@ -69128,13 +69712,114 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
       }),
       referenceDocPath: "images/set-z-order.mdx",
       referenceGroup: "images"
+    },
+    "hyperlinks.list": {
+      memberPath: "hyperlinks.list",
+      description: "List all hyperlinks in the document, with optional filtering by href, anchor, or display text.",
+      expectedResult: "Returns a HyperlinksListResult with an array of hyperlink discovery items and pagination metadata.",
+      requiresDocumentContext: true,
+      metadata: readOperation2({ idempotency: "idempotent" }),
+      referenceDocPath: "hyperlinks/list.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.get": {
+      memberPath: "hyperlinks.get",
+      description: "Retrieve details of a specific hyperlink by its inline address.",
+      expectedResult: "Returns a HyperlinkInfo object with the address, destination properties, and display text.",
+      requiresDocumentContext: true,
+      metadata: readOperation2({
+        idempotency: "idempotent",
+        throws: ["TARGET_NOT_FOUND", "INVALID_TARGET"]
+      }),
+      referenceDocPath: "hyperlinks/get.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.wrap": {
+      memberPath: "hyperlinks.wrap",
+      description: "Wrap an existing text range with a hyperlink.",
+      expectedResult: "Returns a HyperlinkMutationResult with the created hyperlink address on success, or a failure code on no-op.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "hyperlinks/wrap.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.insert": {
+      memberPath: "hyperlinks.insert",
+      description: "Insert new linked text at a target position.",
+      expectedResult: "Returns a HyperlinkMutationResult with the created hyperlink address on success, or a failure code.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "non-idempotent",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP", "INVALID_TARGET"],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "hyperlinks/insert.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.patch": {
+      memberPath: "hyperlinks.patch",
+      description: "Update hyperlink metadata (destination, tooltip, target, rel) without changing display text.",
+      expectedResult: "Returns a HyperlinkMutationResult with the updated hyperlink address on success, or NO_OP if unchanged.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "hyperlinks/patch.mdx",
+      referenceGroup: "hyperlinks"
+    },
+    "hyperlinks.remove": {
+      memberPath: "hyperlinks.remove",
+      description: "Remove a hyperlink. Mode 'unwrap' preserves display text; 'deleteText' removes the linked content entirely.",
+      expectedResult: "Returns a HyperlinkMutationResult with the removed hyperlink address on success, or a failure code on no-op.",
+      requiresDocumentContext: true,
+      metadata: mutationOperation2({
+        idempotency: "conditional",
+        supportsDryRun: true,
+        supportsTrackedMode: false,
+        deterministicTargetResolution: true,
+        possibleFailureCodes: ["NO_OP"],
+        throws: [
+          ...T_NOT_FOUND_CAPABLE2,
+          "INVALID_TARGET",
+          "INVALID_INPUT"
+        ]
+      }),
+      referenceDocPath: "hyperlinks/remove.mdx",
+      referenceGroup: "hyperlinks"
     }
   };
   OPERATION_IDS2 = Object.freeze(Object.keys(OPERATION_DEFINITIONS2));
   Object.freeze(OPERATION_IDS2.filter((id) => !id.includes(".")));
   Object.freeze(OPERATION_IDS2.filter((id) => id.includes(".")));
-  COMMAND_CATALOG2 = projectFromDefinitions2((_id, entry) => entry.metadata);
-  OPERATION_IDS2.filter((operationId) => COMMAND_CATALOG2[operationId].mutates);
+  COMMAND_CATALOG3 = projectFromDefinitions2((_id, entry) => entry.metadata);
+  OPERATION_IDS2.filter((operationId) => COMMAND_CATALOG3[operationId].mutates);
   projectFromDefinitions2((_id, entry) => entry.description);
   projectFromDefinitions2((_id, entry) => entry.requiresDocumentContext);
   projectFromDefinitions2((_id, entry) => entry.expectedResult);
@@ -70926,6 +71611,68 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
     success: { const: true },
     entry: tocEntryAddressSchema2()
   }, ["success", "entry"]);
+  hyperlinkTargetSchema2 = objectSchema2({
+    kind: { const: "inline" },
+    nodeType: { const: "hyperlink" },
+    anchor: ref2("InlineAnchor")
+  }, [
+    "kind",
+    "nodeType",
+    "anchor"
+  ]);
+  hyperlinkReadPropertiesSchema2 = objectSchema2({
+    href: { type: "string" },
+    anchor: { type: "string" },
+    docLocation: { type: "string" },
+    tooltip: { type: "string" },
+    target: { type: "string" },
+    rel: { type: "string" }
+  });
+  hyperlinkSpecSchema2 = objectSchema2({
+    destination: objectSchema2({
+      href: { type: "string" },
+      anchor: { type: "string" },
+      docLocation: { type: "string" }
+    }),
+    tooltip: { type: "string" },
+    target: { type: "string" },
+    rel: { type: "string" }
+  }, ["destination"]);
+  hyperlinkPatchSchema2 = objectSchema2({
+    href: { oneOf: [{ type: "string" }, { type: "null" }] },
+    anchor: { oneOf: [{ type: "string" }, { type: "null" }] },
+    docLocation: { oneOf: [{ type: "string" }, { type: "null" }] },
+    tooltip: { oneOf: [{ type: "string" }, { type: "null" }] },
+    target: { oneOf: [{ type: "string" }, { type: "null" }] },
+    rel: { oneOf: [{ type: "string" }, { type: "null" }] }
+  });
+  hyperlinkDomainSchema2 = objectSchema2({
+    address: hyperlinkTargetSchema2,
+    properties: hyperlinkReadPropertiesSchema2,
+    text: { type: "string" }
+  }, ["address", "properties"]);
+  hyperlinkMutationSuccessSchema2 = objectSchema2({
+    success: { const: true },
+    hyperlink: hyperlinkTargetSchema2
+  }, ["success", "hyperlink"]);
+  hyperlinkMutationFailureSchema2 = objectSchema2({
+    success: { const: false },
+    failure: objectSchema2({
+      code: { enum: [...[
+        "NO_OP",
+        "INVALID_TARGET",
+        "TARGET_NOT_FOUND",
+        "CAPABILITY_UNAVAILABLE"
+      ]] },
+      message: { type: "string" },
+      details: { type: "object" }
+    }, ["code", "message"])
+  }, ["success", "failure"]);
+  objectSchema2({
+    address: hyperlinkTargetSchema2,
+    properties: hyperlinkReadPropertiesSchema2,
+    text: { type: "string" }
+  }, ["address", "properties"]);
   objectSchema2({
     nodeId: { type: "string" },
     nodeType: { enum: [...blockNodeTypeValues2] }
@@ -71687,61 +72434,241 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
     ]);
     const queryMatchMetaSchema = objectSchema2({ effectiveResolved: { type: "boolean" } }, ["effectiveResolved"]);
     return discoveryResultSchema2({ oneOf: [textMatchItemSchema, nodeMatchItemSchema] }, queryMatchMetaSchema);
-  })(), objectSchema2({
-    expectedRevision: { type: "string" },
-    atomic: { const: true },
-    changeMode: { enum: ["direct", "tracked"] },
-    steps: arraySchema2({ type: "object" })
-  }, [
-    "atomic",
-    "changeMode",
-    "steps"
-  ]), objectSchema2({
-    evaluatedRevision: { type: "string" },
-    steps: arraySchema2({ type: "object" }),
-    valid: { type: "boolean" },
-    failures: arraySchema2({ type: "object" })
-  }, [
-    "evaluatedRevision",
-    "steps",
-    "valid"
-  ]), objectSchema2({
-    expectedRevision: { type: "string" },
-    atomic: { const: true },
-    changeMode: { enum: ["direct", "tracked"] },
-    steps: arraySchema2({ type: "object" })
-  }, [
-    "atomic",
-    "changeMode",
-    "steps"
-  ]), objectSchema2({
-    success: { const: true },
-    revision: objectSchema2({
-      before: { type: "string" },
-      after: { type: "string" }
-    }, ["before", "after"]),
-    steps: arraySchema2({ type: "object" }),
-    trackedChanges: arraySchema2({ type: "object" }),
-    timing: objectSchema2({ totalMs: { type: "number" } }, ["totalMs"])
-  }, [
-    "success",
-    "revision",
-    "steps",
-    "timing"
-  ]), objectSchema2({
-    success: { const: true },
-    revision: objectSchema2({
-      before: { type: "string" },
-      after: { type: "string" }
-    }, ["before", "after"]),
-    steps: arraySchema2({ type: "object" }),
-    timing: objectSchema2({ totalMs: { type: "number" } }, ["totalMs"])
-  }, [
-    "success",
-    "revision",
-    "steps",
-    "timing"
-  ]), preApplyFailureResultSchemaFor2("mutations.apply"), objectSchema2({
+  })(), { ...(() => {
+    const stepWhereSchema = { oneOf: [objectSchema2({
+      by: {
+        const: "select",
+        type: "string"
+      },
+      select: { oneOf: [textSelectorSchema2, nodeSelectorSchema2] },
+      within: nodeAddressSchema2,
+      require: { enum: [
+        "first",
+        "exactlyOne",
+        "all"
+      ] }
+    }, [
+      "by",
+      "select",
+      "require"
+    ]), objectSchema2({
+      by: {
+        const: "ref",
+        type: "string"
+      },
+      ref: { type: "string" },
+      within: nodeAddressSchema2
+    }, ["by", "ref"])] };
+    const insertWhereSchema = objectSchema2({
+      by: {
+        const: "select",
+        type: "string"
+      },
+      select: { oneOf: [textSelectorSchema2, nodeSelectorSchema2] },
+      within: nodeAddressSchema2,
+      require: { enum: ["first", "exactlyOne"] }
+    }, [
+      "by",
+      "select",
+      "require"
+    ]);
+    const assertWhereSchema = objectSchema2({
+      by: {
+        const: "select",
+        type: "string"
+      },
+      select: { oneOf: [textSelectorSchema2, nodeSelectorSchema2] },
+      within: nodeAddressSchema2
+    }, ["by", "select"]);
+    const replacementBlockSchema = objectSchema2({ text: { type: "string" } }, ["text"]);
+    const replacementPayloadSchema = { oneOf: [objectSchema2({ text: { type: "string" } }, ["text"]), objectSchema2({ blocks: arraySchema2(replacementBlockSchema) }, ["blocks"])] };
+    const inlineDirectiveSchema = { enum: [...INLINE_DIRECTIVES2] };
+    const setMarksSchema = objectSchema2({
+      bold: inlineDirectiveSchema,
+      italic: inlineDirectiveSchema,
+      underline: inlineDirectiveSchema,
+      strike: inlineDirectiveSchema
+    });
+    const stylePolicySchema = objectSchema2({
+      inline: objectSchema2({
+        mode: {
+          enum: [
+            "preserve",
+            "set",
+            "clear",
+            "merge"
+          ],
+          type: "string"
+        },
+        requireUniform: { type: "boolean" },
+        onNonUniform: { enum: [
+          "error",
+          "useLeadingRun",
+          "majority",
+          "union"
+        ] },
+        setMarks: setMarksSchema
+      }, ["mode"]),
+      paragraph: objectSchema2({ mode: {
+        enum: [
+          "preserve",
+          "set",
+          "clear"
+        ],
+        type: "string"
+      } }, ["mode"])
+    }, ["inline"]);
+    const insertStylePolicySchema = objectSchema2({ inline: objectSchema2({
+      mode: {
+        enum: [
+          "inherit",
+          "set",
+          "clear"
+        ],
+        type: "string"
+      },
+      setMarks: setMarksSchema
+    }, ["mode"]) }, ["inline"]);
+    const mutationsInputSchema = objectSchema2({
+      expectedRevision: { type: "string" },
+      atomic: {
+        const: true,
+        type: "boolean"
+      },
+      changeMode: { enum: ["direct", "tracked"] },
+      steps: arraySchema2({ oneOf: [
+        objectSchema2({
+          id: { type: "string" },
+          op: {
+            const: "text.rewrite",
+            type: "string"
+          },
+          where: stepWhereSchema,
+          args: objectSchema2({
+            replacement: replacementPayloadSchema,
+            style: stylePolicySchema
+          }, ["replacement"])
+        }, [
+          "id",
+          "op",
+          "where",
+          "args"
+        ]),
+        objectSchema2({
+          id: { type: "string" },
+          op: {
+            const: "text.insert",
+            type: "string"
+          },
+          where: insertWhereSchema,
+          args: objectSchema2({
+            position: { enum: ["before", "after"] },
+            content: objectSchema2({ text: { type: "string" } }, ["text"]),
+            style: insertStylePolicySchema
+          }, ["position", "content"])
+        }, [
+          "id",
+          "op",
+          "where",
+          "args"
+        ]),
+        objectSchema2({
+          id: { type: "string" },
+          op: {
+            const: "text.delete",
+            type: "string"
+          },
+          where: stepWhereSchema,
+          args: objectSchema2({})
+        }, [
+          "id",
+          "op",
+          "where",
+          "args"
+        ]),
+        objectSchema2({
+          id: { type: "string" },
+          op: {
+            const: "format.apply",
+            type: "string"
+          },
+          where: stepWhereSchema,
+          args: objectSchema2({ inline: buildInlineRunPatchSchema2() }, ["inline"])
+        }, [
+          "id",
+          "op",
+          "where",
+          "args"
+        ]),
+        objectSchema2({
+          id: { type: "string" },
+          op: {
+            const: "assert",
+            type: "string"
+          },
+          where: assertWhereSchema,
+          args: objectSchema2({ expectCount: { type: "number" } }, ["expectCount"])
+        }, [
+          "id",
+          "op",
+          "where",
+          "args"
+        ])
+      ] })
+    }, [
+      "atomic",
+      "changeMode",
+      "steps"
+    ]);
+    return {
+      "mutations.preview": {
+        input: mutationsInputSchema,
+        output: objectSchema2({
+          evaluatedRevision: { type: "string" },
+          steps: arraySchema2({ type: "object" }),
+          valid: { type: "boolean" },
+          failures: arraySchema2({ type: "object" })
+        }, [
+          "evaluatedRevision",
+          "steps",
+          "valid"
+        ])
+      },
+      "mutations.apply": {
+        input: mutationsInputSchema,
+        output: objectSchema2({
+          success: { const: true },
+          revision: objectSchema2({
+            before: { type: "string" },
+            after: { type: "string" }
+          }, ["before", "after"]),
+          steps: arraySchema2({ type: "object" }),
+          trackedChanges: arraySchema2({ type: "object" }),
+          timing: objectSchema2({ totalMs: { type: "number" } }, ["totalMs"])
+        }, [
+          "success",
+          "revision",
+          "steps",
+          "timing"
+        ]),
+        success: objectSchema2({
+          success: { const: true },
+          revision: objectSchema2({
+            before: { type: "string" },
+            after: { type: "string" }
+          }, ["before", "after"]),
+          steps: arraySchema2({ type: "object" }),
+          timing: objectSchema2({ totalMs: { type: "number" } }, ["totalMs"])
+        }, [
+          "success",
+          "revision",
+          "steps",
+          "timing"
+        ]),
+        failure: preApplyFailureResultSchemaFor2("mutations.apply")
+      }
+    };
+  })() }, objectSchema2({
     rows: {
       type: "integer",
       minimum: 1
@@ -72689,7 +73616,27 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
       code: { type: "string" },
       message: { type: "string" }
     }, ["code", "message"])
-  }, ["success", "failure"]);
+  }, ["success", "failure"]), objectSchema2({
+    within: nodeAddressSchema2,
+    hrefPattern: { type: "string" },
+    anchor: { type: "string" },
+    textPattern: { type: "string" },
+    limit: { type: "integer" },
+    offset: { type: "integer" }
+  }), discoveryResultSchema2(hyperlinkDomainSchema2), objectSchema2({ target: hyperlinkTargetSchema2 }, ["target"]), objectSchema2({
+    target: textAddressSchema2,
+    link: hyperlinkSpecSchema2
+  }, ["target", "link"]), hyperlinkMutationResultSchema2(), objectSchema2({
+    target: textAddressSchema2,
+    text: { type: "string" },
+    link: hyperlinkSpecSchema2
+  }, ["text", "link"]), hyperlinkMutationResultSchema2(), objectSchema2({
+    target: hyperlinkTargetSchema2,
+    patch: hyperlinkPatchSchema2
+  }, ["target", "patch"]), hyperlinkMutationResultSchema2(), objectSchema2({
+    target: hyperlinkTargetSchema2,
+    mode: { enum: ["unwrap", "deleteText"] }
+  }, ["target"]), hyperlinkMutationResultSchema2();
   projectFromDefinitions2((_id, entry) => entry.memberPath);
   [...new Set(OPERATION_IDS2.map((id) => OPERATION_DEFINITIONS2[id].memberPath))];
   projectFromDefinitions2((_id, entry) => entry.referenceDocPath);
@@ -72783,6 +73730,11 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
       title: "Images",
       description: "Image lifecycle, placement, and wrap configuration.",
       pagePath: "images/index.mdx"
+    },
+    hyperlinks: {
+      title: "Hyperlinks",
+      description: "Hyperlink discovery, creation, and metadata management.",
+      pagePath: "hyperlinks/index.mdx"
     }
   };
   Object.keys(GROUP_METADATA2).map((key) => ({
@@ -72991,6 +73943,14 @@ var init_SuperConverter_CejXSSGL_es = __esm(() => {
     "pt",
     "twip"
   ]);
+  PATCH_FIELDS2 = new Set([
+    "href",
+    "anchor",
+    "docLocation",
+    "tooltip",
+    "target",
+    "rel"
+  ]);
   _buffers = /* @__PURE__ */ new Map;
   translator$35 = NodeTranslator.from(createStrictTogglePropertyHandler("w:b", "bold"));
   translator$39 = NodeTranslator.from(createSingleBooleanPropertyHandler("w:bCs", "boldCs"));
@@ -119798,9 +120758,9 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-D8ccu-r8.es.js
-var exports_src_D8ccu_r8_es = {};
-__export(exports_src_D8ccu_r8_es, {
+// ../../packages/superdoc/dist/chunks/src-nq0HTKfv.es.js
+var exports_src_nq0HTKfv_es = {};
+__export(exports_src_nq0HTKfv_es, {
   zt: () => defineMark,
   z: () => cM,
   yt: () => removeAwarenessStates,
@@ -129030,7 +129990,7 @@ function isCommandBackedAvailability(operationId) {
 function buildOperationCapabilities(editor) {
   const operations = {};
   for (const operationId of OPERATION_IDS2) {
-    const metadata = COMMAND_CATALOG2[operationId];
+    const metadata = COMMAND_CATALOG3[operationId];
     const available = isOperationAvailable(editor, operationId);
     const tracked = available && metadata.supportsTrackedMode && hasTrackedModeCapability(editor, operationId);
     const dryRun = metadata.supportsDryRun && available;
@@ -133677,7 +134637,7 @@ function listItemProjectionToInfo(projection, listId) {
     text: projection.text
   };
 }
-function matchesListQuery(projection, query2) {
+function matchesListQuery$1(projection, query2) {
   if (!query2)
     return true;
   if (query2.kind && projection.kind !== query2.kind)
@@ -133724,7 +134684,7 @@ function listListItems(editor, query2) {
   let total = 0;
   const items = [];
   for (const projection of projections) {
-    if (!matchesListQuery(projection, query2))
+    if (!matchesListQuery$1(projection, query2))
       continue;
     const currentIndex = total;
     total += 1;
@@ -141079,7 +142039,7 @@ function dispatchEditorTransaction(editor, tr) {
   }
   throw new Error("No transaction dispatcher available.");
 }
-function receiptApplied$1(receipt2) {
+function receiptApplied$2(receipt2) {
   return receipt2.steps[0]?.effect === "changed";
 }
 function isTocContentUnchanged(existingNode, newContent) {
@@ -141174,7 +142134,7 @@ function tocConfigureWrapper(editor, input2, options) {
   const shouldRefreshContent = !isTocContentUnchanged(resolved.node, nextContent);
   const command$1 = editor.commands?.setTableOfContentsInstructionById;
   const commandNodeId = resolved.commandNodeId ?? resolved.nodeId;
-  if (!receiptApplied$1(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
+  if (!receiptApplied$2(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
     sdBlockId: commandNodeId,
     instruction,
     ...shouldRefreshContent ? { content: nextContent } : {},
@@ -141217,7 +142177,7 @@ function tocUpdateAll(editor, input2, options) {
   if (options?.dryRun)
     return tocSuccess(resolved.nodeId);
   const command$1 = editor.commands?.replaceTableOfContentsContentById;
-  return receiptApplied$1(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
+  return receiptApplied$2(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
     sdBlockId: resolved.commandNodeId ?? resolved.nodeId,
     content: content3
   }, options?.expectedRevision) : runTocAction(editor, () => {
@@ -141260,7 +142220,7 @@ function tocUpdatePageNumbers(editor, input2, options) {
   if (options?.dryRun)
     return tocSuccess(resolved.nodeId);
   const command$1 = editor.commands?.replaceTableOfContentsContentById;
-  return receiptApplied$1(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
+  return receiptApplied$2(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
     sdBlockId: resolved.commandNodeId ?? resolved.nodeId,
     content: updatedContent
   }, options?.expectedRevision) : runTocAction(editor, () => {
@@ -141327,7 +142287,7 @@ function tocRemoveWrapper(editor, input2, options) {
   if (options?.dryRun)
     return tocSuccess(resolved.nodeId);
   const command$1 = editor.commands?.deleteTableOfContentsById;
-  return receiptApplied$1(typeof command$1 === "function" ? runTocCommand(editor, command$1, { sdBlockId: resolved.commandNodeId ?? resolved.nodeId }, options?.expectedRevision) : runTocAction(editor, () => {
+  return receiptApplied$2(typeof command$1 === "function" ? runTocCommand(editor, command$1, { sdBlockId: resolved.commandNodeId ?? resolved.nodeId }, options?.expectedRevision) : runTocAction(editor, () => {
     try {
       const { tr } = editor.state;
       tr.delete(resolved.pos, resolved.pos + resolved.node.nodeSize);
@@ -141358,7 +142318,7 @@ function createTableOfContentsWrapper(editor, input2, options) {
       toc: buildTocAddress("(dry-run)")
     };
   const command$1 = editor.commands?.insertTableOfContentsAt;
-  if (!receiptApplied$1(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
+  if (!receiptApplied$2(typeof command$1 === "function" ? runTocCommand(editor, command$1, {
     pos,
     instruction,
     sdBlockId,
@@ -141553,7 +142513,7 @@ function runEntryCommand(editor, command$1, args$1, expectedRevision) {
   const executeCommand = toEntryEditorCommand(command$1);
   return runEntryAction(editor, () => executeCommand(args$1), expectedRevision);
 }
-function receiptApplied(receipt2) {
+function receiptApplied$1(receipt2) {
   return receipt2.steps[0]?.effect === "changed";
 }
 function tocListEntriesWrapper(editor, query2) {
@@ -141600,7 +142560,7 @@ function tocMarkEntryWrapper(editor, input2, options) {
   const pos = (input2.target.position ?? "end") === "start" ? paragraph2.pos + 1 : paragraph2.pos + paragraph2.node.nodeSize - 1;
   if (options?.dryRun)
     return entrySuccess("(dry-run)");
-  if (!receiptApplied(runEntryCommand(editor, command$1, {
+  if (!receiptApplied$1(runEntryCommand(editor, command$1, {
     pos,
     instruction
   }, options?.expectedRevision)))
@@ -141622,7 +142582,7 @@ function tocUnmarkEntryWrapper(editor, input2, options) {
   const resolved = resolveTcEntryTarget(editor.state.doc, input2.target);
   if (options?.dryRun)
     return entrySuccess(resolved.nodeId);
-  return receiptApplied(runEntryCommand(editor, command$1, { pos: resolved.pos }, options?.expectedRevision)) ? entrySuccess(resolved.nodeId) : entryFailure("NO_OP", "TC entry removal produced no change.");
+  return receiptApplied$1(runEntryCommand(editor, command$1, { pos: resolved.pos }, options?.expectedRevision)) ? entrySuccess(resolved.nodeId) : entryFailure("NO_OP", "TC entry removal produced no change.");
 }
 function tocEditEntryWrapper(editor, input2, options) {
   rejectTrackedMode("toc.editEntry", options);
@@ -141635,7 +142595,7 @@ function tocEditEntryWrapper(editor, input2, options) {
     return entryFailure("NO_OP", "Edit patch produced no change.");
   if (options?.dryRun)
     return entrySuccess(resolved.nodeId);
-  if (!receiptApplied(runEntryCommand(editor, command$1, {
+  if (!receiptApplied$1(runEntryCommand(editor, command$1, {
     pos: resolved.pos,
     instruction: serializeTcInstruction(patched)
   }, options?.expectedRevision)))
@@ -142305,6 +143265,497 @@ function imagesSetZOrderWrapper(editor, input2, options) {
     return buildNoOpResult("Set z-order produced no change.");
   return buildSuccessResult(findImageById(editor, input2.imageId));
 }
+function getLinkMarkType(editor) {
+  const markType = editor.schema.marks.link;
+  if (!markType)
+    throw new Error("Link mark type is not defined in the editor schema.");
+  return markType;
+}
+function dispatchTransaction(editor, tr) {
+  editor.dispatch(tr);
+}
+function dispatchIfChanged(editor, tr) {
+  if (!tr.docChanged)
+    return false;
+  dispatchTransaction(editor, tr);
+  return true;
+}
+function createRelationshipId(editor, href) {
+  if (editor.options.mode !== "docx")
+    return null;
+  try {
+    return insertNewRelationship(href, "hyperlink", editor);
+  } catch {
+    return null;
+  }
+}
+function sanitizeHrefOrThrow(href) {
+  const result = sanitizeHref(href);
+  if (!result)
+    throw Object.assign(/* @__PURE__ */ new Error(`Blocked or invalid href: "${href}"`), { code: "INVALID_INPUT" });
+  return result.href;
+}
+function buildMarkAttrs(editor, spec) {
+  const attrs = {};
+  if (spec.href) {
+    attrs.href = sanitizeHrefOrThrow(spec.href);
+    attrs.rId = createRelationshipId(editor, attrs.href);
+  }
+  if (spec.anchor) {
+    attrs.anchor = spec.anchor;
+    if (!spec.href)
+      attrs.href = `#${spec.anchor}`;
+  }
+  if (spec.docLocation)
+    attrs.docLocation = spec.docLocation;
+  if (spec.tooltip)
+    attrs.tooltip = spec.tooltip;
+  if (spec.target)
+    attrs.target = spec.target;
+  if (spec.rel)
+    attrs.rel = spec.rel;
+  return attrs;
+}
+function wrapWithLink(editor, from$12, to, spec) {
+  const linkMarkType = getLinkMarkType(editor);
+  const attrs = buildMarkAttrs(editor, spec);
+  const tr = editor.state.tr;
+  tr.addMark(from$12, to, linkMarkType.create(attrs));
+  applyDirectMutationMeta(tr);
+  dispatchTransaction(editor, tr);
+  return true;
+}
+function insertLinkedText(editor, pos, text5, spec) {
+  const linkMarkType = getLinkMarkType(editor);
+  const attrs = buildMarkAttrs(editor, spec);
+  const tr = editor.state.tr;
+  const mark2 = linkMarkType.create(attrs);
+  tr.insertText(text5, pos);
+  tr.addMark(pos, pos + text5.length, mark2);
+  applyDirectMutationMeta(tr);
+  dispatchTransaction(editor, tr);
+  return true;
+}
+function patchLinkMark(editor, from$12, to, existingMark, patch3) {
+  const linkMarkType = getLinkMarkType(editor);
+  const merged = { ...existingMark.attrs };
+  for (const [key$1, value] of Object.entries(patch3)) {
+    if (value === undefined)
+      continue;
+    if (value === null)
+      merged[key$1] = null;
+    else
+      merged[key$1] = value;
+  }
+  if (typeof patch3.href === "string") {
+    merged.href = sanitizeHrefOrThrow(patch3.href);
+    merged.rId = createRelationshipId(editor, merged.href);
+  }
+  if (patch3.href === null && typeof merged.anchor === "string") {
+    merged.href = `#${merged.anchor}`;
+    merged.rId = null;
+  }
+  if (typeof patch3.anchor === "string" && patch3.href === undefined) {
+    const currentHref = merged.href;
+    if (typeof currentHref === "string" && currentHref.startsWith("#"))
+      merged.href = `#${patch3.anchor}`;
+  }
+  if (patch3.anchor === null && typeof merged.href === "string" && !merged.href.startsWith("#"))
+    merged.anchor = null;
+  const tr = editor.state.tr;
+  tr.removeMark(from$12, to, existingMark);
+  tr.addMark(from$12, to, linkMarkType.create(merged));
+  applyDirectMutationMeta(tr);
+  return dispatchIfChanged(editor, tr);
+}
+function unwrapLink(editor, from$12, to) {
+  const linkMarkType = getLinkMarkType(editor);
+  const tr = editor.state.tr;
+  tr.removeMark(from$12, to, linkMarkType);
+  applyDirectMutationMeta(tr);
+  return dispatchIfChanged(editor, tr);
+}
+function deleteLinkedText(editor, from$12, to) {
+  const tr = editor.state.tr;
+  tr.delete(from$12, to);
+  applyDirectMutationMeta(tr);
+  dispatchTransaction(editor, tr);
+  return true;
+}
+function normalizeReadProperties(attrs) {
+  const rawHref = typeof attrs.href === "string" ? attrs.href : undefined;
+  const rawAnchor = typeof attrs.anchor === "string" ? attrs.anchor : undefined;
+  const rawDocLocation = typeof attrs.docLocation === "string" ? attrs.docLocation : undefined;
+  const rawTooltip = typeof attrs.tooltip === "string" ? attrs.tooltip : undefined;
+  const rawTarget = typeof attrs.target === "string" ? attrs.target : undefined;
+  const rawRel = typeof attrs.rel === "string" ? attrs.rel : undefined;
+  const props = {};
+  let effectiveAnchor = rawAnchor;
+  let effectiveHref = rawHref;
+  if (rawHref && rawHref.startsWith("#")) {
+    const fragment = rawHref.slice(1);
+    if (!rawAnchor) {
+      effectiveAnchor = fragment;
+      effectiveHref = undefined;
+    } else if (rawAnchor === fragment)
+      effectiveHref = undefined;
+  }
+  if (effectiveHref)
+    props.href = effectiveHref;
+  if (effectiveAnchor)
+    props.anchor = effectiveAnchor;
+  if (rawDocLocation)
+    props.docLocation = rawDocLocation;
+  if (rawTooltip)
+    props.tooltip = rawTooltip;
+  if (rawTarget)
+    props.target = rawTarget;
+  if (rawRel)
+    props.rel = rawRel;
+  return props;
+}
+function candidateToTarget(candidate) {
+  return {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: candidate.anchor
+  };
+}
+function candidateToReadProperties(candidate) {
+  return normalizeReadProperties(candidate.mark?.attrs ?? candidate.attrs ?? {});
+}
+function extractDisplayText(editor, candidate) {
+  const doc$2 = editor.state.doc;
+  try {
+    return doc$2.textBetween(candidate.pos, candidate.end, "");
+  } catch {
+    return;
+  }
+}
+function candidateToDomain(editor, candidate) {
+  return {
+    address: candidateToTarget(candidate),
+    properties: candidateToReadProperties(candidate),
+    text: extractDisplayText(editor, candidate)
+  };
+}
+function encodeInlineRef(anchor) {
+  return `${anchor.start.blockId}:${anchor.start.offset}:${anchor.end.offset}`;
+}
+function isInsideTocBlock(editor, pos) {
+  const resolved = editor.state.doc.resolve(pos);
+  for (let depth = resolved.depth;depth > 0; depth--)
+    if (resolved.node(depth).type.name === "tableOfContents")
+      return true;
+  return false;
+}
+function rejectIfInsideToc(editor, pos, operationName) {
+  if (isInsideTocBlock(editor, pos))
+    throw new DocumentApiAdapterError("INVALID_TARGET", `${operationName}: target is inside a TOC block. TOC content is managed by toc.* operations.`);
+}
+function findHyperlinkCandidates(editor) {
+  return findInlineByType(buildInlineIndex(editor, getBlockIndex(editor)), "hyperlink");
+}
+function resolveHyperlinkCandidate(editor, target) {
+  const candidate = findInlineByAnchor(buildInlineIndex(editor, getBlockIndex(editor)), target);
+  if (!candidate)
+    throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "Hyperlink target not found in document.", { target });
+  return candidate;
+}
+function resolveCandidateTextRange(editor, candidate, operationName) {
+  const start$1 = candidate.anchor.start;
+  const end$1 = candidate.anchor.end;
+  if (start$1.blockId !== end$1.blockId)
+    throw new DocumentApiAdapterError("INVALID_TARGET", `${operationName}: hyperlink anchor spans multiple blocks.`, { anchor: candidate.anchor });
+  const resolved = resolveTextTarget(editor, {
+    kind: "text",
+    blockId: start$1.blockId,
+    range: {
+      start: start$1.offset,
+      end: end$1.offset
+    }
+  });
+  if (!resolved)
+    throw new DocumentApiAdapterError("TARGET_NOT_FOUND", `${operationName}: hyperlink text range could not be resolved.`, { anchor: candidate.anchor });
+  return resolved;
+}
+function hyperlinkSuccess(target) {
+  return {
+    success: true,
+    hyperlink: target
+  };
+}
+function hyperlinkFailure(code$1, message) {
+  return {
+    success: false,
+    failure: {
+      code: code$1,
+      message
+    }
+  };
+}
+function receiptApplied(receipt2) {
+  return receipt2.steps[0]?.effect === "changed";
+}
+function matchesListQuery(candidate, query2, editor) {
+  if (!query2)
+    return true;
+  const props = candidateToReadProperties(candidate);
+  if (query2.hrefPattern && (!props.href || !props.href.includes(query2.hrefPattern)))
+    return false;
+  if (query2.anchor && props.anchor !== query2.anchor)
+    return false;
+  if (query2.textPattern) {
+    const text5 = extractDisplayText(editor, candidate);
+    if (!text5 || !text5.includes(query2.textPattern))
+      return false;
+  }
+  return true;
+}
+function hyperlinksListWrapper(editor, query2) {
+  const revision = getRevision(editor);
+  let candidates = findHyperlinkCandidates(editor);
+  if (query2?.within) {
+    const withinResult = resolveWithinScope(getBlockIndex(editor), { within: query2.within }, []);
+    if (!withinResult.ok)
+      candidates = [];
+    else
+      candidates = scopeByRange(candidates, withinResult.range);
+  }
+  const { total, items: paged } = paginate(candidates.filter((c$3) => matchesListQuery(c$3, query2, editor)).map((candidate) => {
+    const domain2 = candidateToDomain(editor, candidate);
+    const ref$1 = encodeInlineRef(candidate.anchor);
+    return buildDiscoveryItem2(ref$1, buildResolvedHandle2(ref$1, "ephemeral", "node"), domain2);
+  }), query2?.offset, query2?.limit);
+  return buildDiscoveryResult2({
+    evaluatedRevision: revision,
+    total,
+    items: paged,
+    page: {
+      limit: query2?.limit ?? total,
+      offset: query2?.offset ?? 0,
+      returned: paged.length
+    }
+  });
+}
+function hyperlinksGetWrapper(editor, input2) {
+  const candidate = resolveHyperlinkCandidate(editor, input2.target);
+  return {
+    address: candidateToTarget(candidate),
+    properties: candidateToReadProperties(candidate),
+    text: extractDisplayText(editor, candidate)
+  };
+}
+function specFromInput(link2) {
+  return {
+    href: link2.destination.href,
+    anchor: link2.destination.anchor,
+    docLocation: link2.destination.docLocation,
+    tooltip: link2.tooltip,
+    target: link2.target,
+    rel: link2.rel
+  };
+}
+function hyperlinksWrapWrapper(editor, input2, options) {
+  rejectTrackedMode("hyperlinks.wrap", options);
+  const resolved = resolveTextTarget(editor, input2.target);
+  if (!resolved)
+    throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "hyperlinks.wrap: text target block not found.", { target: input2.target });
+  rejectIfInsideToc(editor, resolved.from, "hyperlinks.wrap");
+  const overlapping = findInlineByType(buildInlineIndex(editor, getBlockIndex(editor)), "hyperlink").filter((c$3) => c$3.pos < resolved.to && c$3.end > resolved.from);
+  if (overlapping.length > 1)
+    throw new DocumentApiAdapterError("INVALID_TARGET", "hyperlinks.wrap: target range spans multiple existing links.");
+  if (overlapping.length === 1) {
+    const existing = overlapping[0];
+    if (existing.pos === resolved.from && existing.end === resolved.to) {
+      const existingProps = candidateToReadProperties(existing);
+      const spec$1 = specFromInput(input2.link);
+      if (existingProps.href === spec$1.href && existingProps.anchor === spec$1.anchor)
+        return hyperlinkFailure("NO_OP", "Text range is already linked with the same destination.");
+    } else
+      throw new DocumentApiAdapterError("INVALID_TARGET", "hyperlinks.wrap: target range partially overlaps an existing link. Remove the existing link first.");
+  }
+  if (input2.link.destination.href)
+    sanitizeHrefOrThrow(input2.link.destination.href);
+  if (options?.dryRun)
+    return hyperlinkSuccess({
+      kind: "inline",
+      nodeType: "hyperlink",
+      anchor: {
+        start: {
+          blockId: input2.target.blockId,
+          offset: input2.target.range.start
+        },
+        end: {
+          blockId: input2.target.blockId,
+          offset: input2.target.range.end
+        }
+      }
+    });
+  const spec = specFromInput(input2.link);
+  if (!receiptApplied(executeDomainCommand(editor, () => {
+    const result = wrapWithLink(editor, resolved.from, resolved.to, spec);
+    if (result)
+      clearIndexCache(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision })))
+    return hyperlinkFailure("NO_OP", "Wrap operation produced no change.");
+  const postCandidate = findHyperlinkAtRange(editor, resolved.from, resolved.to);
+  return hyperlinkSuccess(postCandidate ? candidateToTarget(postCandidate) : {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: {
+      start: {
+        blockId: input2.target.blockId,
+        offset: input2.target.range.start
+      },
+      end: {
+        blockId: input2.target.blockId,
+        offset: input2.target.range.end
+      }
+    }
+  });
+}
+function hyperlinksInsertWrapper(editor, input2, options) {
+  rejectTrackedMode("hyperlinks.insert", options);
+  let insertPos;
+  let blockId;
+  let offset$1;
+  let structuralEnd = false;
+  if (input2.target) {
+    const resolved = resolveTextTarget(editor, input2.target);
+    if (!resolved)
+      throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "hyperlinks.insert: text target block not found.", { target: input2.target });
+    rejectIfInsideToc(editor, resolved.from, "hyperlinks.insert");
+    insertPos = resolved.from;
+    blockId = input2.target.blockId;
+    offset$1 = input2.target.range.start;
+  } else {
+    const fallback = resolveDefaultInsertTarget(editor);
+    if (!fallback)
+      throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "hyperlinks.insert: document has no content to insert into.");
+    if (fallback.kind === "text-block") {
+      insertPos = fallback.range.from;
+      blockId = fallback.target.blockId;
+      offset$1 = fallback.target.range.start;
+    } else {
+      insertPos = fallback.insertPos;
+      blockId = "";
+      offset$1 = 0;
+      structuralEnd = true;
+    }
+  }
+  if (input2.link.destination.href)
+    sanitizeHrefOrThrow(input2.link.destination.href);
+  if (options?.dryRun)
+    return hyperlinkSuccess({
+      kind: "inline",
+      nodeType: "hyperlink",
+      anchor: {
+        start: {
+          blockId,
+          offset: offset$1
+        },
+        end: {
+          blockId,
+          offset: offset$1 + input2.text.length
+        }
+      }
+    });
+  const spec = specFromInput(input2.link);
+  if (!receiptApplied(executeDomainCommand(editor, () => {
+    if (structuralEnd) {
+      insertParagraphAtEnd(editor, insertPos, input2.text);
+      clearIndexCache(editor);
+      const textStart = insertPos + 1;
+      const result$1 = wrapWithLink(editor, textStart, textStart + input2.text.length, spec);
+      if (result$1)
+        clearIndexCache(editor);
+      return result$1;
+    }
+    const result = insertLinkedText(editor, insertPos, input2.text, spec);
+    if (result)
+      clearIndexCache(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision })))
+    return hyperlinkFailure("NO_OP", "Insert operation produced no change.");
+  const searchFrom = structuralEnd ? insertPos + 1 : insertPos;
+  const postCandidate = findHyperlinkAtRange(editor, searchFrom, searchFrom + input2.text.length);
+  return hyperlinkSuccess(postCandidate ? candidateToTarget(postCandidate) : {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: {
+      start: {
+        blockId,
+        offset: offset$1
+      },
+      end: {
+        blockId,
+        offset: offset$1 + input2.text.length
+      }
+    }
+  });
+}
+function hyperlinksPatchWrapper(editor, input2, options) {
+  rejectTrackedMode("hyperlinks.patch", options);
+  const candidate = resolveHyperlinkCandidate(editor, input2.target);
+  const resolvedRange = resolveCandidateTextRange(editor, candidate, "hyperlinks.patch");
+  rejectIfInsideToc(editor, resolvedRange.from, "hyperlinks.patch");
+  const existingMark = candidate.mark;
+  if (!existingMark)
+    throw new DocumentApiAdapterError("TARGET_NOT_FOUND", "hyperlinks.patch: resolved candidate has no mark.");
+  const oldAttrs = existingMark.attrs;
+  const mergedHref = input2.patch.href === undefined ? oldAttrs.href : input2.patch.href;
+  const mergedAnchor = input2.patch.anchor === undefined ? oldAttrs.anchor : input2.patch.anchor;
+  const hasHref = typeof mergedHref === "string" && mergedHref.length > 0;
+  const hasAnchor = typeof mergedAnchor === "string" && mergedAnchor.length > 0;
+  if (!hasHref && !hasAnchor)
+    throw new DocumentApiAdapterError("INVALID_INPUT", "hyperlinks.patch: resulting destination must have at least one of href or anchor.");
+  if (typeof input2.patch.href === "string")
+    sanitizeHrefOrThrow(input2.patch.href);
+  const currentProps = candidateToReadProperties(candidate);
+  if (Object.entries(input2.patch).every(([key$1, value]) => {
+    if (value === undefined)
+      return true;
+    if (value === null)
+      return currentProps[key$1] === undefined;
+    return currentProps[key$1] === value;
+  }))
+    return hyperlinkFailure("NO_OP", "Patch produces no change — all values already match.");
+  if (options?.dryRun)
+    return hyperlinkSuccess(candidateToTarget(candidate));
+  if (!receiptApplied(executeDomainCommand(editor, () => {
+    const result = patchLinkMark(editor, resolvedRange.from, resolvedRange.to, existingMark, input2.patch);
+    if (result)
+      clearIndexCache(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision })))
+    return hyperlinkFailure("NO_OP", "Patch operation produced no change.");
+  const postCandidate = findHyperlinkAtRange(editor, resolvedRange.from, resolvedRange.to);
+  return hyperlinkSuccess(postCandidate ? candidateToTarget(postCandidate) : candidateToTarget(candidate));
+}
+function hyperlinksRemoveWrapper(editor, input2, options) {
+  rejectTrackedMode("hyperlinks.remove", options);
+  const candidate = resolveHyperlinkCandidate(editor, input2.target);
+  const resolvedRange = resolveCandidateTextRange(editor, candidate, "hyperlinks.remove");
+  rejectIfInsideToc(editor, resolvedRange.from, "hyperlinks.remove");
+  const mode = input2.mode ?? "unwrap";
+  const targetAddress = candidateToTarget(candidate);
+  if (options?.dryRun)
+    return hyperlinkSuccess(targetAddress);
+  if (!receiptApplied(executeDomainCommand(editor, () => {
+    const result = mode === "unwrap" ? unwrapLink(editor, resolvedRange.from, resolvedRange.to) : deleteLinkedText(editor, resolvedRange.from, resolvedRange.to);
+    if (result)
+      clearIndexCache(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision })))
+    return hyperlinkFailure("NO_OP", `Remove (${mode}) operation produced no change.`);
+  return hyperlinkSuccess(targetAddress);
+}
+function findHyperlinkAtRange(editor, from$12, to) {
+  const hyperlinks = findInlineByType(buildInlineIndex(editor, getBlockIndex(editor)), "hyperlink");
+  return hyperlinks.find((c$3) => c$3.pos >= from$12 - 1 && c$3.pos <= from$12 + 1 && c$3.end >= to - 1 && c$3.end <= to + 1) ?? hyperlinks.find((c$3) => c$3.pos <= from$12 && c$3.end >= to);
+}
 function assembleDocumentApiAdapters(editor) {
   registerBuiltInExecutors();
   initRevision(editor);
@@ -142487,6 +143938,14 @@ function assembleDocumentApiAdapters(editor) {
       setAnchorOptions: (input2, options) => imagesSetAnchorOptionsWrapper(editor, input2, options),
       setZOrder: (input2, options) => imagesSetZOrderWrapper(editor, input2, options)
     },
+    hyperlinks: {
+      list: (query2) => hyperlinksListWrapper(editor, query2),
+      get: (input2) => hyperlinksGetWrapper(editor, input2),
+      wrap: (input2, options) => hyperlinksWrapWrapper(editor, input2, options),
+      insert: (input2, options) => hyperlinksInsertWrapper(editor, input2, options),
+      patch: (input2, options) => hyperlinksPatchWrapper(editor, input2, options),
+      remove: (input2, options) => hyperlinksRemoveWrapper(editor, input2, options)
+    },
     query: { match: (input2) => queryMatchAdapter(editor, input2) },
     mutations: {
       preview: (input2) => previewPlan(editor, input2),
@@ -172261,15 +173720,15 @@ var Node$13 = class Node$14 {
     return false;
   if ($from.parent.type.name !== "run")
     return false;
-  let dispatchTransaction = null;
+  let dispatchTransaction$1 = null;
   if (view?.dispatch)
-    dispatchTransaction = view.dispatch.bind(view);
+    dispatchTransaction$1 = view.dispatch.bind(view);
   else if (editor?.dispatch)
-    dispatchTransaction = editor.dispatch.bind(editor);
-  if (!dispatchTransaction)
+    dispatchTransaction$1 = editor.dispatch.bind(editor);
+  if (!dispatchTransaction$1)
     return false;
   const handled = splitBlockPatch(state, (transaction) => {
-    dispatchTransaction(transaction);
+    dispatchTransaction$1(transaction);
   }, editor);
   if (handled)
     tr.setMeta("preventDispatch", true);
@@ -176921,11 +178380,11 @@ var Node$13 = class Node$14 {
     this.eventListenerCleanups = [];
     this.resizeTimeoutId = null;
   }
-  attach({ element: element3, state, editorProps = {}, dispatchTransaction, handleClick: handleClick$1 }) {
+  attach({ element: element3, state, editorProps = {}, dispatchTransaction: dispatchTransaction$1, handleClick: handleClick$1 }) {
     this.view?.destroy();
     this.view = new EditorView(element3, {
       ...editorProps && typeof editorProps === "object" ? editorProps : {},
-      dispatchTransaction,
+      dispatchTransaction: dispatchTransaction$1,
       state,
       handleClick: handleClick$1
     });
@@ -195789,9 +197248,9 @@ var Node$13 = class Node$14 {
     trackedChanges: context.trackedChanges ?? []
   });
 }, _hoisted_1$6, _hoisted_2$2, _hoisted_3, _hoisted_4, ContextMenu_default, _hoisted_1$5, BasicUpload_default, _hoisted_1$4, MIN_WIDTH = 200, PPI = 96, alignment = "flex-end", Ruler_default, GenericPopover_default, _hoisted_1$3, _hoisted_2$1, RESIZE_HANDLE_WIDTH_PX = 9, RESIZE_HANDLE_HEIGHT_PX = 9, RESIZE_HANDLE_OFFSET_PX = 4, DRAG_OVERLAY_EXTENSION_PX = 1000, MIN_DRAG_OVERLAY_WIDTH_PX = 2000, THROTTLE_INTERVAL_MS = 16, MIN_RESIZE_DELTA_PX = 1, TableResizeOverlay_default, _hoisted_1$2, OVERLAY_EXPANSION_PX = 2000, RESIZE_HANDLE_SIZE_PX = 12, MOUSE_MOVE_THROTTLE_MS = 16, DIMENSION_CHANGE_THRESHOLD_PX = 1, Z_INDEX_OVERLAY = 10, Z_INDEX_HANDLE = 15, Z_INDEX_GUIDELINE = 20, ImageResizeOverlay_default, LINK_CLICK_DEBOUNCE_MS = 300, CURSOR_UPDATE_TIMEOUT_MS = 10, POPOVER_VERTICAL_OFFSET_PX = 15, LinkClickHandler_default, _hoisted_1$1, _hoisted_2, DOCX2 = "application/vnd.openxmlformats-officedocument.wordprocessingml.document", TABLE_RESIZE_HOVER_THRESHOLD = 8, TABLE_RESIZE_THROTTLE_MS = 16, SuperEditor_default, _hoisted_1, SuperInput_default, SlashMenu, Extensions;
-var init_src_D8ccu_r8_es = __esm(() => {
+var init_src_nq0HTKfv_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
-  init_SuperConverter_CejXSSGL_es();
+  init_SuperConverter_C3jSWLmj_es();
   init_jszip_ChlR43oI_es();
   init_uuid_qzgm05fK_es();
   init_constants_CMPtQbp7_es();
@@ -196806,9 +198265,9 @@ var init_src_D8ccu_r8_es = __esm(() => {
   cssChecked = /* @__PURE__ */ new WeakMap;
   isInline = /^(a|abbr|acronym|b|bd[io]|big|br|button|cite|code|data(list)?|del|dfn|em|i|img|ins|kbd|label|map|mark|meter|output|q|ruby|s|samp|small|span|strong|su[bp]|time|u|tt|var)$/i;
   EditorView.prototype.dispatch = function(tr) {
-    let dispatchTransaction = this._props.dispatchTransaction;
-    if (dispatchTransaction)
-      dispatchTransaction.call(this, tr);
+    let dispatchTransaction$1 = this._props.dispatchTransaction;
+    if (dispatchTransaction$1)
+      dispatchTransaction$1.call(this, tr);
     else
       this.updateState(this.state.apply(tr));
   };
@@ -204565,7 +206024,7 @@ function print() { __p += __j.call(arguments, '') }
   RELATIONSHIP_ID_PATTERN = /^rId(\d+)$/;
   HEADER_FILE_PATTERN = /^word\/header(\d+)\.xml$/;
   FOOTER_FILE_PATTERN = /^word\/footer(\d+)\.xml$/;
-  HISTORY_UNSAFE_OPS = OPERATION_IDS2.filter((id2) => COMMAND_CATALOG2[id2].historyUnsafe === true);
+  HISTORY_UNSAFE_OPS = OPERATION_IDS2.filter((id2) => COMMAND_CATALOG3[id2].historyUnsafe === true);
   SWITCH_PATTERN = /\\([a-z])(?:\s*(?:"([^"]*)"|([^\s\\]+)))?/gi;
   TAB_LEADER_MAP = {
     dot: "dot",
@@ -227473,8 +228932,8 @@ function print() { __p += __j.call(arguments, '') }
     return isObjectLike_default(value) && hasOwnProperty$8.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
   };
   stubFalse_default = stubFalse;
-  freeExports$2 = typeof exports_src_D8ccu_r8_es == "object" && exports_src_D8ccu_r8_es && !exports_src_D8ccu_r8_es.nodeType && exports_src_D8ccu_r8_es;
-  freeModule$2 = freeExports$2 && typeof module_src_D8ccu_r8_es == "object" && module_src_D8ccu_r8_es && !module_src_D8ccu_r8_es.nodeType && module_src_D8ccu_r8_es;
+  freeExports$2 = typeof exports_src_nq0HTKfv_es == "object" && exports_src_nq0HTKfv_es && !exports_src_nq0HTKfv_es.nodeType && exports_src_nq0HTKfv_es;
+  freeModule$2 = freeExports$2 && typeof module_src_nq0HTKfv_es == "object" && module_src_nq0HTKfv_es && !module_src_nq0HTKfv_es.nodeType && module_src_nq0HTKfv_es;
   Buffer$1 = freeModule$2 && freeModule$2.exports === freeExports$2 ? _root_default.Buffer : undefined;
   isBuffer_default = (Buffer$1 ? Buffer$1.isBuffer : undefined) || stubFalse_default;
   typedArrayTags = {};
@@ -227482,8 +228941,8 @@ function print() { __p += __j.call(arguments, '') }
   typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false;
   _baseIsTypedArray_default = baseIsTypedArray;
   _baseUnary_default = baseUnary;
-  freeExports$1 = typeof exports_src_D8ccu_r8_es == "object" && exports_src_D8ccu_r8_es && !exports_src_D8ccu_r8_es.nodeType && exports_src_D8ccu_r8_es;
-  freeModule$1 = freeExports$1 && typeof module_src_D8ccu_r8_es == "object" && module_src_D8ccu_r8_es && !module_src_D8ccu_r8_es.nodeType && module_src_D8ccu_r8_es;
+  freeExports$1 = typeof exports_src_nq0HTKfv_es == "object" && exports_src_nq0HTKfv_es && !exports_src_nq0HTKfv_es.nodeType && exports_src_nq0HTKfv_es;
+  freeModule$1 = freeExports$1 && typeof module_src_nq0HTKfv_es == "object" && module_src_nq0HTKfv_es && !module_src_nq0HTKfv_es.nodeType && module_src_nq0HTKfv_es;
   freeProcess = freeModule$1 && freeModule$1.exports === freeExports$1 && _freeGlobal_default.process;
   _nodeUtil_default = function() {
     try {
@@ -227588,8 +229047,8 @@ function print() { __p += __j.call(arguments, '') }
   Stack.prototype.has = _stackHas_default;
   Stack.prototype.set = _stackSet_default;
   _Stack_default = Stack;
-  freeExports = typeof exports_src_D8ccu_r8_es == "object" && exports_src_D8ccu_r8_es && !exports_src_D8ccu_r8_es.nodeType && exports_src_D8ccu_r8_es;
-  freeModule = freeExports && typeof module_src_D8ccu_r8_es == "object" && module_src_D8ccu_r8_es && !module_src_D8ccu_r8_es.nodeType && module_src_D8ccu_r8_es;
+  freeExports = typeof exports_src_nq0HTKfv_es == "object" && exports_src_nq0HTKfv_es && !exports_src_nq0HTKfv_es.nodeType && exports_src_nq0HTKfv_es;
+  freeModule = freeExports && typeof module_src_nq0HTKfv_es == "object" && module_src_nq0HTKfv_es && !module_src_nq0HTKfv_es.nodeType && module_src_nq0HTKfv_es;
   Buffer4 = freeModule && freeModule.exports === freeExports ? _root_default.Buffer : undefined;
   allocUnsafe = Buffer4 ? Buffer4.allocUnsafe : undefined;
   _cloneBuffer_default = cloneBuffer;
@@ -235669,8 +237128,8 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_D8ccu_r8_es();
-  init_SuperConverter_CejXSSGL_es();
+  init_src_nq0HTKfv_es();
+  init_SuperConverter_C3jSWLmj_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_DLE8mr0n_es();
   init_constants_CMPtQbp7_es();
@@ -255153,7 +256612,152 @@ var init_CommandService = () => {};
 // ../../packages/super-editor/src/core/helpers/getHTMLFromFragment.js
 var init_getHTMLFromFragment = () => {};
 // ../../shared/url-validation/index.js
-var init_url_validation = () => {};
+function toProtocolSet2(values2) {
+  const result = new Set;
+  if (!values2)
+    return result;
+  values2.forEach((value) => {
+    if (typeof value === "string" && value.trim()) {
+      result.add(value.trim().toLowerCase());
+    }
+  });
+  return result;
+}
+function buildAllowedProtocols2(config2 = {}) {
+  const allowed = config2.allowedProtocols?.length ? toProtocolSet2(config2.allowedProtocols) : new Set(DEFAULT_ALLOWED_PROTOCOLS2);
+  const optional = toProtocolSet2(config2.optionalProtocols);
+  if (optional.size > 0) {
+    optional.forEach((protocol) => {
+      if (OPTIONAL_PROTOCOLS2.includes(protocol)) {
+        allowed.add(protocol);
+      }
+    });
+  }
+  return allowed;
+}
+function normalizeBlocklist2(values2) {
+  const hosts = new Set;
+  const urls = new Set;
+  if (!values2) {
+    return { hosts, urls };
+  }
+  values2.forEach((entry) => {
+    if (!entry || typeof entry !== "string")
+      return;
+    const trimmed = entry.trim().toLowerCase();
+    if (!trimmed)
+      return;
+    if (trimmed.includes("://")) {
+      urls.add(trimmed);
+    } else {
+      hosts.add(trimmed);
+    }
+  });
+  return { hosts, urls };
+}
+function parseAnchorLink2(trimmed) {
+  if (!trimmed.startsWith("#"))
+    return null;
+  const anchor = trimmed.slice(1);
+  if (!anchor || !ANCHOR_NAME_PATTERN2.test(anchor)) {
+    return null;
+  }
+  return { href: `#${anchor}`, protocol: null, isExternal: false };
+}
+function isProtocolAllowed2(scheme, allowedProtocols, blockedProtocols) {
+  if (blockedProtocols.includes(scheme)) {
+    return false;
+  }
+  return allowedProtocols.has(scheme);
+}
+function isBlockedByRedirectList2(normalizedHref, parsed, blocklist) {
+  const { hosts, urls } = blocklist;
+  const hostname2 = parsed.hostname ? parsed.hostname.toLowerCase() : "";
+  if (hosts.size > 0 && hostname2 && hosts.has(hostname2)) {
+    return true;
+  }
+  if (urls.size > 0) {
+    const hrefLower = normalizedHref.toLowerCase();
+    for (const blockedUrl of urls) {
+      if (hrefLower.startsWith(blockedUrl)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function sanitizeHref2(raw, config2 = {}) {
+  if (typeof raw !== "string")
+    return null;
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  const maxLength = typeof config2.maxLength === "number" ? config2.maxLength : DEFAULT_MAX_LENGTH2;
+  if (trimmed.length > maxLength) {
+    return null;
+  }
+  const anchorResult = parseAnchorLink2(trimmed);
+  if (anchorResult !== null) {
+    return anchorResult;
+  }
+  if (trimmed.startsWith("/") || trimmed.startsWith(".") || trimmed.startsWith("//") || /^www\./i.test(trimmed)) {
+    return null;
+  }
+  const schemeMatch = trimmed.match(/^([a-z0-9+.-]+):/i);
+  if (!schemeMatch) {
+    return null;
+  }
+  const scheme = schemeMatch[1].toLowerCase();
+  const allowedProtocols = buildAllowedProtocols2(config2);
+  const blockedProtocols = BLOCKED_PROTOCOLS2.concat(config2.blockedProtocols ?? []).map((p4) => p4.toLowerCase());
+  if (!isProtocolAllowed2(scheme, allowedProtocols, blockedProtocols)) {
+    return null;
+  }
+  const hostStartIndex = trimmed.indexOf("://") + 3;
+  let hostEndIndex = trimmed.indexOf("/", hostStartIndex);
+  if (hostEndIndex === -1) {
+    hostEndIndex = trimmed.indexOf("?", hostStartIndex);
+  }
+  if (hostEndIndex === -1) {
+    hostEndIndex = trimmed.indexOf("#", hostStartIndex);
+  }
+  if (hostEndIndex === -1) {
+    hostEndIndex = trimmed.length;
+  }
+  const rawHostname = trimmed.slice(hostStartIndex, hostEndIndex).toLowerCase();
+  if (rawHostname && /[^\x00-\x7F]/.test(rawHostname)) {
+    if (true) {
+      console.warn(`[URL Validation] Potential homograph attack detected in hostname: ${rawHostname.slice(0, 50)}`);
+    }
+  }
+  const queryStartIndex = trimmed.indexOf("?");
+  if (queryStartIndex !== -1) {
+    const queryString = trimmed.slice(queryStartIndex);
+    if (/[<>"']/.test(queryString)) {
+      return null;
+    }
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return null;
+  }
+  const normalizedHref = trimmed;
+  const blocklist = normalizeBlocklist2(config2.redirectBlocklist);
+  if (isBlockedByRedirectList2(normalizedHref, parsed, blocklist)) {
+    return null;
+  }
+  const isExternal = scheme === "http" || scheme === "https";
+  return { href: normalizedHref, protocol: scheme, isExternal };
+}
+var DEFAULT_ALLOWED_PROTOCOLS2, OPTIONAL_PROTOCOLS2, BLOCKED_PROTOCOLS2, DEFAULT_MAX_LENGTH2 = 2048, ANCHOR_NAME_PATTERN2;
+var init_url_validation = __esm(() => {
+  DEFAULT_ALLOWED_PROTOCOLS2 = ["http", "https", "mailto", "tel", "sms"];
+  OPTIONAL_PROTOCOLS2 = ["ftp", "sftp", "irc"];
+  BLOCKED_PROTOCOLS2 = ["javascript", "data", "vbscript", "file", "ssh", "ws", "wss"];
+  ANCHOR_NAME_PATTERN2 = /^[A-Za-z0-9._-]+$/;
+});
 
 // ../../packages/super-editor/src/core/super-converter/docx-helpers/docx-constants.js
 var RELATIONSHIP_TYPES2;
@@ -312904,6 +314508,545 @@ var init_images_wrappers = __esm(() => {
   WRAP_TYPES_SUPPORTING_DISTANCES2 = new Set(["Square", "Tight", "Through", "TopAndBottom"]);
 });
 
+// ../../packages/super-editor/src/document-api-adapters/helpers/hyperlink-mutation-helper.ts
+function getLinkMarkType2(editor) {
+  const markType = editor.schema.marks.link;
+  if (!markType) {
+    throw new Error("Link mark type is not defined in the editor schema.");
+  }
+  return markType;
+}
+function dispatchTransaction2(editor, tr) {
+  editor.dispatch(tr);
+}
+function dispatchIfChanged2(editor, tr) {
+  if (!tr.docChanged)
+    return false;
+  dispatchTransaction2(editor, tr);
+  return true;
+}
+function createRelationshipId2(editor, href) {
+  if (editor.options.mode !== "docx")
+    return null;
+  try {
+    return insertNewRelationship2(href, "hyperlink", editor);
+  } catch {
+    return null;
+  }
+}
+function sanitizeHrefOrThrow2(href) {
+  const result = sanitizeHref2(href);
+  if (!result) {
+    throw Object.assign(new Error(`Blocked or invalid href: "${href}"`), { code: "INVALID_INPUT" });
+  }
+  return result.href;
+}
+function buildMarkAttrs2(editor, spec) {
+  const attrs = {};
+  if (spec.href) {
+    attrs.href = sanitizeHrefOrThrow2(spec.href);
+    attrs.rId = createRelationshipId2(editor, attrs.href);
+  }
+  if (spec.anchor) {
+    attrs.anchor = spec.anchor;
+    if (!spec.href) {
+      attrs.href = `#${spec.anchor}`;
+    }
+  }
+  if (spec.docLocation)
+    attrs.docLocation = spec.docLocation;
+  if (spec.tooltip)
+    attrs.tooltip = spec.tooltip;
+  if (spec.target)
+    attrs.target = spec.target;
+  if (spec.rel)
+    attrs.rel = spec.rel;
+  return attrs;
+}
+function wrapWithLink2(editor, from4, to, spec) {
+  const linkMarkType = getLinkMarkType2(editor);
+  const attrs = buildMarkAttrs2(editor, spec);
+  const tr = editor.state.tr;
+  tr.addMark(from4, to, linkMarkType.create(attrs));
+  applyDirectMutationMeta2(tr);
+  dispatchTransaction2(editor, tr);
+  return true;
+}
+function insertLinkedText2(editor, pos, text9, spec) {
+  const linkMarkType = getLinkMarkType2(editor);
+  const attrs = buildMarkAttrs2(editor, spec);
+  const tr = editor.state.tr;
+  const mark2 = linkMarkType.create(attrs);
+  tr.insertText(text9, pos);
+  tr.addMark(pos, pos + text9.length, mark2);
+  applyDirectMutationMeta2(tr);
+  dispatchTransaction2(editor, tr);
+  return true;
+}
+function patchLinkMark2(editor, from4, to, existingMark, patch3) {
+  const linkMarkType = getLinkMarkType2(editor);
+  const oldAttrs = existingMark.attrs;
+  const merged = { ...oldAttrs };
+  for (const [key3, value] of Object.entries(patch3)) {
+    if (value === undefined)
+      continue;
+    if (value === null) {
+      merged[key3] = null;
+    } else {
+      merged[key3] = value;
+    }
+  }
+  if (typeof patch3.href === "string") {
+    merged.href = sanitizeHrefOrThrow2(patch3.href);
+    merged.rId = createRelationshipId2(editor, merged.href);
+  }
+  if (patch3.href === null && typeof merged.anchor === "string") {
+    merged.href = `#${merged.anchor}`;
+    merged.rId = null;
+  }
+  if (typeof patch3.anchor === "string" && patch3.href === undefined) {
+    const currentHref = merged.href;
+    if (typeof currentHref === "string" && currentHref.startsWith("#")) {
+      merged.href = `#${patch3.anchor}`;
+    }
+  }
+  if (patch3.anchor === null && typeof merged.href === "string" && !merged.href.startsWith("#")) {
+    merged.anchor = null;
+  }
+  const tr = editor.state.tr;
+  tr.removeMark(from4, to, existingMark);
+  tr.addMark(from4, to, linkMarkType.create(merged));
+  applyDirectMutationMeta2(tr);
+  return dispatchIfChanged2(editor, tr);
+}
+function unwrapLink2(editor, from4, to) {
+  const linkMarkType = getLinkMarkType2(editor);
+  const tr = editor.state.tr;
+  tr.removeMark(from4, to, linkMarkType);
+  applyDirectMutationMeta2(tr);
+  return dispatchIfChanged2(editor, tr);
+}
+function deleteLinkedText2(editor, from4, to) {
+  const tr = editor.state.tr;
+  tr.delete(from4, to);
+  applyDirectMutationMeta2(tr);
+  dispatchTransaction2(editor, tr);
+  return true;
+}
+var init_hyperlink_mutation_helper = __esm(() => {
+  init_document_rels();
+  init_url_validation();
+});
+
+// ../../packages/super-editor/src/document-api-adapters/plan-engine/hyperlinks-wrappers.ts
+function normalizeReadProperties2(attrs) {
+  const rawHref = typeof attrs.href === "string" ? attrs.href : undefined;
+  const rawAnchor = typeof attrs.anchor === "string" ? attrs.anchor : undefined;
+  const rawDocLocation = typeof attrs.docLocation === "string" ? attrs.docLocation : undefined;
+  const rawTooltip = typeof attrs.tooltip === "string" ? attrs.tooltip : undefined;
+  const rawTarget = typeof attrs.target === "string" ? attrs.target : undefined;
+  const rawRel = typeof attrs.rel === "string" ? attrs.rel : undefined;
+  const props = {};
+  let effectiveAnchor = rawAnchor;
+  let effectiveHref = rawHref;
+  if (rawHref && rawHref.startsWith("#")) {
+    const fragment = rawHref.slice(1);
+    if (!rawAnchor) {
+      effectiveAnchor = fragment;
+      effectiveHref = undefined;
+    } else if (rawAnchor === fragment) {
+      effectiveHref = undefined;
+    }
+  }
+  if (effectiveHref)
+    props.href = effectiveHref;
+  if (effectiveAnchor)
+    props.anchor = effectiveAnchor;
+  if (rawDocLocation)
+    props.docLocation = rawDocLocation;
+  if (rawTooltip)
+    props.tooltip = rawTooltip;
+  if (rawTarget)
+    props.target = rawTarget;
+  if (rawRel)
+    props.rel = rawRel;
+  return props;
+}
+function candidateToTarget2(candidate) {
+  return {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: candidate.anchor
+  };
+}
+function candidateToReadProperties2(candidate) {
+  const attrs = candidate.mark?.attrs ?? candidate.attrs ?? {};
+  return normalizeReadProperties2(attrs);
+}
+function extractDisplayText2(editor, candidate) {
+  const doc4 = editor.state.doc;
+  try {
+    return doc4.textBetween(candidate.pos, candidate.end, "");
+  } catch {
+    return;
+  }
+}
+function candidateToDomain2(editor, candidate) {
+  return {
+    address: candidateToTarget2(candidate),
+    properties: candidateToReadProperties2(candidate),
+    text: extractDisplayText2(editor, candidate)
+  };
+}
+function encodeInlineRef2(anchor) {
+  return `${anchor.start.blockId}:${anchor.start.offset}:${anchor.end.offset}`;
+}
+function isInsideTocBlock2(editor, pos) {
+  const resolved = editor.state.doc.resolve(pos);
+  for (let depth = resolved.depth;depth > 0; depth--) {
+    const node4 = resolved.node(depth);
+    if (node4.type.name === "tableOfContents")
+      return true;
+  }
+  return false;
+}
+function rejectIfInsideToc2(editor, pos, operationName) {
+  if (isInsideTocBlock2(editor, pos)) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", `${operationName}: target is inside a TOC block. TOC content is managed by toc.* operations.`);
+  }
+}
+function findHyperlinkCandidates2(editor) {
+  const blockIndex = getBlockIndex2(editor);
+  const inlineIndex = buildInlineIndex2(editor, blockIndex);
+  return findInlineByType2(inlineIndex, "hyperlink");
+}
+function resolveHyperlinkCandidate2(editor, target) {
+  const blockIndex = getBlockIndex2(editor);
+  const inlineIndex = buildInlineIndex2(editor, blockIndex);
+  const candidate = findInlineByAnchor2(inlineIndex, target);
+  if (!candidate) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "Hyperlink target not found in document.", { target });
+  }
+  return candidate;
+}
+function resolveCandidateTextRange2(editor, candidate, operationName) {
+  const start2 = candidate.anchor.start;
+  const end = candidate.anchor.end;
+  if (start2.blockId !== end.blockId) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", `${operationName}: hyperlink anchor spans multiple blocks.`, {
+      anchor: candidate.anchor
+    });
+  }
+  const resolved = resolveTextTarget2(editor, {
+    kind: "text",
+    blockId: start2.blockId,
+    range: { start: start2.offset, end: end.offset }
+  });
+  if (!resolved) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", `${operationName}: hyperlink text range could not be resolved.`, {
+      anchor: candidate.anchor
+    });
+  }
+  return resolved;
+}
+function hyperlinkSuccess2(target) {
+  return { success: true, hyperlink: target };
+}
+function hyperlinkFailure2(code10, message) {
+  return { success: false, failure: { code: code10, message } };
+}
+function receiptApplied4(receipt2) {
+  return receipt2.steps[0]?.effect === "changed";
+}
+function matchesListQuery3(candidate, query2, editor) {
+  if (!query2)
+    return true;
+  const props = candidateToReadProperties2(candidate);
+  if (query2.hrefPattern && (!props.href || !props.href.includes(query2.hrefPattern))) {
+    return false;
+  }
+  if (query2.anchor && props.anchor !== query2.anchor) {
+    return false;
+  }
+  if (query2.textPattern) {
+    const text9 = extractDisplayText2(editor, candidate);
+    if (!text9 || !text9.includes(query2.textPattern))
+      return false;
+  }
+  return true;
+}
+function hyperlinksListWrapper2(editor, query2) {
+  const revision = getRevision2(editor);
+  let candidates = findHyperlinkCandidates2(editor);
+  if (query2?.within) {
+    const blockIndex = getBlockIndex2(editor);
+    const diagnostics = [];
+    const withinResult = resolveWithinScope2(blockIndex, { within: query2.within }, diagnostics);
+    if (!withinResult.ok) {
+      candidates = [];
+    } else {
+      candidates = scopeByRange2(candidates, withinResult.range);
+    }
+  }
+  const filtered = candidates.filter((c2) => matchesListQuery3(c2, query2, editor));
+  const allItems = filtered.map((candidate) => {
+    const domain3 = candidateToDomain2(editor, candidate);
+    const ref4 = encodeInlineRef2(candidate.anchor);
+    const handle4 = buildResolvedHandle(ref4, "ephemeral", "node");
+    return buildDiscoveryItem(ref4, handle4, domain3);
+  });
+  const { total, items: paged } = paginate2(allItems, query2?.offset, query2?.limit);
+  const effectiveLimit = query2?.limit ?? total;
+  return buildDiscoveryResult({
+    evaluatedRevision: revision,
+    total,
+    items: paged,
+    page: { limit: effectiveLimit, offset: query2?.offset ?? 0, returned: paged.length }
+  });
+}
+function hyperlinksGetWrapper2(editor, input2) {
+  const candidate = resolveHyperlinkCandidate2(editor, input2.target);
+  return {
+    address: candidateToTarget2(candidate),
+    properties: candidateToReadProperties2(candidate),
+    text: extractDisplayText2(editor, candidate)
+  };
+}
+function specFromInput2(link3) {
+  return {
+    href: link3.destination.href,
+    anchor: link3.destination.anchor,
+    docLocation: link3.destination.docLocation,
+    tooltip: link3.tooltip,
+    target: link3.target,
+    rel: link3.rel
+  };
+}
+function hyperlinksWrapWrapper2(editor, input2, options) {
+  rejectTrackedMode2("hyperlinks.wrap", options);
+  const resolved = resolveTextTarget2(editor, input2.target);
+  if (!resolved) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "hyperlinks.wrap: text target block not found.", {
+      target: input2.target
+    });
+  }
+  rejectIfInsideToc2(editor, resolved.from, "hyperlinks.wrap");
+  const blockIndex = getBlockIndex2(editor);
+  const inlineIndex = buildInlineIndex2(editor, blockIndex);
+  const hyperlinks = findInlineByType2(inlineIndex, "hyperlink");
+  const overlapping = hyperlinks.filter((c2) => c2.pos < resolved.to && c2.end > resolved.from);
+  if (overlapping.length > 1) {
+    throw new DocumentApiAdapterError3("INVALID_TARGET", "hyperlinks.wrap: target range spans multiple existing links.");
+  }
+  if (overlapping.length === 1) {
+    const existing = overlapping[0];
+    if (existing.pos === resolved.from && existing.end === resolved.to) {
+      const existingProps = candidateToReadProperties2(existing);
+      const spec2 = specFromInput2(input2.link);
+      if (existingProps.href === spec2.href && existingProps.anchor === spec2.anchor) {
+        return hyperlinkFailure2("NO_OP", "Text range is already linked with the same destination.");
+      }
+    } else {
+      throw new DocumentApiAdapterError3("INVALID_TARGET", "hyperlinks.wrap: target range partially overlaps an existing link. Remove the existing link first.");
+    }
+  }
+  if (input2.link.destination.href) {
+    sanitizeHrefOrThrow2(input2.link.destination.href);
+  }
+  if (options?.dryRun) {
+    const dryTarget = {
+      kind: "inline",
+      nodeType: "hyperlink",
+      anchor: {
+        start: { blockId: input2.target.blockId, offset: input2.target.range.start },
+        end: { blockId: input2.target.blockId, offset: input2.target.range.end }
+      }
+    };
+    return hyperlinkSuccess2(dryTarget);
+  }
+  const spec = specFromInput2(input2.link);
+  const receipt2 = executeDomainCommand2(editor, () => {
+    const result = wrapWithLink2(editor, resolved.from, resolved.to, spec);
+    if (result)
+      clearIndexCache2(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision });
+  if (!receiptApplied4(receipt2)) {
+    return hyperlinkFailure2("NO_OP", "Wrap operation produced no change.");
+  }
+  const postCandidate = findHyperlinkAtRange2(editor, resolved.from, resolved.to);
+  return hyperlinkSuccess2(postCandidate ? candidateToTarget2(postCandidate) : {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: {
+      start: { blockId: input2.target.blockId, offset: input2.target.range.start },
+      end: { blockId: input2.target.blockId, offset: input2.target.range.end }
+    }
+  });
+}
+function hyperlinksInsertWrapper2(editor, input2, options) {
+  rejectTrackedMode2("hyperlinks.insert", options);
+  let insertPos;
+  let blockId;
+  let offset2;
+  let structuralEnd = false;
+  if (input2.target) {
+    const resolved = resolveTextTarget2(editor, input2.target);
+    if (!resolved) {
+      throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "hyperlinks.insert: text target block not found.", {
+        target: input2.target
+      });
+    }
+    rejectIfInsideToc2(editor, resolved.from, "hyperlinks.insert");
+    insertPos = resolved.from;
+    blockId = input2.target.blockId;
+    offset2 = input2.target.range.start;
+  } else {
+    const fallback = resolveDefaultInsertTarget2(editor);
+    if (!fallback) {
+      throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "hyperlinks.insert: document has no content to insert into.");
+    }
+    if (fallback.kind === "text-block") {
+      insertPos = fallback.range.from;
+      blockId = fallback.target.blockId;
+      offset2 = fallback.target.range.start;
+    } else {
+      insertPos = fallback.insertPos;
+      blockId = "";
+      offset2 = 0;
+      structuralEnd = true;
+    }
+  }
+  if (input2.link.destination.href) {
+    sanitizeHrefOrThrow2(input2.link.destination.href);
+  }
+  if (options?.dryRun) {
+    const dryTarget = {
+      kind: "inline",
+      nodeType: "hyperlink",
+      anchor: {
+        start: { blockId, offset: offset2 },
+        end: { blockId, offset: offset2 + input2.text.length }
+      }
+    };
+    return hyperlinkSuccess2(dryTarget);
+  }
+  const spec = specFromInput2(input2.link);
+  const receipt2 = executeDomainCommand2(editor, () => {
+    if (structuralEnd) {
+      insertParagraphAtEnd2(editor, insertPos, input2.text);
+      clearIndexCache2(editor);
+      const textStart = insertPos + 1;
+      const result2 = wrapWithLink2(editor, textStart, textStart + input2.text.length, spec);
+      if (result2)
+        clearIndexCache2(editor);
+      return result2;
+    }
+    const result = insertLinkedText2(editor, insertPos, input2.text, spec);
+    if (result)
+      clearIndexCache2(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision });
+  if (!receiptApplied4(receipt2)) {
+    return hyperlinkFailure2("NO_OP", "Insert operation produced no change.");
+  }
+  const searchFrom = structuralEnd ? insertPos + 1 : insertPos;
+  const searchTo = searchFrom + input2.text.length;
+  const postCandidate = findHyperlinkAtRange2(editor, searchFrom, searchTo);
+  return hyperlinkSuccess2(postCandidate ? candidateToTarget2(postCandidate) : {
+    kind: "inline",
+    nodeType: "hyperlink",
+    anchor: {
+      start: { blockId, offset: offset2 },
+      end: { blockId, offset: offset2 + input2.text.length }
+    }
+  });
+}
+function hyperlinksPatchWrapper2(editor, input2, options) {
+  rejectTrackedMode2("hyperlinks.patch", options);
+  const candidate = resolveHyperlinkCandidate2(editor, input2.target);
+  const resolvedRange = resolveCandidateTextRange2(editor, candidate, "hyperlinks.patch");
+  rejectIfInsideToc2(editor, resolvedRange.from, "hyperlinks.patch");
+  const existingMark = candidate.mark;
+  if (!existingMark) {
+    throw new DocumentApiAdapterError3("TARGET_NOT_FOUND", "hyperlinks.patch: resolved candidate has no mark.");
+  }
+  const oldAttrs = existingMark.attrs;
+  const mergedHref = input2.patch.href === undefined ? oldAttrs.href : input2.patch.href;
+  const mergedAnchor = input2.patch.anchor === undefined ? oldAttrs.anchor : input2.patch.anchor;
+  const hasHref = typeof mergedHref === "string" && mergedHref.length > 0;
+  const hasAnchor = typeof mergedAnchor === "string" && mergedAnchor.length > 0;
+  if (!hasHref && !hasAnchor) {
+    throw new DocumentApiAdapterError3("INVALID_INPUT", "hyperlinks.patch: resulting destination must have at least one of href or anchor.");
+  }
+  if (typeof input2.patch.href === "string") {
+    sanitizeHrefOrThrow2(input2.patch.href);
+  }
+  const currentProps = candidateToReadProperties2(candidate);
+  const isNoop = Object.entries(input2.patch).every(([key3, value]) => {
+    if (value === undefined)
+      return true;
+    if (value === null)
+      return currentProps[key3] === undefined;
+    return currentProps[key3] === value;
+  });
+  if (isNoop) {
+    return hyperlinkFailure2("NO_OP", "Patch produces no change — all values already match.");
+  }
+  if (options?.dryRun) {
+    return hyperlinkSuccess2(candidateToTarget2(candidate));
+  }
+  const receipt2 = executeDomainCommand2(editor, () => {
+    const result = patchLinkMark2(editor, resolvedRange.from, resolvedRange.to, existingMark, input2.patch);
+    if (result)
+      clearIndexCache2(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision });
+  if (!receiptApplied4(receipt2)) {
+    return hyperlinkFailure2("NO_OP", "Patch operation produced no change.");
+  }
+  const postCandidate = findHyperlinkAtRange2(editor, resolvedRange.from, resolvedRange.to);
+  return hyperlinkSuccess2(postCandidate ? candidateToTarget2(postCandidate) : candidateToTarget2(candidate));
+}
+function hyperlinksRemoveWrapper2(editor, input2, options) {
+  rejectTrackedMode2("hyperlinks.remove", options);
+  const candidate = resolveHyperlinkCandidate2(editor, input2.target);
+  const resolvedRange = resolveCandidateTextRange2(editor, candidate, "hyperlinks.remove");
+  rejectIfInsideToc2(editor, resolvedRange.from, "hyperlinks.remove");
+  const mode = input2.mode ?? "unwrap";
+  const targetAddress = candidateToTarget2(candidate);
+  if (options?.dryRun) {
+    return hyperlinkSuccess2(targetAddress);
+  }
+  const receipt2 = executeDomainCommand2(editor, () => {
+    const result = mode === "unwrap" ? unwrapLink2(editor, resolvedRange.from, resolvedRange.to) : deleteLinkedText2(editor, resolvedRange.from, resolvedRange.to);
+    if (result)
+      clearIndexCache2(editor);
+    return result;
+  }, { expectedRevision: options?.expectedRevision });
+  if (!receiptApplied4(receipt2)) {
+    return hyperlinkFailure2("NO_OP", `Remove (${mode}) operation produced no change.`);
+  }
+  return hyperlinkSuccess2(targetAddress);
+}
+function findHyperlinkAtRange2(editor, from4, to) {
+  const blockIndex = getBlockIndex2(editor);
+  const inlineIndex = buildInlineIndex2(editor, blockIndex);
+  const hyperlinks = findInlineByType2(inlineIndex, "hyperlink");
+  return hyperlinks.find((c2) => c2.pos >= from4 - 1 && c2.pos <= from4 + 1 && c2.end >= to - 1 && c2.end <= to + 1) ?? hyperlinks.find((c2) => c2.pos <= from4 && c2.end >= to);
+}
+var init_hyperlinks_wrappers = __esm(() => {
+  init_src();
+  init_index_cache();
+  init_inline_address_resolver();
+  init_adapter_utils();
+  init_revision_tracker();
+  init_plan_wrappers();
+  init_mutation_helpers();
+  init_errors3();
+  init_hyperlink_mutation_helper();
+});
+
 // ../../packages/super-editor/src/document-api-adapters/assemble-adapters.ts
 function assembleDocumentApiAdapters2(editor) {
   registerBuiltInExecutors2();
@@ -313105,6 +315248,14 @@ function assembleDocumentApiAdapters2(editor) {
       setAnchorOptions: (input2, options) => imagesSetAnchorOptionsWrapper2(editor, input2, options),
       setZOrder: (input2, options) => imagesSetZOrderWrapper2(editor, input2, options)
     },
+    hyperlinks: {
+      list: (query2) => hyperlinksListWrapper2(editor, query2),
+      get: (input2) => hyperlinksGetWrapper2(editor, input2),
+      wrap: (input2, options) => hyperlinksWrapWrapper2(editor, input2, options),
+      insert: (input2, options) => hyperlinksInsertWrapper2(editor, input2, options),
+      patch: (input2, options) => hyperlinksPatchWrapper2(editor, input2, options),
+      remove: (input2, options) => hyperlinksRemoveWrapper2(editor, input2, options)
+    },
     query: {
       match: (input2) => queryMatchAdapter2(editor, input2)
     },
@@ -313143,6 +315294,7 @@ var init_assemble_adapters = __esm(() => {
   init_toc_wrappers();
   init_toc_entry_wrappers();
   init_images_wrappers();
+  init_hyperlinks_wrappers();
 });
 
 // ../../packages/super-editor/src/document-api-adapters/index.ts
@@ -368748,17 +370900,18 @@ function buildHelpText() {
     categories.set(spec.category, list8);
   }
   const categoryOrder = [
-    "query",
-    "mutation",
+    "core",
     "format",
     "create",
-    "blocks",
+    "tables",
+    "sections",
     "lists",
     "comments",
     "trackChanges",
-    "lifecycle",
-    "session",
-    "introspection"
+    "toc",
+    "images",
+    "history",
+    "session"
   ];
   for (const category of categoryOrder) {
     const specs = categories.get(category);
@@ -369080,8 +371233,7 @@ var init_operation_params = __esm(() => {
     kind: "flag",
     flag: "change-mode",
     type: "string",
-    schema: { oneOf: [{ const: "direct" }, { const: "tracked" }] },
-    agentVisible: false
+    schema: { enum: ["direct", "tracked"] }
   };
   EXPECTED_REVISION_PARAM = {
     name: "expectedRevision",
@@ -369102,7 +371254,7 @@ var init_operation_params = __esm(() => {
     flag: "user-email",
     type: "string"
   };
-  AGENT_HIDDEN_PARAM_NAMES = new Set(["out", "expectedRevision", "changeMode", "dryRun"]);
+  AGENT_HIDDEN_PARAM_NAMES = new Set(["out", "expectedRevision", "dryRun"]);
   OPERATION_CONSTRAINTS = {
     "doc.find": {
       requiresOneOf: [["type", "query"]],
@@ -369139,14 +371291,7 @@ var init_operation_params = __esm(() => {
       address: { flag: "address-json" }
     }
   };
-  PARAM_SCHEMA_OVERRIDES = {
-    "doc.mutations.preview": {
-      steps: { type: "json" }
-    },
-    "doc.mutations.apply": {
-      steps: { type: "json" }
-    }
-  };
+  PARAM_SCHEMA_OVERRIDES = {};
   PARAM_EXCLUSIONS = {
     "doc.find": new Set(["select"])
   };
@@ -369947,6 +372092,12 @@ function validateValueAgainstTypeSpec(value2, schema, path3) {
   }
   if (schema.type === "json")
     return;
+  if (schema.enum) {
+    if (!schema.enum.includes(value2)) {
+      throw new CliError("VALIDATION_ERROR", `${path3} must be one of: ${schema.enum.join(", ")}.`);
+    }
+    return;
+  }
   if (schema.type === "string") {
     if (typeof value2 !== "string")
       throw new CliError("VALIDATION_ERROR", `${path3} must be a string.`);