@opendatalabs/vana-sdk 0.1.0-alpha.ffe4659 → 2.0.0

package/dist/core/client.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  createClient: () => createClient,
+  createWalletClient: () => createWalletClient,
+  defaultFromBlocks: () => defaultFromBlocks,
+  getDefaultFromBlock: () => getDefaultFromBlock
+});
+module.exports = __toCommonJS(client_exports);
+var import_viem = require("viem");
+var import_chains = require("../config/chains");
+const defaultFromBlocks = {
+  14800: 732312n,
+  // Moksha Testnet - earliest contract deployment
+  1480: 758584n
+  // Vana Mainnet - earliest contract deployment
+};
+function getDefaultFromBlock(chainId) {
+  return defaultFromBlocks[chainId] || 0n;
+}
+let cachedClient;
+const createClient = (chainId = import_chains.mokshaTestnet.id) => {
+  if (!cachedClient || cachedClient.chain?.id !== chainId) {
+    const chain = import_chains.chains[chainId];
+    if (!chain) {
+      throw new Error(`Chain ${chainId} not found`);
+    }
+    cachedClient = (0, import_viem.createPublicClient)({
+      chain,
+      transport: (0, import_viem.http)()
+    });
+  }
+  return cachedClient;
+};
+const createWalletClient = (chainId = import_chains.mokshaTestnet.id, account) => {
+  const chain = import_chains.chains[chainId];
+  if (!chain) {
+    throw new Error(`Chain ${chainId} not found`);
+  }
+  return (0, import_viem.createWalletClient)({
+    chain,
+    transport: (0, import_viem.http)(),
+    account
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClient,
+  createWalletClient,
+  defaultFromBlocks,
+  getDefaultFromBlock
+});
+//# sourceMappingURL=client.cjs.map

package/dist/core/client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/client.ts"],"sourcesContent":["import type { Chain, Account, PublicClient, WalletClient } from \"viem\";\nimport {\n  createPublicClient,\n  http,\n  createWalletClient as viemCreateWalletClient,\n} from \"viem\";\nimport { chains, mokshaTestnet } from \"../config/chains\";\n\n/**\n * Default starting block numbers for querying blockchain events and data per chain.\n *\n * @remarks\n * These block numbers represent the earliest deployment of Vana protocol contracts\n * on each network. Using these as starting points for event queries significantly\n * improves performance by avoiding unnecessary queries of blocks before the\n * protocol existed.\n *\n * - Moksha Testnet (14800): Block 732312 - DataRegistry deployment\n * - Vana Mainnet (1480): Block 758584 - DataRegistry deployment\n *\n * @category Blockchain\n */\nexport const defaultFromBlocks: Record<number, bigint> = {\n  14800: 732312n, // Moksha Testnet - earliest contract deployment\n  1480: 758584n, // Vana Mainnet - earliest contract deployment\n};\n\n/**\n * Gets the default starting block for a specific chain.\n *\n * @param chainId - The chain ID to get the default from block for\n * @returns The default starting block for the chain, or 0n if not configured\n * @category Blockchain\n */\nexport function getDefaultFromBlock(chainId: number): bigint {\n  return defaultFromBlocks[chainId] || 0n;\n}\n\n// Cache for clients\nlet cachedClient: PublicClient & { chain: Chain };\n\n/**\n * Creates or retrieves a cached public client for blockchain read operations.\n *\n * @remarks\n * This function provides an optimized way to access blockchain data by maintaining\n * a cached client instance per chain. The client is used for reading contract state,\n * querying events, and other read-only blockchain operations. It automatically\n * handles HTTP transport configuration and chain switching.\n *\n * @param chainId - The chain ID to connect to (defaults to Moksha testnet)\n * @returns A public client configured for the specified chain with caching optimization\n * @throws {Error} When the specified chain ID is not supported by the SDK\n * @example\n * ```typescript\n * // Get client for default chain (Moksha testnet)\n * const client = createClient();\n *\n * // Get client for specific chain\n * const mainnetClient = createClient(14800);\n *\n * // Use client for blockchain reads\n * const blockNumber = await client.getBlockNumber();\n * ```\n * @category Blockchain\n */\nexport const createClient = (\n  chainId: keyof typeof chains = mokshaTestnet.id,\n): PublicClient & { chain: Chain } => {\n  if (!cachedClient || cachedClient.chain?.id !== chainId) {\n    const chain = chains[chainId];\n    if (!chain) {\n      throw new Error(`Chain ${chainId} not found`);\n    }\n\n    cachedClient = createPublicClient({\n      chain,\n      transport: http(),\n    });\n  }\n\n  return cachedClient;\n};\n\n/**\n * Creates a wallet client for blockchain transaction signing and submission.\n *\n * @remarks\n * This function creates a wallet client configured for transaction signing and\n * submission on the specified chain. Unlike the public client, wallet clients\n * are not cached and require an account for transaction signing. The client\n * handles HTTP transport configuration and provides access to wallet-specific\n * operations like signing transactions and messages.\n *\n * @param chainId - The chain ID to connect to (defaults to Moksha testnet)\n * @param account - Optional account for transaction signing (can be set later)\n * @returns A wallet client configured for the specified chain\n * @throws {Error} When the specified chain ID is not supported by the SDK\n * @example\n * ```typescript\n * import { privateKeyToAccount } from 'viem/accounts';\n *\n * // Create wallet client for default chain\n * const account = privateKeyToAccount('0x...');\n * const walletClient = createWalletClient(mokshaTestnet.id, account);\n *\n * // Use for transaction signing\n * const txHash = await walletClient.writeContract({\n *   address: contractAddress,\n *   abi: contractAbi,\n *   functionName: 'someFunction',\n *   args: []\n * });\n *\n * // Create without account (account can be set later)\n * const client = createWalletClient();\n * ```\n * @category Blockchain\n */\nexport const createWalletClient = (\n  chainId: keyof typeof chains = mokshaTestnet.id,\n  account?: Account,\n): WalletClient => {\n  const chain = chains[chainId];\n  if (!chain) {\n    throw new Error(`Chain ${chainId} not found`);\n  }\n\n  return viemCreateWalletClient({\n    chain,\n    transport: http(),\n    account,\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAIO;AACP,oBAAsC;AAgB/B,MAAM,oBAA4C;AAAA,EACvD,OAAO;AAAA;AAAA,EACP,MAAM;AAAA;AACR;AASO,SAAS,oBAAoB,SAAyB;AAC3D,SAAO,kBAAkB,OAAO,KAAK;AACvC;AAGA,IAAI;AA2BG,MAAM,eAAe,CAC1B,UAA+B,4BAAc,OACT;AACpC,MAAI,CAAC,gBAAgB,aAAa,OAAO,OAAO,SAAS;AACvD,UAAM,QAAQ,qBAAO,OAAO;AAC5B,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,SAAS,OAAO,YAAY;AAAA,IAC9C;AAEA,uBAAe,gCAAmB;AAAA,MAChC;AAAA,MACA,eAAW,kBAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAqCO,MAAM,qBAAqB,CAChC,UAA+B,4BAAc,IAC7C,YACiB;AACjB,QAAM,QAAQ,qBAAO,OAAO;AAC5B,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,SAAS,OAAO,YAAY;AAAA,EAC9C;AAEA,aAAO,YAAAA,oBAAuB;AAAA,IAC5B;AAAA,IACA,eAAW,kBAAK;AAAA,IAChB;AAAA,EACF,CAAC;AACH;","names":["viemCreateWalletClient"]}

