x402-proxy 0.10.7 → 0.10.9

package/dist/index.d.ts

@@ -1,9 +1,1903 @@
-import { ClientEvmSigner, ClientEvmSigner as ClientEvmSigner$1, ExactEvmScheme, toClientEvmSigner } from "@x402/evm";
-import { x402Client, x402Client as x402Client$1 } from "@x402/fetch";
-import { ExactSvmScheme } from "@x402/svm/exact/client";
-import { KeyPairSigner } from "@solana/kit";
+/// <reference types="node" />
+import { URL as URL$1, URLSearchParams } from "node:url";
+import { Duplex, Readable, Writable } from "node:stream";
+import { EventEmitter } from "node:events";
+import { Blob, File } from "node:buffer";
+import { ConnectionOptions, TLSSocket } from "node:tls";
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from "node:net";
 
-//#region src/handler.d.ts
+//#region node_modules/.pnpm/@x402+core@2.8.0/node_modules/@x402/core/dist/esm/mechanisms-B3SXtgLV.d.mts
+type Network = `${string}:${string}`;
+interface ResourceInfo {
+  url: string;
+  description?: string;
+  mimeType?: string;
+}
+type PaymentRequirements = {
+  scheme: string;
+  network: Network;
+  asset: string;
+  amount: string;
+  payTo: string;
+  maxTimeoutSeconds: number;
+  extra: Record<string, unknown>;
+};
+type PaymentRequired = {
+  x402Version: number;
+  error?: string;
+  resource: ResourceInfo;
+  accepts: PaymentRequirements[];
+  extensions?: Record<string, unknown>;
+};
+type PaymentPayload = {
+  x402Version: number;
+  resource?: ResourceInfo;
+  accepted: PaymentRequirements;
+  payload: Record<string, unknown>;
+  extensions?: Record<string, unknown>;
+};
+/**
+ * Result of createPaymentPayload - the core payload fields.
+ * Contains the x402 version, scheme-specific payload data, and optional extension data.
+ * Schemes may return extensions (e.g., EIP-2612 gas sponsoring) that get merged
+ * with server-declared extensions in the final PaymentPayload.
+ */
+type PaymentPayloadResult = Pick<PaymentPayload, "x402Version" | "payload"> & {
+  extensions?: Record<string, unknown>;
+};
+/**
+ * Context passed to scheme's createPaymentPayload for extensions awareness.
+ * Contains the server-declared extensions from PaymentRequired so the scheme
+ * can check which extensions are advertised and respond accordingly.
+ */
+interface PaymentPayloadContext {
+  extensions?: Record<string, unknown>;
+}
+interface SchemeNetworkClient {
+  readonly scheme: string;
+  createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements, context?: PaymentPayloadContext): Promise<PaymentPayloadResult>;
+}
+/**
+ * Context passed to SchemeNetworkFacilitator.verify/settle, providing
+ * access to registered facilitator extensions. Mechanism implementations
+ * use this to retrieve extension-provided capabilities (e.g., a batch signer).
+ */
+//#endregion
+//#region node_modules/.pnpm/@x402+evm@2.8.0_typescript@5.9.3/node_modules/@x402/evm/dist/esm/signer-D912R4mq.d.mts
+/**
+ * ClientEvmSigner - Used by x402 clients to sign payment authorizations.
+ *
+ * Typically a viem WalletClient extended with publicActions:
+ * ```typescript
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: baseSepolia,
+ *   transport: http(),
+ * }).extend(publicActions);
+ * ```
+ *
+ * Or composed via `toClientEvmSigner(account, publicClient)`.
+ */
+type ClientEvmSigner = {
+  readonly address: `0x${string}`;
+  signTypedData(message: {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    primaryType: string;
+    message: Record<string, unknown>;
+  }): Promise<`0x${string}`>;
+  /**
+   * Optional on-chain reads.
+   * Required only for extension enrichment (EIP-2612 / ERC-20 approval).
+   */
+  readContract?(args: {
+    address: `0x${string}`;
+    abi: readonly unknown[];
+    functionName: string;
+    args?: readonly unknown[];
+  }): Promise<unknown>;
+  /**
+   * Optional: Signs a raw EIP-1559 transaction without broadcasting.
+   * Required for ERC-20 approval gas sponsoring when the token lacks EIP-2612.
+   */
+  signTransaction?(args: {
+    to: `0x${string}`;
+    data: `0x${string}`;
+    nonce: number;
+    gas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    chainId: number;
+  }): Promise<`0x${string}`>;
+  /**
+   * Optional: Gets the current transaction count (nonce) for an address.
+   * Required for ERC-20 approval gas sponsoring.
+   */
+  getTransactionCount?(args: {
+    address: `0x${string}`;
+  }): Promise<number>;
+  /**
+   * Optional: Estimates current gas fees per gas.
+   * Required for ERC-20 approval gas sponsoring.
+   */
+  estimateFeesPerGas?(): Promise<{
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+  }>;
+};
+/**
+ * FacilitatorEvmSigner - Used by x402 facilitators to verify and settle payments
+ * This is typically a viem PublicClient + WalletClient combination that can
+ * read contract state, verify signatures, write transactions, and wait for receipts
+ *
+ * Supports multiple addresses for load balancing, key rotation, and high availability
+ */
+/**
+ * Composes a ClientEvmSigner from a local account and a public client.
+ *
+ * Use this when your signer (e.g., `privateKeyToAccount`) doesn't have
+ * `readContract`. The `publicClient` provides the on-chain read capability.
+ *
+ * Alternatively, use a WalletClient extended with publicActions directly:
+ * ```typescript
+ * const signer = createWalletClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: baseSepolia,
+ *   transport: http(),
+ * }).extend(publicActions);
+ * ```
+ *
+ * @param signer - A signer with `address` and `signTypedData` (and optionally `readContract`)
+ * @param publicClient - A client with optional read/nonce/fee helpers
+ * @param publicClient.readContract - The readContract method from the public client
+ * @param publicClient.getTransactionCount - Optional getTransactionCount for ERC-20 approval
+ * @param publicClient.estimateFeesPerGas - Optional estimateFeesPerGas for ERC-20 approval
+ * @returns A ClientEvmSigner with any available optional capabilities
+ *
+ * @example
+ * ```typescript
+ * const account = privateKeyToAccount("0x...");
+ * const publicClient = createPublicClient({ chain: baseSepolia, transport: http() });
+ * const signer = toClientEvmSigner(account, publicClient);
+ * ```
+ */
+declare function toClientEvmSigner(signer: Omit<ClientEvmSigner, "readContract"> & {
+  readContract?: ClientEvmSigner["readContract"];
+}, publicClient?: {
+  readContract(args: {
+    address: `0x${string}`;
+    abi: readonly unknown[];
+    functionName: string;
+    args?: readonly unknown[];
+  }): Promise<unknown>;
+  getTransactionCount?(args: {
+    address: `0x${string}`;
+  }): Promise<number>;
+  estimateFeesPerGas?(): Promise<{
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+  }>;
+}): ClientEvmSigner;
+/**
+ * Converts a viem client with single address to a FacilitatorEvmSigner
+ * Wraps the single address in a getAddresses() function for compatibility
+ *
+ * @param client - The client to convert (must have 'address' property)
+ * @returns FacilitatorEvmSigner with getAddresses() support
+ */
+//#endregion
+//#region node_modules/.pnpm/@x402+evm@2.8.0_typescript@5.9.3/node_modules/@x402/evm/dist/esm/permit2-Bbh3a8_h.d.mts
+type ExactEvmSchemeConfig = {
+  rpcUrl?: string;
+};
+type ExactEvmSchemeConfigByChainId = Record<number, ExactEvmSchemeConfig>;
+type ExactEvmSchemeOptions = ExactEvmSchemeConfig | ExactEvmSchemeConfigByChainId;
+/**
+ * EVM client implementation for the Exact payment scheme.
+ * Supports both EIP-3009 (transferWithAuthorization) and Permit2 flows.
+ *
+ * Routes to the appropriate authorization method based on
+ * `requirements.extra.assetTransferMethod`. Defaults to EIP-3009
+ * for backward compatibility with older facilitators.
+ *
+ * When the server advertises `eip2612GasSponsoring` and the asset transfer
+ * method is `permit2`, the scheme automatically signs an EIP-2612 permit
+ * if the user lacks Permit2 approval. This requires `readContract` on the signer.
+ */
+declare class ExactEvmScheme implements SchemeNetworkClient {
+  private readonly signer;
+  private readonly options?;
+  readonly scheme = "exact";
+  /**
+   * Creates a new ExactEvmClient instance.
+   *
+   * @param signer - The EVM signer for client operations.
+   *   Base flow only requires `address` + `signTypedData`.
+   *   Extension enrichment (EIP-2612 / ERC-20 approval sponsoring) additionally
+   *   requires optional capabilities like `readContract` and tx signing helpers.
+   * @param options - Optional RPC configuration used to backfill extension capabilities.
+   */
+  constructor(signer: ClientEvmSigner, options?: ExactEvmSchemeOptions | undefined);
+  /**
+   * Creates a payment payload for the Exact scheme.
+   * Routes to EIP-3009 or Permit2 based on requirements.extra.assetTransferMethod.
+   *
+   * For Permit2 flows, if the server advertises `eip2612GasSponsoring` and the
+   * signer supports `readContract`, automatically signs an EIP-2612 permit
+   * when Permit2 allowance is insufficient.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @param context - Optional context with server-declared extensions
+   * @returns Promise resolving to a payment payload result (with optional extensions)
+   */
+  createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements, context?: PaymentPayloadContext): Promise<PaymentPayloadResult>;
+  /**
+   * Attempts to sign an EIP-2612 permit for gasless Permit2 approval.
+   *
+   * Returns extension data if:
+   * 1. Server advertises eip2612GasSponsoring
+   * 2. Signer has readContract capability
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param result - The payment payload result from the scheme
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for EIP-2612 gas sponsoring, or undefined if not applicable
+   */
+  private trySignEip2612Permit;
+  /**
+   * Attempts to sign an ERC-20 approval transaction for gasless Permit2 approval.
+   *
+   * This is the fallback path when the token does not support EIP-2612. The client
+   * signs (but does not broadcast) a raw `approve(Permit2, MaxUint256)` transaction.
+   * The facilitator broadcasts it atomically before settling.
+   *
+   * Returns extension data if:
+   * 1. Server advertises erc20ApprovalGasSponsoring
+   * 2. Signer has signTransaction + getTransactionCount capabilities
+   * 3. Current Permit2 allowance is insufficient
+   *
+   * Returns undefined if the extension should not be used.
+   *
+   * @param requirements - The payment requirements from the server
+   * @param _result - The payment payload result from the scheme (unused)
+   * @param context - Optional context containing server extensions and metadata
+   * @returns Extension data for ERC-20 approval gas sponsoring, or undefined if not applicable
+   */
+  private trySignErc20Approval;
+}
+//#endregion
+//#region node_modules/.pnpm/@x402+core@2.8.0/node_modules/@x402/core/dist/esm/client/index.d.mts
+/**
+ * Client Hook Context Interfaces
+ */
+interface PaymentCreationContext {
+  paymentRequired: PaymentRequired;
+  selectedRequirements: PaymentRequirements;
+}
+interface PaymentCreatedContext extends PaymentCreationContext {
+  paymentPayload: PaymentPayload;
+}
+interface PaymentCreationFailureContext extends PaymentCreationContext {
+  error: Error;
+}
+/**
+ * Client Hook Type Definitions
+ */
+type BeforePaymentCreationHook = (context: PaymentCreationContext) => Promise<void | {
+  abort: true;
+  reason: string;
+}>;
+type AfterPaymentCreationHook = (context: PaymentCreatedContext) => Promise<void>;
+type OnPaymentCreationFailureHook = (context: PaymentCreationFailureContext) => Promise<void | {
+  recovered: true;
+  payload: PaymentPayload;
+}>;
+type SelectPaymentRequirements = (x402Version: number, paymentRequirements: PaymentRequirements[]) => PaymentRequirements;
+/**
+ * Extension that can enrich payment payloads on the client side.
+ *
+ * Client extensions are invoked after the scheme creates the base payment payload
+ * but before it is returned. This allows mechanism-specific logic (e.g., EVM EIP-2612
+ * permit signing) to enrich the payload's extensions data.
+ */
+interface ClientExtension {
+  /**
+   * Unique key identifying this extension (e.g., "eip2612GasSponsoring").
+   * Must match the extension key used in PaymentRequired.extensions.
+   */
+  key: string;
+  /**
+   * Called after payload creation when the extension key is present in
+   * paymentRequired.extensions. Allows the extension to enrich the payload
+   * with extension-specific data (e.g., signing an EIP-2612 permit).
+   *
+   * @param paymentPayload - The payment payload to enrich
+   * @param paymentRequired - The original PaymentRequired response
+   * @returns The enriched payment payload
+   */
+  enrichPaymentPayload?: (paymentPayload: PaymentPayload, paymentRequired: PaymentRequired) => Promise<PaymentPayload>;
+}
+/**
+ * A policy function that filters or transforms payment requirements.
+ * Policies are applied in order before the selector chooses the final option.
+ *
+ * @param x402Version - The x402 protocol version
+ * @param paymentRequirements - Array of payment requirements to filter/transform
+ * @returns Filtered array of payment requirements
+ */
+type PaymentPolicy = (x402Version: number, paymentRequirements: PaymentRequirements[]) => PaymentRequirements[];
+/**
+ * Configuration for registering a payment scheme with a specific network
+ */
+interface SchemeRegistration {
+  /**
+   * The network identifier (e.g., 'eip155:8453', 'solana:mainnet')
+   */
+  network: Network;
+  /**
+   * The scheme client implementation for this network
+   */
+  client: SchemeNetworkClient;
+  /**
+   * The x402 protocol version to use for this scheme
+   *
+   * @default 2
+   */
+  x402Version?: number;
+}
+/**
+ * Configuration options for the fetch wrapper
+ */
+interface x402ClientConfig {
+  /**
+   * Array of scheme registrations defining which payment methods are supported
+   */
+  schemes: SchemeRegistration[];
+  /**
+   * Policies to apply to the client
+   */
+  policies?: PaymentPolicy[];
+  /**
+   * Custom payment requirements selector function
+   * If not provided, uses the default selector (first available option)
+   */
+  paymentRequirementsSelector?: SelectPaymentRequirements;
+}
+/**
+ * Core client for managing x402 payment schemes and creating payment payloads.
+ *
+ * Handles registration of payment schemes, policy-based filtering of payment requirements,
+ * and creation of payment payloads based on server requirements.
+ */
+declare class x402Client {
+  private readonly paymentRequirementsSelector;
+  private readonly registeredClientSchemes;
+  private readonly policies;
+  private readonly registeredExtensions;
+  private beforePaymentCreationHooks;
+  private afterPaymentCreationHooks;
+  private onPaymentCreationFailureHooks;
+  /**
+   * Creates a new x402Client instance.
+   *
+   * @param paymentRequirementsSelector - Function to select payment requirements from available options
+   */
+  constructor(paymentRequirementsSelector?: SelectPaymentRequirements);
+  /**
+   * Creates a new x402Client instance from a configuration object.
+   *
+   * @param config - The client configuration including schemes, policies, and payment requirements selector
+   * @returns A configured x402Client instance
+   */
+  static fromConfig(config: x402ClientConfig): x402Client;
+  /**
+   * Registers a scheme client for the current x402 version.
+   *
+   * @param network - The network to register the client for
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  register(network: Network, client: SchemeNetworkClient): x402Client;
+  /**
+   * Registers a scheme client for x402 version 1.
+   *
+   * @param network - The v1 network identifier (e.g., 'base-sepolia', 'solana-devnet')
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  registerV1(network: string, client: SchemeNetworkClient): x402Client;
+  /**
+   * Registers a policy to filter or transform payment requirements.
+   *
+   * Policies are applied in order after filtering by registered schemes
+   * and before the selector chooses the final payment requirement.
+   *
+   * @param policy - Function to filter/transform payment requirements
+   * @returns The x402Client instance for chaining
+   *
+   * @example
+   * ```typescript
+   * // Prefer cheaper options
+   * client.registerPolicy((version, reqs) =>
+   *   reqs.filter(r => BigInt(r.value) < BigInt('1000000'))
+   * );
+   *
+   * // Prefer specific networks
+   * client.registerPolicy((version, reqs) =>
+   *   reqs.filter(r => r.network.startsWith('eip155:'))
+   * );
+   * ```
+   */
+  registerPolicy(policy: PaymentPolicy): x402Client;
+  /**
+   * Registers a client extension that can enrich payment payloads.
+   *
+   * Extensions are invoked after the scheme creates the base payload and the
+   * payload is wrapped with extensions/resource/accepted data. If the extension's
+   * key is present in `paymentRequired.extensions`, the extension's
+   * `enrichPaymentPayload` hook is called to modify the payload.
+   *
+   * @param extension - The client extension to register
+   * @returns The x402Client instance for chaining
+   */
+  registerExtension(extension: ClientExtension): x402Client;
+  /**
+   * Register a hook to execute before payment payload creation.
+   * Can abort creation by returning { abort: true, reason: string }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onBeforePaymentCreation(hook: BeforePaymentCreationHook): x402Client;
+  /**
+   * Register a hook to execute after successful payment payload creation.
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onAfterPaymentCreation(hook: AfterPaymentCreationHook): x402Client;
+  /**
+   * Register a hook to execute when payment payload creation fails.
+   * Can recover from failure by returning { recovered: true, payload: PaymentPayload }
+   *
+   * @param hook - The hook function to register
+   * @returns The x402Client instance for chaining
+   */
+  onPaymentCreationFailure(hook: OnPaymentCreationFailureHook): x402Client;
+  /**
+   * Creates a payment payload based on a PaymentRequired response.
+   *
+   * Automatically extracts x402Version, resource, and extensions from the PaymentRequired
+   * response and constructs a complete PaymentPayload with the accepted requirements.
+   *
+   * @param paymentRequired - The PaymentRequired response from the server
+   * @returns Promise resolving to the complete payment payload
+   */
+  createPaymentPayload(paymentRequired: PaymentRequired): Promise<PaymentPayload>;
+  /**
+   * Merges server-declared extensions with scheme-provided extensions.
+   * Scheme extensions overlay on top of server extensions at each key,
+   * preserving server-provided schema while overlaying scheme-provided info.
+   *
+   * @param serverExtensions - Extensions declared by the server in the 402 response
+   * @param schemeExtensions - Extensions provided by the scheme client (e.g. EIP-2612)
+   * @returns The merged extensions object, or undefined if both inputs are undefined
+   */
+  private mergeExtensions;
+  /**
+   * Enriches a payment payload by calling registered extension hooks.
+   * For each extension key present in the PaymentRequired response,
+   * invokes the corresponding extension's enrichPaymentPayload callback.
+   *
+   * @param paymentPayload - The payment payload to enrich with extension data
+   * @param paymentRequired - The PaymentRequired response containing extension declarations
+   * @returns The enriched payment payload with extension data applied
+   */
+  private enrichPaymentPayloadWithExtensions;
+  /**
+   * Selects appropriate payment requirements based on registered clients and policies.
+   *
+   * Selection process:
+   * 1. Filter by registered schemes (network + scheme support)
+   * 2. Apply all registered policies in order
+   * 3. Use selector to choose final requirement
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - Array of available payment requirements
+   * @returns The selected payment requirements
+   */
+  private selectPaymentRequirements;
+  /**
+   * Internal method to register a scheme client.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param network - The network to register the client for
+   * @param client - The scheme network client to register
+   * @returns The x402Client instance for chaining
+   */
+  private _registerScheme;
+}
+/**
+ * Context provided to onPaymentRequired hooks.
+ */
+//#endregion
+//#region node_modules/.pnpm/@solana+codecs-core@6.5.0_typescript@5.9.3/node_modules/@solana/codecs-core/dist/types/readonly-uint8array.d.ts
+/**
+ * A read-only variant of `Uint8Array`.
+ *
+ * This type prevents modifications to the array by omitting mutable methods such as `copyWithin`,
+ * `fill`, `reverse`, `set`, and `sort`, while still allowing indexed access to elements.
+ *
+ * @example
+ * ```ts
+ * const bytes: ReadonlyUint8Array = new Uint8Array([1, 2, 3]);
+ * console.log(bytes[0]); // 1
+ * bytes[0] = 42; // Type error: Cannot assign to '0' because it is a read-only property.
+ * ```
+ */
+interface ReadonlyUint8Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends Omit<Uint8Array<TArrayBuffer>, TypedArrayMutableProperties> {
+  readonly [n: number]: number;
+}
+type TypedArrayMutableProperties = 'copyWithin' | 'fill' | 'reverse' | 'set' | 'sort';
+//#endregion
+//#region node_modules/.pnpm/@solana+nominal-types@6.5.0_typescript@5.9.3/node_modules/@solana/nominal-types/dist/types/index.d.ts
+type StringEncoding = 'base58' | 'base64';
+/**
+ * Use this to produce a new type that satisfies the original type, but adds extra type information
+ * that marks the type as being an affine point over a field that either lies on a given curve
+ * (is valid) or does not (is invalid).
+ *
+ * @typeParam T - The underlying type
+ * @typeParam TValidity - Whether the point is valid or invalid
+ *
+ * @example
+ * ```ts
+ * const address = 'dv1ZAGvdsz5hHLwWXsVnM94hWf1pjbKVau1QVkaMJ92';
+ * const onCurveAddress = address as AffinePoint<typeof address, 'valid'>;
+ *
+ * onCurveAddress satisfies AffinePoint<'dv1ZAGvdsz5hHLwWXsVnM94hWf1pjbKVau1QVkaMJ92', 'valid'>; // OK
+ * onCurveAddress satisfies AffinePoint<string, 'valid'>; // OK
+ * onCurveAddress satisfies AffinePoint<string, 'invalid'>; // ERROR
+ * address satisfies AffinePoint<string, 'valid'>; // ERROR
+ * address satisfies AffinePoint<string, 'invalid'>; // ERROR
+ * ```
+ */
+/**
+ * Use this to produce a new type that satisfies the original type, but not the other way around.
+ * That is to say, the branded type is acceptable wherever the original type is specified, but
+ * wherever the branded type is specified, the original type will be insufficient.
+ *
+ * You can use this to create specialized instances of strings, numbers, objects, and more which
+ * you would like to assert are special in some way (eg. numbers that are non-negative, strings
+ * which represent the names of foods, objects that have passed validation).
+ *
+ * @typeParam T - The base type to brand
+ * @typeParam TBrandName - A string that identifies a particular brand. Branded types with identical
+ * names will satisfy each other so long as their base types satisfy each other. Branded types with
+ * different names will never satisfy each other.
+ *
+ * @example
+ * ```ts
+ * const unverifiedName = 'Alice';
+ * const verifiedName = unverifiedName as Brand<'Alice', 'VerifiedName'>;
+ *
+ * 'Alice' satisfies Brand<string, 'VerifiedName'>; // ERROR
+ * 'Alice' satisfies Brand<'Alice', 'VerifiedName'>; // ERROR
+ * unverifiedName satisfies Brand<string, 'VerifiedName'>; // ERROR
+ * verifiedName satisfies Brand<'Bob', 'VerifiedName'>; // ERROR
+ * verifiedName satisfies Brand<'Alice', 'VerifiedName'>; // OK
+ * verifiedName satisfies Brand<string, 'VerifiedName'>; // OK
+ * ```
+ */
+type Brand<T, TBrandName extends string> = NominalType<'brand', TBrandName> & T;
+/**
+ * Use this to produce a new type that satisfies the original string type, but adds extra type
+ * information that marks the string as being encoded in a particular format.
+ *
+ * @typeParam T - The underlying string type
+ * @typeParam TEncoding - The encoding format of the string
+ *
+ * @example
+ * ```ts
+ * const untaggedString = 'dv1ZAGvdsz5hHLwWXsVnM94hWf1pjbKVau1QVkaMJ92';
+ * const encodedString = untaggedString as EncodedString<typeof untaggedString, 'base58'>;
+ *
+ * encodedString satisfies EncodedString<'dv1ZAGvdsz5hHLwWXsVnM94hWf1pjbKVau1QVkaMJ92', 'base58'>; // OK
+ * encodedString satisfies EncodedString<string, 'base58'>; // OK
+ * encodedString satisfies EncodedString<string, 'base64'>; // ERROR
+ * untaggedString satisfies EncodedString<string, 'base58'>; // ERROR
+ * ```
+ */
+type EncodedString<T extends string, TEncoding extends StringEncoding> = NominalType<'stringEncoding', TEncoding> & T;
+/**
+ * Use this to produce a nominal type.
+ *
+ * This can be intersected with other base types to produce custom branded types.
+ *
+ * @typeParam TKey - The name of the nominal type. This distinguishes one nominal type from another.
+ * @typeParam TMarker - The type of the value the nominal type can take.
+ *
+ * @example
+ * ```ts
+ * type SweeteningSubstance = 'aspartame' | 'cane-sugar' | 'stevia';
+ * type Sweetener<T extends SweeteningSubstance> = NominalType<'sweetener', T>;
+ *
+ * // This function accepts sweetened foods, except those with aspartame.
+ * declare function eat(food: string & Sweetener<Exclude<SweeteningSubstance, 'aspartame'>>): void;
+ *
+ * const artificiallySweetenedDessert = 'ice-cream' as string & Sweetener<'aspartame'>;
+ * eat(artificiallySweetenedDessert); // ERROR
+ * ```
+ */
+type NominalType<TKey extends string, TMarker extends string> = { readonly [K in `__${TKey}:@solana/kit`]: TMarker };
+//#endregion
+//#region node_modules/.pnpm/@solana+addresses@6.5.0_typescript@5.9.3/node_modules/@solana/addresses/dist/types/address.d.ts
+/**
+ * Represents a string that validates as a Solana address. Functions that require well-formed
+ * addresses should specify their inputs in terms of this type.
+ *
+ * Whenever you need to validate an arbitrary string as a base58-encoded address, use the
+ * {@link address}, {@link assertIsAddress}, or {@link isAddress} functions in this package.
+ */
+type Address<TAddress extends string = string> = Brand<EncodedString<TAddress, 'base58'>, 'Address'>;
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-types@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-types/dist/types/blockhash.d.ts
+type Blockhash = Brand<EncodedString<string, 'base58'>, 'Blockhash'>;
+//#endregion
+//#region node_modules/.pnpm/@solana+rpc-types@6.5.0_typescript@5.9.3/node_modules/@solana/rpc-types/dist/types/typed-numbers.d.ts
+type Slot = bigint;
+//#endregion
+//#region node_modules/.pnpm/@solana+transaction-messages@6.5.0_typescript@5.9.3/node_modules/@solana/transaction-messages/dist/types/durable-nonce.d.ts
+/** Represents a string that is particularly known to be the base58-encoded value of a nonce. */
+type Nonce<TNonceValue extends string = string> = Brand<TNonceValue, 'Nonce'>;
+//#endregion
+//#region node_modules/.pnpm/@solana+keys@6.5.0_typescript@5.9.3/node_modules/@solana/keys/dist/types/signatures.d.ts
+/**
+ * A 64-byte Ed25519 signature.
+ *
+ * Whenever you need to verify that a particular signature is, in fact, the one that would have been
+ * produced by signing some known bytes using the private key associated with some known public key,
+ * use the {@link verifySignature} function in this package.
+ */
+type SignatureBytes = Brand<Uint8Array, 'SignatureBytes'>;
+//#endregion
+//#region node_modules/.pnpm/@solana+transactions@6.5.0_typescript@5.9.3/node_modules/@solana/transactions/dist/types/lifetime.d.ts
+/**
+ * A constraint which, when applied to a transaction, makes that transaction eligible to land on the
+ * network. The transaction will continue to be eligible to land until the network considers the
+ * `blockhash` to be expired.
+ *
+ * This can happen when the network proceeds past the `lastValidBlockHeight` for which the blockhash
+ * is considered valid, or when the network switches to a fork where that blockhash is not present.
+ */
+type TransactionBlockhashLifetime = {
+  /**
+   * A recent blockhash observed by the transaction proposer.
+   *
+   * The transaction will be considered eligible to land until the network determines this
+   * blockhash to be too old, or has switched to a fork where it is not present.
+   */
+  blockhash: Blockhash;
+  /**
+   * This is the block height beyond which the network will consider the blockhash to be too old
+   * to make a transaction eligible to land.
+   */
+  lastValidBlockHeight: Slot;
+};
+/**
+ * A constraint which, when applied to a transaction, makes that transaction eligible to land on the
+ * network.
+ *
+ * The transaction will continue to be eligible to land until the network considers the `nonce` to
+ * have advanced. This can happen when the nonce account in which this nonce is found is destroyed,
+ * or the nonce value within changes.
+ */
+type TransactionDurableNonceLifetime = {
+  /**
+   * A value contained in the account with address `nonceAccountAddress` at the time the
+   * transaction was prepared.
+   *
+   * The transaction will be considered eligible to land until the nonce account ceases to exist
+   * or contain this value.
+   */
+  nonce: Nonce; /** The account that contains the `nonce` value */
+  nonceAccountAddress: Address;
+};
+/**
+ * A transaction whose ability to land on the network is determined by some evanescent criteria.
+ *
+ * This describes a window of time after which a transaction is constructed and before which it will
+ * no longer be accepted by the network.
+ *
+ * No transaction can land on Solana without having a `lifetimeConstraint` set.
+ */
+type TransactionWithLifetime = {
+  readonly lifetimeConstraint: TransactionBlockhashLifetime | TransactionDurableNonceLifetime;
+};
+//#endregion
+//#region node_modules/.pnpm/@solana+transactions@6.5.0_typescript@5.9.3/node_modules/@solana/transactions/dist/types/transaction-size.d.ts
+/**
+ * A type guard that checks if a transaction is within the size limit.
+ */
+type TransactionWithinSizeLimit = NominalType<'transactionSize', 'withinLimit'>;
+//#endregion
+//#region node_modules/.pnpm/@solana+transactions@6.5.0_typescript@5.9.3/node_modules/@solana/transactions/dist/types/transaction.d.ts
+type TransactionMessageBytes = Brand<ReadonlyUint8Array, 'TransactionMessageBytes'>;
+type OrderedMap<K extends string, V> = Record<K, V>;
+type SignaturesMap = OrderedMap<Address, SignatureBytes | null>;
+type Transaction = Readonly<{
+  /** The bytes of a compiled transaction message, encoded in wire format */messageBytes: TransactionMessageBytes;
+  /**
+   * A map between the addresses of a transaction message's signers, and the 64-byte Ed25519
+   * signature of the transaction's `messageBytes` by the private key associated with each.
+   */
+  signatures: SignaturesMap;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/types.d.ts
+type SignatureDictionary = Readonly<Record<Address, SignatureBytes>>;
+/**
+ * The base configuration object for all signers — including transaction and message signers.
+ */
+type BaseSignerConfig = Readonly<{
+  /**
+   * An optional `AbortSignal` that can be used to cancel the signing process.
+   *
+   * @example
+   * ```ts
+   * import { generateKeyPairSigner } from '@solana/signers';
+   *
+   * const abortController = new AbortController();
+   * const signer = await generateKeyPairSigner();
+   * signer.signMessages([message], { abortSignal: abortController.signal });
+   * abortController.abort();
+   * ```
+   */
+  abortSignal?: AbortSignal;
+}>;
+/**
+ * The base configuration object for transaction signers only.
+ */
+interface BaseTransactionSignerConfig extends BaseSignerConfig {
+  /**
+   * Signers that simulate transactions (eg. wallets) might be interested in knowing which slot
+   * was current when the transaction was prepared. They can use this information to ensure that
+   * they don't run the simulation at too early a slot.
+   */
+  minContextSlot?: Slot;
+}
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/transaction-modifying-signer.d.ts
+/**
+ * The configuration to optionally provide when calling the
+ * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} method.
+ *
+ * @see {@link BaseTransactionSignerConfig}
+ */
+type TransactionModifyingSignerConfig = BaseTransactionSignerConfig;
+/**
+ * A signer interface that potentially modifies the provided {@link Transaction | Transactions}
+ * before signing them.
+ *
+ * For instance, this enables wallets to inject additional instructions into the
+ * transaction before signing them. For each transaction, instead of returning a
+ * {@link SignatureDictionary}, its
+ * {@link TransactionModifyingSigner#modifyAndSignTransactions | modifyAndSignTransactions} function
+ * returns an updated {@link Transaction} with a potentially modified set of instructions and
+ * signature dictionary. The returned transaction must be within the transaction size limit,
+ * and include a `lifetimeConstraint`.
+ *
+ * @typeParam TAddress - Supply a string literal to define a signer having a particular address.
+ *
+ * @example
+ * ```ts
+ * const signer: TransactionModifyingSigner<'1234..5678'> = {
+ *     address: address('1234..5678'),
+ *     modifyAndSignTransactions: async (
+ *         transactions: Transaction[]
+ *     ): Promise<(Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]> => {
+ *         // My custom signing logic.
+ *     },
+ * };
+ * ```
+ *
+ * @remarks
+ * Here are the main characteristics of this signer interface:
+ *
+ * - **Sequential**. Contrary to partial signers, these cannot be executed in
+ *   parallel as each call can modify the provided transactions.
+ * - **First signers**. For a given transaction, a modifying signer must always
+ *   be used before a partial signer as the former will likely modify the
+ *   transaction and thus impact the outcome of the latter.
+ * - **Potential conflicts**. If more than one modifying signer is provided,
+ *   the second signer may invalidate the signature of the first one. However,
+ *   modifying signers may decide not to modify a transaction based on the
+ *   existence of signatures for that transaction.
+ *
+ * @see {@link isTransactionModifyingSigner}
+ * @see {@link assertIsTransactionModifyingSigner}
+ */
+type TransactionModifyingSigner<TAddress extends string = string> = Readonly<{
+  address: Address<TAddress>;
+  modifyAndSignTransactions(transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[], config?: TransactionModifyingSignerConfig): Promise<readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[]>;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/transaction-partial-signer.d.ts
+/**
+ * The configuration to optionally provide when calling the
+ * {@link TransactionPartialSigner#signTransactions | signTransactions} method.
+ *
+ * @see {@link BaseTransactionSignerConfig}
+ */
+type TransactionPartialSignerConfig = BaseTransactionSignerConfig;
+/**
+ * A signer interface that signs an array of {@link Transaction | Transactions}
+ *  without modifying their content. It defines a
+ * {@link TransactionPartialSigner#signTransactions | signTransactions}
+ * function that returns a {@link SignatureDictionary} for each provided transaction.
+ *
+ * Such signature dictionaries are expected to be merged with the existing ones if any.
+ *
+ * @typeParam TAddress - Supply a string literal to define a signer having a particular address.
+ *
+ * @example
+ * ```ts
+ * const signer: TransactionPartialSigner<'1234..5678'> = {
+ *     address: address('1234..5678'),
+ *     signTransactions: async (
+ *         transactions: Transaction[]
+ *     ): Promise<SignatureDictionary[]> => {
+ *         // My custom signing logic.
+ *     },
+ * };
+ * ```
+ *
+ * @remarks
+ * Here are the main characteristics of this signer interface:
+ *
+ * - **Parallel**. It returns a signature dictionary for each provided
+ *   transaction without modifying them, making it possible for multiple
+ *   partial signers to sign the same transaction in parallel.
+ * - **Flexible order**. The order in which we use these signers for
+ *   a given transaction doesn’t matter.
+ *
+ * @see {@link isTransactionPartialSigner}
+ * @see {@link assertIsTransactionPartialSigner}
+ */
+type TransactionPartialSigner<TAddress extends string = string> = Readonly<{
+  address: Address<TAddress>;
+  signTransactions(transactions: readonly (Transaction & TransactionWithinSizeLimit & TransactionWithLifetime)[], config?: TransactionPartialSignerConfig): Promise<readonly SignatureDictionary[]>;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/transaction-sending-signer.d.ts
+/**
+ * The configuration to optionally provide when calling the
+ * {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions} method.
+ *
+ * @see {@link BaseTransactionSignerConfig}
+ */
+type TransactionSendingSignerConfig = BaseTransactionSignerConfig;
+/**
+ * A signer interface that signs one or multiple transactions
+ * before sending them immediately to the blockchain.
+ *
+ * It defines a {@link TransactionSendingSignerConfig#signAndSendTransactions | signAndSendTransactions}
+ * function that returns the transaction signature (i.e. its identifier) for each provided
+ * {@link Transaction}.
+ *
+ * This interface is required for PDA wallets and other types of wallets that don't provide an
+ * interface for signing transactions without sending them.
+ *
+ * Note that it is also possible for such signers to modify the provided transactions
+ * before signing and sending them. This enables use cases where the modified transactions
+ * cannot be shared with the app and thus must be sent directly.
+ *
+ * @typeParam TAddress - Supply a string literal to define a signer having a particular address.
+ *
+ * @example
+ * ```ts
+ * const myTransactionSendingSigner: TransactionSendingSigner<'1234..5678'> = {
+ *     address: address('1234..5678'),
+ *     signAndSendTransactions: async (transactions: Transaction[]): Promise<SignatureBytes[]> => {
+ *         // My custom signing logic.
+ *     },
+ * };
+ * ```
+ *
+ * @remarks
+ * Here are the main characteristics of this signer interface:
+ *
+ * - **Single signer**. Since this signer also sends the provided transactions,
+ *   we can only use a single {@link TransactionSendingSigner} for a given set of transactions.
+ * - **Last signer**. Trivially, that signer must also be the last one used.
+ * - **Potential conflicts**. Since signers may decide to modify the given
+ *   transactions before sending them, they may invalidate previous signatures.
+ *   However, signers may decide not to modify a transaction based
+ *   on the existence of signatures for that transaction.
+ * - **Potential confirmation**. Whilst this is not required by this interface,
+ *   it is also worth noting that most wallets will also wait for the transaction
+ *   to be confirmed (typically with a `confirmed` commitment)
+ *   before notifying the app that they are done.
+ *
+ * @see {@link isTransactionSendingSigner}
+ * @see {@link assertIsTransactionSendingSigner}
+ */
+type TransactionSendingSigner<TAddress extends string = string> = Readonly<{
+  address: Address<TAddress>;
+  signAndSendTransactions(transactions: readonly (Transaction | (Transaction & TransactionWithLifetime))[], config?: TransactionSendingSignerConfig): Promise<readonly SignatureBytes[]>;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/transaction-signer.d.ts
+/**
+ * Defines a signer capable of signing transactions.
+ *
+ * @see {@link TransactionModifyingSigner} For signers that can modify transactions before signing them.
+ * @see {@link TransactionPartialSigner} For signers that can be used in parallel.
+ * @see {@link TransactionSendingSigner} For signers that send transactions after signing them.
+ * @see {@link isTransactionSigner}
+ * @see {@link assertIsTransactionSigner}
+ */
+type TransactionSigner<TAddress extends string = string> = TransactionModifyingSigner<TAddress> | TransactionPartialSigner<TAddress> | TransactionSendingSigner<TAddress>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/signable-message.d.ts
+/**
+ * Defines a message that needs signing and its current set of signatures if any.
+ *
+ * This interface allows {@link MessageModifyingSigner | MessageModifyingSigners}
+ * to decide on whether or not they should modify the provided message depending
+ * on whether or not signatures already exist for such message.
+ *
+ * It also helps create a more consistent API by providing a structure analogous
+ * to transactions which also keep track of their {@link SignatureDictionary}.
+ *
+ * @example
+ * ```ts
+ * import { createSignableMessage } from '@solana/signers';
+ *
+ * const message = createSignableMessage(new Uint8Array([1, 2, 3]));
+ * message.content; // The content of the message as bytes.
+ * message.signatures; // The current set of signatures for this message.
+ * ```
+ *
+ * @see {@link createSignableMessage}
+ */
+type SignableMessage = Readonly<{
+  content: Uint8Array;
+  signatures: SignatureDictionary;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/message-partial-signer.d.ts
+/**
+ * The configuration to optionally provide when calling the
+ * {@link MessagePartialSigner#signMessages | signMessages} method.
+ *
+ * @see {@link BaseSignerConfig}
+ */
+type MessagePartialSignerConfig = BaseSignerConfig;
+/**
+ * A signer interface that signs an array of {@link SignableMessage | SignableMessages}
+ * without modifying their content.
+ *
+ * It defines a {@link MessagePartialSigner#signMessages | signMessages} function
+ * that returns a {@link SignatureDictionary} for each provided message.
+ * Such signature dictionaries are expected to be merged with the existing ones if any.
+ *
+ * @typeParam TAddress - Supply a string literal to define a signer having a particular address.
+ *
+ * @example
+ * ```ts
+ * const signer: MessagePartialSigner<'1234..5678'> = {
+ *     address: address('1234..5678'),
+ *     signMessages: async (
+ *         messages: SignableMessage[]
+ *     ): Promise<SignatureDictionary[]> => {
+ *         // My custom signing logic.
+ *     },
+ * };
+ * ```
+ *
+ * @remarks
+ * Here are the main characteristics of this signer interface:
+ *
+ * - **Parallel**. When multiple signers sign the same message, we can
+ *   perform this operation in parallel to obtain all their signatures.
+ * - **Flexible order**. The order in which we use these signers
+ *   for a given message doesn’t matter.
+ *
+ * @see {@link SignableMessage}
+ * @see {@link createSignableMessage}
+ * @see {@link isMessagePartialSigner}
+ * @see {@link assertIsMessagePartialSigner}
+ */
+type MessagePartialSigner<TAddress extends string = string> = Readonly<{
+  address: Address<TAddress>;
+  signMessages(messages: readonly SignableMessage[], config?: MessagePartialSignerConfig): Promise<readonly SignatureDictionary[]>;
+}>;
+//#endregion
+//#region node_modules/.pnpm/@solana+signers@6.5.0_typescript@5.9.3/node_modules/@solana/signers/dist/types/keypair-signer.d.ts
+/**
+ * Defines a signer that uses a {@link CryptoKeyPair} to sign messages and transactions.
+ *
+ * It implements both the {@link MessagePartialSigner} and {@link TransactionPartialSigner}
+ * interfaces and keeps track of the {@link CryptoKeyPair} instance used
+ * to sign messages and transactions.
+ *
+ * @typeParam TAddress - Supply a string literal to define a signer having a particular address.
+ *
+ * @example
+ * ```ts
+ * import { generateKeyPairSigner } from '@solana/signers';
+ *
+ * const signer = generateKeyPairSigner();
+ * signer.address; // Address;
+ * signer.keyPair; // CryptoKeyPair;
+ * const [messageSignatures] = await signer.signMessages([message]);
+ * const [transactionSignatures] = await signer.signTransactions([transaction]);
+ * ```
+ *
+ * @see {@link generateKeyPairSigner}
+ * @see {@link createSignerFromKeyPair}
+ * @see {@link createKeyPairSignerFromBytes}
+ * @see {@link createKeyPairSignerFromPrivateKeyBytes}
+ * @see {@link isKeyPairSigner}
+ * @see {@link assertIsKeyPairSigner}
+ */
+type KeyPairSigner<TAddress extends string = string> = MessagePartialSigner<TAddress> & TransactionPartialSigner<TAddress> & {
+  keyPair: CryptoKeyPair;
+};
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/utility.d.ts
+type AutocompletePrimitiveBaseType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>);
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/header.d.ts
+/**
+ * The header type declaration of `undici`.
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type HeaderNames = Autocomplete<'Accept' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Encoding' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'Alt-Svc' | 'Alt-Used' | 'Authorization' | 'Cache-Control' | 'Clear-Site-Data' | 'Connection' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'Device-Memory' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Forwarded' | 'From' | 'Host' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Unmodified-Since' | 'Keep-Alive' | 'Last-Modified' | 'Link' | 'Location' | 'Max-Forwards' | 'Origin' | 'Permissions-Policy' | 'Priority' | 'Proxy-Authenticate' | 'Proxy-Authorization' | 'Range' | 'Referer' | 'Referrer-Policy' | 'Retry-After' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-Purpose' | 'Sec-WebSocket-Accept' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'SourceMap' | 'Strict-Transport-Security' | 'TE' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Upgrade-Insecure-Requests' | 'User-Agent' | 'Vary' | 'Via' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options'>;
+type IANARegisteredMimeType = Autocomplete<'audio/aac' | 'video/x-msvideo' | 'image/avif' | 'video/av1' | 'application/octet-stream' | 'image/bmp' | 'text/css' | 'text/csv' | 'application/vnd.ms-fontobject' | 'application/epub+zip' | 'image/gif' | 'application/gzip' | 'text/html' | 'image/x-icon' | 'text/calendar' | 'image/jpeg' | 'text/javascript' | 'application/json' | 'application/ld+json' | 'audio/x-midi' | 'audio/mpeg' | 'video/mp4' | 'video/mpeg' | 'audio/ogg' | 'video/ogg' | 'application/ogg' | 'audio/opus' | 'font/otf' | 'application/pdf' | 'image/png' | 'application/rtf' | 'image/svg+xml' | 'image/tiff' | 'video/mp2t' | 'font/ttf' | 'text/plain' | 'application/wasm' | 'video/webm' | 'audio/webm' | 'image/webp' | 'font/woff' | 'font/woff2' | 'application/xhtml+xml' | 'application/xml' | 'application/zip' | 'video/3gpp' | 'video/3gpp2' | 'model/gltf+json' | 'model/gltf-binary'>;
+type KnownHeaderValues = {
+  'content-type': IANARegisteredMimeType;
+};
+type HeaderRecord = { [K in HeaderNames | Lowercase<HeaderNames>]?: Lowercase<K> extends keyof KnownHeaderValues ? KnownHeaderValues[Lowercase<K>] : string };
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/readable.d.ts
+declare class BodyReadable extends Readable {
+  constructor(opts: {
+    resume: (this: Readable, size: number) => void | null;
+    abort: () => void | null;
+    contentType?: string;
+    contentLength?: number;
+    highWaterMark?: number;
+  });
+  /** Consumes and returns the body as a string
+   *  https://fetch.spec.whatwg.org/#dom-body-text
+   */
+  text(): Promise<string>;
+  /** Consumes and returns the body as a JavaScript Object
+   *  https://fetch.spec.whatwg.org/#dom-body-json
+   */
+  json(): Promise<unknown>;
+  /** Consumes and returns the body as a Blob
+   *  https://fetch.spec.whatwg.org/#dom-body-blob
+   */
+  blob(): Promise<Blob>;
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes(): Promise<Uint8Array>;
+  /** Consumes and returns the body as an ArrayBuffer
+   *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+   */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Not implemented
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-formdata
+   */
+  formData(): Promise<never>;
+  /** Returns true if the body is not null and the body has been consumed
+   *
+   *  Otherwise, returns false
+   *
+   * https://fetch.spec.whatwg.org/#dom-body-bodyused
+   */
+  readonly bodyUsed: boolean;
+  /**
+   * If body is null, it should return null as the body
+   *
+   *  If body is not null, should return the body as a ReadableStream
+   *
+   *  https://fetch.spec.whatwg.org/#dom-body-body
+   */
+  readonly body: never | undefined;
+  /** Dumps the response body by reading `limit` number of bytes.
+   * @param opts.limit Number of bytes to read (optional) - Default: 131072
+   * @param opts.signal AbortSignal to cancel the operation (optional)
+   */
+  dump(opts?: {
+    limit: number;
+    signal?: AbortSignal;
+  }): Promise<void>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/fetch.d.ts
+type BodyInit = ArrayBuffer | AsyncIterable<Uint8Array> | Blob | FormData | Iterable<Uint8Array> | NodeJS.ArrayBufferView | URLSearchParams | null | string;
+interface SpecIterator<T, TReturn = any, TNext = undefined> {
+  next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+}
+interface SpecIterableIterator<T> extends SpecIterator<T> {
+  [Symbol.iterator](): SpecIterableIterator<T>;
+}
+interface SpecIterable<T> {
+  [Symbol.iterator](): SpecIterator<T>;
+}
+type HeadersInit = [string, string][] | HeaderRecord | Headers;
+declare class Headers implements SpecIterable<[string, string]> {
+  constructor(init?: HeadersInit);
+  readonly append: (name: string, value: string) => void;
+  readonly delete: (name: string) => void;
+  readonly get: (name: string) => string | null;
+  readonly has: (name: string) => boolean;
+  readonly set: (name: string, value: string) => void;
+  readonly getSetCookie: () => string[];
+  readonly forEach: (callbackfn: (value: string, key: string, iterable: Headers) => void, thisArg?: unknown) => void;
+  readonly keys: () => SpecIterableIterator<string>;
+  readonly values: () => SpecIterableIterator<string>;
+  readonly entries: () => SpecIterableIterator<[string, string]>;
+  readonly [Symbol.iterator]: () => SpecIterableIterator<[string, string]>;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/formdata.d.ts
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File;
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData {
+  /**
+   * Appends a new value onto an existing key inside a FormData object,
+   * or adds the key if it does not already exist.
+   *
+   * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   */
+  append(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Set a new value for an existing key inside FormData,
+   * or add the new field if it does not already exist.
+   *
+   * @param name The name of the field whose data is contained in `value`.
+   * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+    or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+   * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+   *
+   */
+  set(name: string, value: unknown, fileName?: string): void;
+  /**
+   * Returns the first value associated with a given key from within a `FormData` object.
+   * If you expect multiple values and want all of them, use the `getAll()` method instead.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+   */
+  get(name: string): FormDataEntryValue | null;
+  /**
+   * Returns all the values associated with a given key from within a `FormData` object.
+   *
+   * @param {string} name A name of the value you want to retrieve.
+   *
+   * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+   */
+  getAll(name: string): FormDataEntryValue[];
+  /**
+   * Returns a boolean stating whether a `FormData` object contains a certain key.
+   *
+   * @param name A string representing the name of the key you want to test for.
+   *
+   * @return A boolean value.
+   */
+  has(name: string): boolean;
+  /**
+   * Deletes a key and its value(s) from a `FormData` object.
+   *
+   * @param name The name of the key you want to delete.
+   */
+  delete(name: string): void;
+  /**
+   * Executes given callback function for each field of the FormData instance
+   */
+  forEach: (callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData) => void, thisArg?: unknown) => void;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+   * Each key is a `string`.
+   */
+  keys: () => SpecIterableIterator<string>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+   * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  values: () => SpecIterableIterator<FormDataEntryValue>;
+  /**
+   * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+   * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+   */
+  entries: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  /**
+   * An alias for FormData#entries()
+   */
+  [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>;
+  readonly [Symbol.toStringTag]: string;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/connector.d.ts
+declare function buildConnector(options?: buildConnector.BuildOptions): buildConnector.connector;
+declare namespace buildConnector {
+  export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+    allowH2?: boolean;
+    maxCachedSessions?: number | null;
+    socketPath?: string | null;
+    timeout?: number | null;
+    port?: number;
+    keepAlive?: boolean | null;
+    keepAliveInitialDelay?: number | null;
+    typeOfService?: number | null;
+  };
+  export interface Options {
+    hostname: string;
+    host?: string;
+    protocol: string;
+    port: string;
+    servername?: string;
+    localAddress?: string | null;
+    socketPath?: string | null;
+    httpSocket?: Socket;
+  }
+  export type Callback = (...args: CallbackArgs) => void;
+  type CallbackArgs = [null, Socket | TLSSocket] | [Error, null];
+  export interface connector {
+    (options: buildConnector.Options, callback: buildConnector.Callback): void;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/client-stats.d.ts
+declare class ClientStats {
+  constructor(pool: Client);
+  /** If socket has open connection. */
+  connected: boolean;
+  /** Number of open socket connections in this client that do not have an active request. */
+  pending: number;
+  /** Number of currently active requests of this client. */
+  running: number;
+  /** Number of active, pending, or queued requests of this client. */
+  size: number;
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/client.d.ts
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+/**
+ * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
+ */
+declare class Client extends Dispatcher {
+  constructor(url: string | URL$1, options?: Client.Options);
+  /** Property to get and set the pipelining factor. */
+  pipelining: number;
+  /** `true` after `client.close()` has been called. */
+  closed: boolean;
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean;
+  /** Aggregate stats for a Client. */
+  readonly stats: ClientStats; // Override dispatcher APIs.
+  override connect(options: ClientConnectOptions): Promise<Dispatcher.ConnectData>;
+  override connect(options: ClientConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+declare namespace Client {
+  export interface OptionsInterceptors {
+    Client: readonly Dispatcher.DispatchInterceptor[];
+  }
+  export interface Options {
+    /** TODO */
+    interceptors?: OptionsInterceptors;
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
+    socketTimeout?: never;
+    /** @deprecated unsupported requestTimeout, use headersTimeout & bodyTimeout instead */
+    requestTimeout?: never;
+    /** TODO */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
+    idleTimeout?: never;
+    /** @deprecated unsupported keepAlive, use pipelining=0 instead */
+    keepAlive?: never;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** @deprecated unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead */
+    maxKeepAliveTimeout?: never;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** TODO */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** @deprecated use the connect option instead */
+    tls?: never;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** TODO */
+    maxCachedSessions?: number;
+    /** TODO */
+    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    /** TODO */
+    maxRequestsPerClient?: number;
+    /** TODO */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
+     * @default false
+     */
+    allowH2?: boolean;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+     */
+    maxConcurrentStreams?: number;
+    /**
+     * @description Sets the HTTP/2 stream-level flow-control window size (SETTINGS_INITIAL_WINDOW_SIZE).
+     * @default 262144
+     */
+    initialWindowSize?: number;
+    /**
+     * @description Sets the HTTP/2 connection-level flow-control window size (ClientHttp2Session.setLocalWindowSize).
+     * @default 524288
+     */
+    connectionWindowSize?: number;
+    /**
+     * @description Time interval between PING frames dispatch
+     * @default 60000
+     */
+    pingInterval?: number;
+  }
+  export interface SocketInfo {
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    timeout?: number;
+    bytesWritten?: number;
+    bytesRead?: number;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/errors.d.ts
+declare namespace Errors {
+  export class UndiciError extends Error {
+    name: string;
+    code: string;
+  }
+  /** Connect timeout error. */
+  export class ConnectTimeoutError extends UndiciError {
+    name: 'ConnectTimeoutError';
+    code: 'UND_ERR_CONNECT_TIMEOUT';
+  }
+  /** A header exceeds the `headersTimeout` option. */
+  export class HeadersTimeoutError extends UndiciError {
+    name: 'HeadersTimeoutError';
+    code: 'UND_ERR_HEADERS_TIMEOUT';
+  }
+  /** Headers overflow error. */
+  export class HeadersOverflowError extends UndiciError {
+    name: 'HeadersOverflowError';
+    code: 'UND_ERR_HEADERS_OVERFLOW';
+  }
+  /** A body exceeds the `bodyTimeout` option. */
+  export class BodyTimeoutError extends UndiciError {
+    name: 'BodyTimeoutError';
+    code: 'UND_ERR_BODY_TIMEOUT';
+  }
+  export class ResponseError extends UndiciError {
+    constructor(message: string, code: number, options: {
+      headers?: IncomingHttpHeaders | string[] | null;
+      body?: null | Record<string, any> | string;
+    });
+    name: 'ResponseError';
+    code: 'UND_ERR_RESPONSE';
+    statusCode: number;
+    body: null | Record<string, any> | string;
+    headers: IncomingHttpHeaders | string[] | null;
+  }
+  /** Passed an invalid argument. */
+  export class InvalidArgumentError extends UndiciError {
+    name: 'InvalidArgumentError';
+    code: 'UND_ERR_INVALID_ARG';
+  }
+  /** Returned an invalid value. */
+  export class InvalidReturnValueError extends UndiciError {
+    name: 'InvalidReturnValueError';
+    code: 'UND_ERR_INVALID_RETURN_VALUE';
+  }
+  /** The request has been aborted by the user. */
+  export class RequestAbortedError extends UndiciError {
+    name: 'AbortError';
+    code: 'UND_ERR_ABORTED';
+  }
+  /** Expected error with reason. */
+  export class InformationalError extends UndiciError {
+    name: 'InformationalError';
+    code: 'UND_ERR_INFO';
+  }
+  /** Request body length does not match content-length header. */
+  export class RequestContentLengthMismatchError extends UndiciError {
+    name: 'RequestContentLengthMismatchError';
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Response body length does not match content-length header. */
+  export class ResponseContentLengthMismatchError extends UndiciError {
+    name: 'ResponseContentLengthMismatchError';
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+  }
+  /** Trying to use a destroyed client. */
+  export class ClientDestroyedError extends UndiciError {
+    name: 'ClientDestroyedError';
+    code: 'UND_ERR_DESTROYED';
+  }
+  /** Trying to use a closed client. */
+  export class ClientClosedError extends UndiciError {
+    name: 'ClientClosedError';
+    code: 'UND_ERR_CLOSED';
+  }
+  /** There is an error with the socket. */
+  export class SocketError extends UndiciError {
+    name: 'SocketError';
+    code: 'UND_ERR_SOCKET';
+    socket: Client.SocketInfo | null;
+  }
+  /** Encountered unsupported functionality. */
+  export class NotSupportedError extends UndiciError {
+    name: 'NotSupportedError';
+    code: 'UND_ERR_NOT_SUPPORTED';
+  }
+  /** No upstream has been added to the BalancedPool. */
+  export class BalancedPoolMissingUpstreamError extends UndiciError {
+    name: 'MissingUpstreamError';
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+  }
+  export class HTTPParserError extends UndiciError {
+    name: 'HTTPParserError';
+    code: string;
+  }
+  /** The response exceed the length allowed. */
+  export class ResponseExceededMaxSizeError extends UndiciError {
+    name: 'ResponseExceededMaxSizeError';
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+  }
+  export class RequestRetryError extends UndiciError {
+    constructor(message: string, statusCode: number, headers?: IncomingHttpHeaders | string[] | null, body?: null | Record<string, any> | string);
+    name: 'RequestRetryError';
+    code: 'UND_ERR_REQ_RETRY';
+    statusCode: number;
+    data: {
+      count: number;
+    };
+    headers: Record<string, string | string[]>;
+  }
+  export class SecureProxyConnectionError extends UndiciError {
+    constructor(cause?: Error, message?: string, options?: Record<any, any>);
+    name: 'SecureProxyConnectionError';
+    code: 'UND_ERR_PRX_TLS';
+  }
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError';
+    code: 'UND_ERR_MAX_ORIGINS_REACHED';
+  }
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor(message?: string, code?: string);
+    name: 'Socks5ProxyError';
+    code: string;
+  }
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError';
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED';
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/dispatcher.d.ts
+type AbortSignal$1 = unknown;
+type UndiciHeaders = Record<string, string | string[]> | IncomingHttpHeaders | string[] | Iterable<[string, string | string[] | undefined]> | null;
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+  /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+  dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+  /** Starts two-way communications with the requested resource. */
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ConnectData<TOpaque>) => void): void;
+  connect<TOpaque = null>(options: Dispatcher.ConnectOptions<TOpaque>): Promise<Dispatcher.ConnectData<TOpaque>>;
+  /** Compose a chain of dispatchers */
+  compose(dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  compose(...dispatchers: Dispatcher.DispatcherComposeInterceptor[]): Dispatcher.ComposedDispatcher;
+  /** Performs an HTTP request. */
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, callback: (err: Error | null, data: Dispatcher.ResponseData<TOpaque>) => void): void;
+  request<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>): Promise<Dispatcher.ResponseData<TOpaque>>;
+  /** For easy use with `stream.pipeline`. */
+  pipeline<TOpaque = null>(options: Dispatcher.PipelineOptions<TOpaque>, handler: Dispatcher.PipelineHandler<TOpaque>): Duplex;
+  /** A faster version of `Dispatcher.request`. */
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>, callback: (err: Error | null, data: Dispatcher.StreamData<TOpaque>) => void): void;
+  stream<TOpaque = null>(options: Dispatcher.RequestOptions<TOpaque>, factory: Dispatcher.StreamFactory<TOpaque>): Promise<Dispatcher.StreamData<TOpaque>>;
+  /** Upgrade to a different protocol. */
+  upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+  upgrade(options: Dispatcher.UpgradeOptions): Promise<Dispatcher.UpgradeData>;
+  /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+  close(callback: () => void): void;
+  close(): Promise<void>;
+  /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+  destroy(err: Error | null, callback: () => void): void;
+  destroy(callback: () => void): void;
+  destroy(err: Error | null): Promise<void>;
+  destroy(): Promise<void>;
+  on(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  on(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  on(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  once(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  once(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  once(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  off(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  off(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  off(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  addListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  addListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  addListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  removeListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  removeListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  removeListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  prependOnceListener(eventName: 'connect', callback: (origin: URL$1, targets: readonly Dispatcher[]) => void): this;
+  prependOnceListener(eventName: 'disconnect', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'connectionError', callback: (origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+  prependOnceListener(eventName: 'drain', callback: (origin: URL$1) => void): this;
+  listeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  listeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  listeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  rawListeners(eventName: 'connect'): ((origin: URL$1, targets: readonly Dispatcher[]) => void)[];
+  rawListeners(eventName: 'disconnect'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'connectionError'): ((origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+  rawListeners(eventName: 'drain'): ((origin: URL$1) => void)[];
+  emit(eventName: 'connect', origin: URL$1, targets: readonly Dispatcher[]): boolean;
+  emit(eventName: 'disconnect', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'connectionError', origin: URL$1, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+  emit(eventName: 'drain', origin: URL$1): boolean;
+}
+declare namespace Dispatcher {
+  export interface ComposedDispatcher extends Dispatcher {}
+  export type Dispatch = Dispatcher['dispatch'];
+  export type DispatcherComposeInterceptor = (dispatch: Dispatch) => Dispatch;
+  export interface DispatchOptions {
+    origin?: string | URL$1;
+    path: string;
+    method: HttpMethod;
+    /** Default: `null` */
+    body?: string | Buffer | Uint8Array | Readable | null | FormData;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Query string params to be embedded in the request URL. Default: `null` */
+    query?: Record<string, any>;
+    /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+    idempotent?: boolean;
+    /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
+    blocking?: boolean;
+    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. Default: `0` */
+    typeOfService?: number | null;
+    /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+    upgrade?: boolean | string | null;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+    headersTimeout?: number | null;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+    bodyTimeout?: number | null;
+    /** Whether the request should stablish a keep-alive or not. Default `false` */
+    reset?: boolean;
+    /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
+    throwOnError?: boolean;
+    /** For H2, it appends the expect: 100-continue header, and halts the request body until a 100-continue is received from the remote server */
+    expectContinue?: boolean;
+  }
+  export interface ConnectOptions<TOpaque = null> {
+    origin: string | URL$1;
+    path: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** This argument parameter is passed through to `ConnectData` */
+    opaque?: TOpaque;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface RequestOptions<TOpaque = null> extends DispatchOptions {
+    /** Default: `null` */
+    opaque?: TOpaque;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    onInfo?: (info: {
+      statusCode: number;
+      headers: Record<string, string | string[]>;
+    }) => void;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+    /** Default: `64 KiB` */
+    highWaterMark?: number;
+  }
+  export interface PipelineOptions<TOpaque = null> extends RequestOptions<TOpaque> {
+    /** `true` if the `handler` will return an object stream. Default: `false` */
+    objectMode?: boolean;
+  }
+  export interface UpgradeOptions {
+    path: string;
+    /** Default: `'GET'` */
+    method?: string;
+    /** Default: `null` */
+    headers?: UndiciHeaders;
+    /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+    protocol?: string;
+    /** Default: `null` */
+    signal?: AbortSignal$1 | EventEmitter | null;
+    /** Default: false */
+    redirectionLimitReached?: boolean;
+    /** Default: `null` */
+    responseHeaders?: 'raw' | null;
+  }
+  export interface ConnectData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface ResponseData<TOpaque = null> {
+    statusCode: number;
+    statusText: string;
+    headers: IncomingHttpHeaders;
+    body: BodyReadable & BodyMixin;
+    trailers: Record<string, string>;
+    opaque: TOpaque;
+    context: object;
+  }
+  export interface PipelineHandlerData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    body: BodyReadable;
+    context: object;
+  }
+  export interface StreamData<TOpaque = null> {
+    opaque: TOpaque;
+    trailers: Record<string, string>;
+  }
+  export interface UpgradeData<TOpaque = null> {
+    headers: IncomingHttpHeaders;
+    socket: Duplex;
+    opaque: TOpaque;
+  }
+  export interface StreamFactoryData<TOpaque = null> {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    opaque: TOpaque;
+    context: object;
+  }
+  export type StreamFactory<TOpaque = null> = (data: StreamFactoryData<TOpaque>) => Writable;
+  export interface DispatchController {
+    get aborted(): boolean;
+    get paused(): boolean;
+    get reason(): Error | null;
+    abort(reason: Error): void;
+    pause(): void;
+    resume(): void;
+  }
+  export interface DispatchHandler {
+    onRequestStart?(controller: DispatchController, context: any): void;
+    onRequestUpgrade?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, socket: Duplex): void;
+    onResponseStart?(controller: DispatchController, statusCode: number, headers: IncomingHttpHeaders, statusMessage?: string): void;
+    onResponseData?(controller: DispatchController, chunk: Buffer): void;
+    onResponseEnd?(controller: DispatchController, trailers: IncomingHttpHeaders): void;
+    onResponseError?(controller: DispatchController, error: Error): void;
+    /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
+    /** @deprecated */
+    onConnect?(abort: (err?: Error) => void): void;
+    /** Invoked when an error has occurred. */
+    /** @deprecated */
+    onError?(err: Error): void;
+    /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
+    /** @deprecated */
+    onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
+    /** Invoked when response is received, before headers have been read. **/
+    /** @deprecated */
+    onResponseStarted?(): void;
+    /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
+    /** @deprecated */
+    onHeaders?(statusCode: number, headers: Buffer[], resume: () => void, statusText: string): boolean;
+    /** Invoked when response payload data is received. */
+    /** @deprecated */
+    onData?(chunk: Buffer): boolean;
+    /** Invoked when response payload and trailers have been received and the request has completed. */
+    /** @deprecated */
+    onComplete?(trailers: string[] | null): void;
+    /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+    /** @deprecated */
+    onBodySent?(chunkSize: number, totalBytesSent: number): void;
+  }
+  export type PipelineHandler<TOpaque = null> = (data: PipelineHandlerData<TOpaque>) => Readable;
+  export type HttpMethod = Autocomplete<'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH'>;
+  /**
+   * @link https://fetch.spec.whatwg.org/#body-mixin
+   */
+  interface BodyMixin {
+    readonly body?: never;
+    readonly bodyUsed: boolean;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
+    formData(): Promise<never>;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+  }
+  export interface DispatchInterceptor {
+    (dispatch: Dispatch): Dispatch;
+  }
+}
+//#endregion
+//#region node_modules/.pnpm/undici-types@7.24.6/node_modules/undici-types/mock-interceptor.d.ts
+/** The scope associated with a mock dispatch. */
+declare class MockScope<TData extends object = object> {
+  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  /** Delay a reply by a set amount of time in ms. */
+  delay(waitInMs: number): MockScope<TData>;
+  /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
+  persist(): MockScope<TData>;
+  /** Define a reply for a set amount of matching requests. */
+  times(repeatTimes: number): MockScope<TData>;
+}
+/** The interceptor for a Mock. */
+declare class MockInterceptor {
+  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  /** Mock an undici request with the defined reply. */
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor.MockResponseOptions): MockScope<TData>;
+  /** Mock an undici request by throwing the defined reply error. */
+  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  /** Set default reply headers on the interceptor for subsequent mocked replies. */
+  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  /** Set default reply trailers on the interceptor for subsequent mocked replies. */
+  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  /** Set automatically calculated content-length header on subsequent mocked replies. */
+  replyContentLength(): MockInterceptor;
+}
+declare namespace MockInterceptor {
+  /** MockInterceptor options. */
+  export interface Options {
+    /** Path to intercept on. */
+    path: string | RegExp | ((path: string) => boolean);
+    /** Method to intercept on. Defaults to GET. */
+    method?: string | RegExp | ((method: string) => boolean);
+    /** Body to intercept on. */
+    body?: string | RegExp | ((body: string) => boolean);
+    /** Headers to intercept on. */
+    headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+    /** Query params to intercept on */
+    query?: Record<string, any>;
+  }
+  export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+    times: number | null;
+    persist: boolean;
+    consumed: boolean;
+    data: MockDispatchData<TData, TError>;
+  }
+  export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+    error: TError | null;
+    statusCode?: number;
+    data?: TData | string;
+  }
+  export interface MockResponseOptions {
+    headers?: IncomingHttpHeaders;
+    trailers?: Record<string, string>;
+  }
+  export interface MockResponseCallbackOptions {
+    path: string;
+    method: string;
+    headers?: Headers | Record<string, string>;
+    origin?: string;
+    body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+  }
+  export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+  export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => {
+    statusCode: number;
+    data?: TData | Buffer | string;
+    responseOptions?: MockResponseOptions;
+  };
+}
+//#endregion
+//#region node_modules/.pnpm/@x402+svm@2.8.0_@solana+kit@6.5.0_typescript@5.9.3__@solana+sysvars@6.5.0_typescript@5.9.3_/node_modules/@x402/svm/dist/esm/signer-BMkbhFYE.d.mts
+/**
+ * Client-side signer for creating and signing Solana transactions
+ * This is a wrapper around TransactionSigner from @solana/kit
+ */
+type ClientSvmSigner = TransactionSigner;
+/**
+ * Configuration for client operations
+ */
+type ClientSvmConfig = {
+  /**
+   * Optional custom RPC URL for the client to use
+   */
+  rpcUrl?: string;
+};
+/**
+ * RPC client type from @solana/kit
+ * Can be devnet, testnet, or mainnet RPC client
+ */
+//#endregion
+//#region node_modules/.pnpm/@x402+svm@2.8.0_@solana+kit@6.5.0_typescript@5.9.3__@solana+sysvars@6.5.0_typescript@5.9.3_/node_modules/@x402/svm/dist/esm/scheme-fjF-9LhT.d.mts
+/**
+ * SVM client implementation for the Exact payment scheme.
+ */
+declare class ExactSvmScheme implements SchemeNetworkClient {
+  private readonly signer;
+  private readonly config?;
+  readonly scheme = "exact";
+  /**
+   * Creates a new ExactSvmClient instance.
+   *
+   * @param signer - The SVM signer for client operations
+   * @param config - Optional configuration with custom RPC URL
+   * @returns ExactSvmClient instance
+   */
+  constructor(signer: ClientSvmSigner, config?: ClientSvmConfig | undefined);
+  /**
+   * Creates a payment payload for the Exact scheme.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements
+   * @returns Promise resolving to a payment payload
+   */
+  createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+}
+//#endregion
+//#region packages/x402-proxy/src/handler.d.ts
 type PaymentInfo = {
   protocol: "x402";
   network: string | undefined;
@@ -27,7 +1921,7 @@ type MppPaymentInfo = {
   };
 };
 type X402ProxyOptions = {
-  client: x402Client$1;
+  client: x402Client;
 };
 type X402ProxyHandler = {
   /** Wrapped fetch with x402 payment handling */x402Fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>; /** Shift the latest payment info from the queue (call after x402Fetch) */
@@ -67,7 +1961,7 @@ declare function createMppProxyHandler(opts: {
   maxDeposit?: string;
 }): Promise<MppProxyHandler>;
 //#endregion
-//#region src/history.d.ts
+//#region packages/x402-proxy/src/history.d.ts
 declare const HISTORY_MAX_LINES = 1000;
 declare const HISTORY_KEEP_LINES = 500;
 type TxRecord = {
@@ -105,7 +1999,7 @@ declare function formatTxLine(r: TxRecord, opts?: {
   verbose?: boolean;
 }): string;
 //#endregion
-//#region src/wallet.d.ts
+//#region packages/x402-proxy/src/wallet.d.ts
 /**
  * Load a Solana keypair from a solana-keygen JSON file.
  * Format: JSON array of 64 numbers [32 secret bytes + 32 public bytes].
@@ -115,6 +2009,6 @@ declare function loadSvmWallet(keypairPath: string): Promise<KeyPairSigner>;
  * Load an EVM wallet from a hex private key file.
  * Format: 0x-prefixed hex string (66 chars) or raw hex (64 chars).
  */
-declare function loadEvmWallet(keyPath: string): ClientEvmSigner$1;
+declare function loadEvmWallet(keyPath: string): ClientEvmSigner;
 //#endregion
 export { type ClientEvmSigner, type DetectedProtocols, ExactEvmScheme, ExactSvmScheme, HISTORY_KEEP_LINES, HISTORY_MAX_LINES, type MppPaymentInfo, type MppProxyHandler, type PaymentInfo, TEMPO_NETWORK, type TxRecord, type X402ProxyHandler, type X402ProxyOptions, appendHistory, calcSpend, createMppProxyHandler, createX402ProxyHandler, detectProtocols, explorerUrl, extractTxSignature, formatTxLine, loadEvmWallet, loadSvmWallet, readHistory, toClientEvmSigner, x402Client };