package/dist/core/client.d.ts

@@ -0,0 +1,89 @@
+import type { Chain, Account, PublicClient, WalletClient } from "viem";
+import { chains } from "../config/chains";
+/**
+ * Default starting block numbers for querying blockchain events and data per chain.
+ *
+ * @remarks
+ * These block numbers represent the earliest deployment of Vana protocol contracts
+ * on each network. Using these as starting points for event queries significantly
+ * improves performance by avoiding unnecessary queries of blocks before the
+ * protocol existed.
+ *
+ * - Moksha Testnet (14800): Block 732312 - DataRegistry deployment
+ * - Vana Mainnet (1480): Block 758584 - DataRegistry deployment
+ *
+ * @category Blockchain
+ */
+export declare const defaultFromBlocks: Record<number, bigint>;
+/**
+ * Gets the default starting block for a specific chain.
+ *
+ * @param chainId - The chain ID to get the default from block for
+ * @returns The default starting block for the chain, or 0n if not configured
+ * @category Blockchain
+ */
+export declare function getDefaultFromBlock(chainId: number): bigint;
+/**
+ * Creates or retrieves a cached public client for blockchain read operations.
+ *
+ * @remarks
+ * This function provides an optimized way to access blockchain data by maintaining
+ * a cached client instance per chain. The client is used for reading contract state,
+ * querying events, and other read-only blockchain operations. It automatically
+ * handles HTTP transport configuration and chain switching.
+ *
+ * @param chainId - The chain ID to connect to (defaults to Moksha testnet)
+ * @returns A public client configured for the specified chain with caching optimization
+ * @throws {Error} When the specified chain ID is not supported by the SDK
+ * @example
+ * ```typescript
+ * // Get client for default chain (Moksha testnet)
+ * const client = createClient();
+ *
+ * // Get client for specific chain
+ * const mainnetClient = createClient(14800);
+ *
+ * // Use client for blockchain reads
+ * const blockNumber = await client.getBlockNumber();
+ * ```
+ * @category Blockchain
+ */
+export declare const createClient: (chainId?: keyof typeof chains) => PublicClient & {
+    chain: Chain;
+};
+/**
+ * Creates a wallet client for blockchain transaction signing and submission.
+ *
+ * @remarks
+ * This function creates a wallet client configured for transaction signing and
+ * submission on the specified chain. Unlike the public client, wallet clients
+ * are not cached and require an account for transaction signing. The client
+ * handles HTTP transport configuration and provides access to wallet-specific
+ * operations like signing transactions and messages.
+ *
+ * @param chainId - The chain ID to connect to (defaults to Moksha testnet)
+ * @param account - Optional account for transaction signing (can be set later)
+ * @returns A wallet client configured for the specified chain
+ * @throws {Error} When the specified chain ID is not supported by the SDK
+ * @example
+ * ```typescript
+ * import { privateKeyToAccount } from 'viem/accounts';
+ *
+ * // Create wallet client for default chain
+ * const account = privateKeyToAccount('0x...');
+ * const walletClient = createWalletClient(mokshaTestnet.id, account);
+ *
+ * // Use for transaction signing
+ * const txHash = await walletClient.writeContract({
+ *   address: contractAddress,
+ *   abi: contractAbi,
+ *   functionName: 'someFunction',
+ *   args: []
+ * });
+ *
+ * // Create without account (account can be set later)
+ * const client = createWalletClient();
+ * ```
+ * @category Blockchain
+ */
+export declare const createWalletClient: (chainId?: keyof typeof chains, account?: Account) => WalletClient;

package/dist/core/client.js

@@ -0,0 +1,47 @@
+import {
+  createPublicClient,
+  http,
+  createWalletClient as viemCreateWalletClient
+} from "viem";
+import { chains, mokshaTestnet } from "../config/chains";
+const defaultFromBlocks = {
+  14800: 732312n,
+  // Moksha Testnet - earliest contract deployment
+  1480: 758584n
+  // Vana Mainnet - earliest contract deployment
+};
+function getDefaultFromBlock(chainId) {
+  return defaultFromBlocks[chainId] || 0n;
+}
+let cachedClient;
+const createClient = (chainId = mokshaTestnet.id) => {
+  if (!cachedClient || cachedClient.chain?.id !== chainId) {
+    const chain = chains[chainId];
+    if (!chain) {
+      throw new Error(`Chain ${chainId} not found`);
+    }
+    cachedClient = createPublicClient({
+      chain,
+      transport: http()
+    });
+  }
+  return cachedClient;
+};
+const createWalletClient = (chainId = mokshaTestnet.id, account) => {
+  const chain = chains[chainId];
+  if (!chain) {
+    throw new Error(`Chain ${chainId} not found`);
+  }
+  return viemCreateWalletClient({
+    chain,
+    transport: http(),
+    account
+  });
+};
+export {
+  createClient,
+  createWalletClient,
+  defaultFromBlocks,
+  getDefaultFromBlock
+};
+//# sourceMappingURL=client.js.map

package/dist/core/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/client.ts"],"sourcesContent":["import type { Chain, Account, PublicClient, WalletClient } from \"viem\";\nimport {\n  createPublicClient,\n  http,\n  createWalletClient as viemCreateWalletClient,\n} from \"viem\";\nimport { chains, mokshaTestnet } from \"../config/chains\";\n\n/**\n * Default starting block numbers for querying blockchain events and data per chain.\n *\n * @remarks\n * These block numbers represent the earliest deployment of Vana protocol contracts\n * on each network. Using these as starting points for event queries significantly\n * improves performance by avoiding unnecessary queries of blocks before the\n * protocol existed.\n *\n * - Moksha Testnet (14800): Block 732312 - DataRegistry deployment\n * - Vana Mainnet (1480): Block 758584 - DataRegistry deployment\n *\n * @category Blockchain\n */\nexport const defaultFromBlocks: Record<number, bigint> = {\n  14800: 732312n, // Moksha Testnet - earliest contract deployment\n  1480: 758584n, // Vana Mainnet - earliest contract deployment\n};\n\n/**\n * Gets the default starting block for a specific chain.\n *\n * @param chainId - The chain ID to get the default from block for\n * @returns The default starting block for the chain, or 0n if not configured\n * @category Blockchain\n */\nexport function getDefaultFromBlock(chainId: number): bigint {\n  return defaultFromBlocks[chainId] || 0n;\n}\n\n// Cache for clients\nlet cachedClient: PublicClient & { chain: Chain };\n\n/**\n * Creates or retrieves a cached public client for blockchain read operations.\n *\n * @remarks\n * This function provides an optimized way to access blockchain data by maintaining\n * a cached client instance per chain. The client is used for reading contract state,\n * querying events, and other read-only blockchain operations. It automatically\n * handles HTTP transport configuration and chain switching.\n *\n * @param chainId - The chain ID to connect to (defaults to Moksha testnet)\n * @returns A public client configured for the specified chain with caching optimization\n * @throws {Error} When the specified chain ID is not supported by the SDK\n * @example\n * ```typescript\n * // Get client for default chain (Moksha testnet)\n * const client = createClient();\n *\n * // Get client for specific chain\n * const mainnetClient = createClient(14800);\n *\n * // Use client for blockchain reads\n * const blockNumber = await client.getBlockNumber();\n * ```\n * @category Blockchain\n */\nexport const createClient = (\n  chainId: keyof typeof chains = mokshaTestnet.id,\n): PublicClient & { chain: Chain } => {\n  if (!cachedClient || cachedClient.chain?.id !== chainId) {\n    const chain = chains[chainId];\n    if (!chain) {\n      throw new Error(`Chain ${chainId} not found`);\n    }\n\n    cachedClient = createPublicClient({\n      chain,\n      transport: http(),\n    });\n  }\n\n  return cachedClient;\n};\n\n/**\n * Creates a wallet client for blockchain transaction signing and submission.\n *\n * @remarks\n * This function creates a wallet client configured for transaction signing and\n * submission on the specified chain. Unlike the public client, wallet clients\n * are not cached and require an account for transaction signing. The client\n * handles HTTP transport configuration and provides access to wallet-specific\n * operations like signing transactions and messages.\n *\n * @param chainId - The chain ID to connect to (defaults to Moksha testnet)\n * @param account - Optional account for transaction signing (can be set later)\n * @returns A wallet client configured for the specified chain\n * @throws {Error} When the specified chain ID is not supported by the SDK\n * @example\n * ```typescript\n * import { privateKeyToAccount } from 'viem/accounts';\n *\n * // Create wallet client for default chain\n * const account = privateKeyToAccount('0x...');\n * const walletClient = createWalletClient(mokshaTestnet.id, account);\n *\n * // Use for transaction signing\n * const txHash = await walletClient.writeContract({\n *   address: contractAddress,\n *   abi: contractAbi,\n *   functionName: 'someFunction',\n *   args: []\n * });\n *\n * // Create without account (account can be set later)\n * const client = createWalletClient();\n * ```\n * @category Blockchain\n */\nexport const createWalletClient = (\n  chainId: keyof typeof chains = mokshaTestnet.id,\n  account?: Account,\n): WalletClient => {\n  const chain = chains[chainId];\n  if (!chain) {\n    throw new Error(`Chain ${chainId} not found`);\n  }\n\n  return viemCreateWalletClient({\n    chain,\n    transport: http(),\n    account,\n  });\n};\n"],"mappings":"AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA,sBAAsB;AAAA,OACjB;AACP,SAAS,QAAQ,qBAAqB;AAgB/B,MAAM,oBAA4C;AAAA,EACvD,OAAO;AAAA;AAAA,EACP,MAAM;AAAA;AACR;AASO,SAAS,oBAAoB,SAAyB;AAC3D,SAAO,kBAAkB,OAAO,KAAK;AACvC;AAGA,IAAI;AA2BG,MAAM,eAAe,CAC1B,UAA+B,cAAc,OACT;AACpC,MAAI,CAAC,gBAAgB,aAAa,OAAO,OAAO,SAAS;AACvD,UAAM,QAAQ,OAAO,OAAO;AAC5B,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,SAAS,OAAO,YAAY;AAAA,IAC9C;AAEA,mBAAe,mBAAmB;AAAA,MAChC;AAAA,MACA,WAAW,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAqCO,MAAM,qBAAqB,CAChC,UAA+B,cAAc,IAC7C,YACiB;AACjB,QAAM,QAAQ,OAAO,OAAO;AAC5B,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,SAAS,OAAO,YAAY;AAAA,EAC9C;AAEA,SAAO,uBAAuB;AAAA,IAC5B;AAAA,IACA,WAAW,KAAK;AAAA,IAChB;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/core/core.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/generics.cjs

@@ -0,0 +1,417 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generics_exports = {};
+__export(generics_exports, {
+  AsyncQueue: () => AsyncQueue,
+  BaseController: () => BaseController,
+  CircuitBreaker: () => CircuitBreaker,
+  EventEmitter: () => EventEmitter,
+  MemoryCache: () => MemoryCache,
+  MiddlewarePipeline: () => MiddlewarePipeline,
+  RateLimiter: () => RateLimiter,
+  RetryUtility: () => RetryUtility
+});
+module.exports = __toCommonJS(generics_exports);
+class BaseController {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Executes a request with optional middleware pipeline.
+   *
+   * @remarks
+   * Processes request through middleware chain, executes handler, and applies
+   * response middleware in reverse order. Handles errors through error middleware
+   * before failing the request.
+   *
+   * @param request - The generic request object containing parameters and metadata
+   * @param handler - The function that processes the request parameters
+   * @param middleware - Optional array of middleware functions to apply
+   * @returns Promise resolving to a generic response object
+   *
+   * @example
+   * ```typescript
+   * const response = await this.executeRequest(
+   *   { params: { id: 123 }, options: {} },
+   *   async (params) => await fetchData(params.id),
+   *   [loggingMiddleware, cachingMiddleware]
+   * );
+   * ```
+   */
+  async executeRequest(request, handler, middleware = []) {
+    try {
+      let processedRequest = request;
+      for (const mw of middleware) {
+        if (mw.request) {
+          processedRequest = await mw.request(
+            processedRequest
+          );
+        }
+      }
+      let response = await handler(processedRequest.params);
+      for (const mw of middleware.reverse()) {
+        if (mw.response) {
+          response = await mw.response(response);
+        }
+      }
+      return {
+        data: response,
+        success: true
+      };
+    } catch (error) {
+      for (const mw of middleware) {
+        if (mw.error) {
+          const handled = await mw.error(error, request);
+          if (handled) {
+            return {
+              data: handled,
+              success: true
+            };
+          }
+        }
+      }
+      return {
+        // TODO(TYPES): undefined coerced to TResponse for error case.
+        // Future improvement: Use discriminated union with success: false
+        // to properly type data as undefined when error occurs.
+        data: void 0,
+        success: false,
+        error: {
+          code: "EXECUTION_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error",
+          details: error
+        }
+      };
+    }
+  }
+  /**
+   * Validates parameters with optional custom validator.
+   *
+   * @remarks
+   * Type guard that validates and asserts parameter types at runtime.
+   * Use for input validation in public API methods.
+   *
+   * @param params - The parameters to validate
+   * @param validator - Optional function to validate parameter types
+   * @throws {Error} When validation fails.
+   *   Provide valid parameters matching expected type.
+   *
+   * @example
+   * ```typescript
+   * this.validateParams<MyParams>(params, (p): p is MyParams => {
+   *   return typeof p === 'object' && 'id' in p;
+   * });
+   * // TypeScript now knows params is MyParams
+   * ```
+   */
+  validateParams(params, validator) {
+    if (validator && !validator(params)) {
+      throw new Error("Invalid parameters");
+    }
+  }
+}
+class RetryUtility {
+  static async delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  static async withRetry(operation, config) {
+    let lastError;
+    for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (config.shouldRetry && !config.shouldRetry(lastError, attempt)) {
+          throw lastError;
+        }
+        if (attempt === config.maxAttempts) {
+          break;
+        }
+        const baseDelay = config.baseDelay * Math.pow(config.backoffMultiplier ?? 2, attempt - 1);
+        const maxDelay = config.maxDelay ?? 3e4;
+        const jitter = config.jitter ?? 0;
+        let delay = Math.min(baseDelay, maxDelay);
+        if (jitter > 0) {
+          delay += Math.random() * jitter * delay;
+        }
+        await this.delay(delay);
+      }
+    }
+    throw lastError ?? new Error("Operation failed after retries");
+  }
+}
+class RateLimiter {
+  constructor(config) {
+    this.config = config;
+  }
+  requests = [];
+  async checkLimit() {
+    const now = Date.now();
+    const windowStart = now - this.config.windowMs;
+    this.requests = this.requests.filter((time) => time > windowStart);
+    if (this.requests.length < this.config.requestsPerWindow) {
+      this.requests.push(now);
+      return true;
+    }
+    return false;
+  }
+  async waitForSlot() {
+    while (!await this.checkLimit()) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  getRemainingRequests() {
+    const now = Date.now();
+    const windowStart = now - this.config.windowMs;
+    const activeRequests = this.requests.filter((time) => time > windowStart);
+    return Math.max(0, this.config.requestsPerWindow - activeRequests.length);
+  }
+  getResetTime() {
+    if (this.requests.length === 0) return 0;
+    return Math.max(0, this.requests[0] + this.config.windowMs - Date.now());
+  }
+}
+class MemoryCache {
+  cache = /* @__PURE__ */ new Map();
+  async get(key) {
+    const item = this.cache.get(key);
+    if (!item) return void 0;
+    if (item.expiry && Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return item.value;
+  }
+  async set(key, value, ttl) {
+    const expiry = ttl ? Date.now() + ttl : void 0;
+    this.cache.set(key, { value, expiry });
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async has(key) {
+    const exists = this.cache.has(key);
+    if (!exists) return false;
+    const item = this.cache.get(key);
+    if (item?.expiry && Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  size() {
+    return this.cache.size;
+  }
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+}
+class EventEmitter {
+  observers = [];
+  subscribe(observer) {
+    this.observers.push(observer);
+    return () => {
+      this.unsubscribe(observer);
+    };
+  }
+  unsubscribe(observer) {
+    const index = this.observers.indexOf(observer);
+    if (index > -1) {
+      this.observers.splice(index, 1);
+    }
+  }
+  emit(event) {
+    for (const observer of this.observers) {
+      try {
+        const result = observer.notify(event);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error("Observer error:", error);
+          });
+        }
+      } catch (error) {
+        console.error("Observer error:", error);
+      }
+    }
+  }
+  getObserverCount() {
+    return this.observers.length;
+  }
+  removeAllObservers() {
+    this.observers = [];
+  }
+}
+class MiddlewarePipeline {
+  middleware = [];
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+  async processRequest(request) {
+    let processed = request;
+    for (const mw of this.middleware) {
+      if (mw.request) {
+        processed = await mw.request(processed);
+      }
+    }
+    return processed;
+  }
+  async processResponse(response) {
+    let processed = response;
+    for (const mw of this.middleware.slice().reverse()) {
+      if (mw.response) {
+        processed = await mw.response(processed);
+      }
+    }
+    return processed;
+  }
+  async handleError(error, request) {
+    for (const mw of this.middleware) {
+      if (mw.error) {
+        const result = await mw.error(error, request);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  getMiddleware() {
+    return [...this.middleware];
+  }
+  clear() {
+    this.middleware = [];
+  }
+}
+class AsyncQueue {
+  constructor(concurrency = 1) {
+    this.concurrency = concurrency;
+  }
+  queue = [];
+  running = 0;
+  async add(operation) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          const result = await operation();
+          resolve(result);
+          return result;
+        } catch (error) {
+          reject(error);
+          throw error;
+        } finally {
+          this.running--;
+          this.processQueue();
+        }
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.running < this.concurrency && this.queue.length > 0) {
+      const operation = this.queue.shift();
+      if (operation) {
+        this.running++;
+        operation().catch(() => {
+        });
+      }
+    }
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get active() {
+    return this.running;
+  }
+  get size() {
+    return this.queue.length + this.running;
+  }
+  clear() {
+    this.queue = [];
+  }
+}
+class CircuitBreaker {
+  constructor(config) {
+    this.config = config;
+  }
+  state = "closed";
+  failures = 0;
+  lastFailureTime = 0;
+  successes = 0;
+  async execute(operation) {
+    if (this.state === "open") {
+      if (Date.now() - this.lastFailureTime > this.config.recoveryTimeout) {
+        this.state = "half-open";
+        this.successes = 0;
+      } else {
+        throw new Error("Circuit breaker is open");
+      }
+    }
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failures = 0;
+    if (this.state === "half-open") {
+      this.successes++;
+      if (this.successes >= (this.config.halfOpenMaxAttempts ?? 1)) {
+        this.state = "closed";
+      }
+    }
+  }
+  onFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    if (this.failures >= this.config.failureThreshold) {
+      this.state = "open";
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getFailures() {
+    return this.failures;
+  }
+  reset() {
+    this.state = "closed";
+    this.failures = 0;
+    this.successes = 0;
+    this.lastFailureTime = 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncQueue,
+  BaseController,
+  CircuitBreaker,
+  EventEmitter,
+  MemoryCache,
+  MiddlewarePipeline,
+  RateLimiter,
+  RetryUtility
+});
+//# sourceMappingURL=generics.cjs.map