@sentio/runtime 2.62.2-rc.7 → 2.62.2-rc.8

package/lib/{chunk-BIFWYVK4.js → chunk-FQYIWDRC.js}

@@ -36097,12 +36097,14 @@ var require_eventemitter3 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-id.js
+// ../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-id.js
 var require_chain_id = __commonJS({
-  "../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-id.js"(exports) {
+  "../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-id.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isChainType = exports.getChainType = exports.ChainIdToType = exports.ChainTypeToChainId = exports.ChainId = exports.NonEthChainId = exports.BTCChainId = exports.StarknetChainId = exports.CosmosChainId = exports.FuelChainId = exports.SolanaChainId = exports.SuiChainId = exports.AptosChainId = exports.EthChainId = exports.ChainType = void 0;
+    exports.ChainIdToType = exports.ChainTypeToChainId = exports.ChainId = exports.NonEthChainId = exports.BTCChainId = exports.StarknetChainId = exports.CosmosChainId = exports.FuelChainId = exports.SolanaChainId = exports.SuiChainId = exports.AptosChainId = exports.EthChainId = exports.ChainType = void 0;
+    exports.getChainType = getChainType;
+    exports.isChainType = isChainType;
     var ChainType;
     (function(ChainType2) {
       ChainType2["SOLANA"] = "solana";
@@ -36156,6 +36158,8 @@ var require_chain_id = __commonJS({
       EthChainId3["MANTLE"] = "5000";
       EthChainId3["BASE"] = "8453";
       EthChainId3["MEV_COMMIT"] = "8855";
+      EthChainId3["PLASMA_MAINNET"] = "9745";
+      EthChainId3["PLASMA_TESTNET"] = "9746";
       EthChainId3["MONAD_TESTNET"] = "10143";
       EthChainId3["HOLESKY"] = "17000";
       EthChainId3["HOODI"] = "560048";
@@ -36261,7 +36265,6 @@ var require_chain_id = __commonJS({
       }
       return chainType;
     }
-    exports.getChainType = getChainType;
     function isChainType(chainId, targetChainType) {
       const id2 = String(chainId).toLowerCase();
       const chainType = exports.ChainIdToType.get(id2);
@@ -36270,16 +36273,20 @@ var require_chain_id = __commonJS({
       }
       return chainType === targetChainType;
     }
-    exports.isChainType = isChainType;
   }
 });
 
-// ../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-info.js
+// ../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-info.js
 var require_chain_info = __commonJS({
-  "../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-info.js"(exports) {
+  "../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-info.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getMainnetChain = exports.getChainLogo = exports.getSuiscanUrl = exports.getChainBlockscoutUrl = exports.getChainExternalUrl = exports.ChainInfo = exports.NonEthChainInfo = exports.CosmosChainInfo = exports.StarknetChainInfo = exports.FuelChainInfo = exports.SuiChainInfo = exports.SolanaChainInfo = exports.AptosChainInfo = exports.BTCChainInfo = exports.EthChainInfo = exports.EthVariation = exports.ExplorerApiType = void 0;
+    exports.ChainInfo = exports.NonEthChainInfo = exports.CosmosChainInfo = exports.StarknetChainInfo = exports.FuelChainInfo = exports.SuiChainInfo = exports.SolanaChainInfo = exports.AptosChainInfo = exports.BTCChainInfo = exports.EthChainInfo = exports.EthVariation = exports.ExplorerApiType = void 0;
+    exports.getChainExternalUrl = getChainExternalUrl;
+    exports.getChainBlockscoutUrl = getChainBlockscoutUrl;
+    exports.getSuiscanUrl = getSuiscanUrl;
+    exports.getChainLogo = getChainLogo;
+    exports.getMainnetChain = getMainnetChain;
     var chain_id_1 = require_chain_id();
     var ExplorerApiType;
     (function(ExplorerApiType2) {
@@ -36425,8 +36432,10 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.POLYGON,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+        // WMATIC
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
+        // WMATIC
         tokenSymbol: "MATIC",
         tokenDecimals: 18,
         explorerApiType: ExplorerApiType.ETHERSCAN_V2,
@@ -36487,6 +36496,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.MOONBEAM,
         variation: EthVariation.SUBSTRATE,
         priceTokenAddress: "0xacc15dc74880c9944775448304b263d191c6077f",
+        // WGLMR
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xacc15dc74880c9944775448304b263d191c6077f",
         tokenSymbol: "GLMR",
@@ -36502,6 +36512,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.ASTAR,
         variation: EthVariation.SUBSTRATE,
         priceTokenAddress: "0xaeaaf0e2c81af264101b9129c00f4440ccf0f720",
+        // WASTR
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xaeaaf0e2c81af264101b9129c00f4440ccf0f720",
         tokenSymbol: "ASTR",
@@ -36517,6 +36528,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.LINEA,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
+        // WETH
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f",
         tokenSymbol: "ETH",
@@ -36535,6 +36547,7 @@ var require_chain_info = __commonJS({
         priceTokenAddress: "0x0000000000000000000000000000000000000000",
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x5300000000000000000000000000000000000004",
+        // TODO questionable
         tokenSymbol: "ETH",
         tokenDecimals: 18,
         explorerUrl: "https://scrollscan.com",
@@ -36761,11 +36774,12 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.CRONOS,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x5c7f8a570d578ed84e63fdfa7b1ee72deae1ae23",
+        // WCRO
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x5c7f8a570d578ed84e63fdfa7b1ee72deae1ae23",
         tokenSymbol: "CRO",
         tokenDecimals: 18,
-        explorerUrl: "https://cronoscan.com",
+        explorerUrl: "https://explorer.cronos.org",
         explorerApiType: ExplorerApiType.ETHERSCAN_V2,
         explorerApi: "https://api.etherscan.io/v2",
         lightIcon: "https://assets.sentio.xyz/chains/cronos.svg",
@@ -36778,6 +36792,7 @@ var require_chain_info = __commonJS({
         mainnetChainId: chain_id_1.EthChainId.CRONOS,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x6a3173618859c7cd40faf6921b5e9eb6a76f1fd4",
+        // WCRO
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x6a3173618859c7cd40faf6921b5e9eb6a76f1fd4",
         tokenSymbol: "CRO",
@@ -36794,6 +36809,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.BITLAYER,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0xff204e2681a6fa0e2c3fade68a1b28fb90e4fc5f",
+        // WBTC
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xff204e2681a6fa0e2c3fade68a1b28fb90e4fc5f",
         tokenSymbol: "BTC",
@@ -36824,6 +36840,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.MANTLE,
         variation: EthVariation.OPTIMISM,
         priceTokenAddress: "0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8",
+        // WMNT
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8",
         tokenSymbol: "MNT",
@@ -36840,6 +36857,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.B2_MAINNET,
         variation: EthVariation.OPTIMISM,
         priceTokenAddress: "0x4200000000000000000000000000000000000006",
+        // WBTC
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x4200000000000000000000000000000000000006",
         tokenSymbol: "BTC",
@@ -36886,6 +36904,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.FRAXTAL,
         variation: EthVariation.OPTIMISM,
         priceTokenAddress: "0x0000000000000000000000000000000000000000",
+        // wfrxETH
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xFC00000000000000000000000000000000000006",
         tokenSymbol: "ETH",
@@ -36901,6 +36920,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.KUCOIN,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x4446Fc4eb47f2f6586f9fAAb68B3498F86C07521",
+        // WCCS
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x4446Fc4eb47f2f6586f9fAAb68B3498F86C07521",
         tokenSymbol: "KCS",
@@ -36916,6 +36936,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.CONFLUX,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x14b2d3bc65e74dae1030eafd8ac30c533c976a9b",
+        // WCFX
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x14b2d3bc65e74dae1030eafd8ac30c533c976a9b",
         tokenSymbol: "CFX",
@@ -36932,6 +36953,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.METIS,
         variation: EthVariation.DEFAULT,
         priceTokenAddress: "0x75cb093E4D61d2A2e65D8e0BBb01DE8d89b53481",
+        // WMETIS
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x75cb093E4D61d2A2e65D8e0BBb01DE8d89b53481",
         tokenSymbol: "METIS",
@@ -36947,6 +36969,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.BEVM,
         variation: EthVariation.SUBSTRATE,
         priceTokenAddress: "0xB5136FEba197f5fF4B765E5b50c74db717796dcD",
+        // WBTC
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xB5136FEba197f5fF4B765E5b50c74db717796dcD",
         tokenSymbol: "BTC",
@@ -36962,6 +36985,7 @@ var require_chain_info = __commonJS({
         chainId: chain_id_1.EthChainId.MERLIN_MAINNET,
         variation: EthVariation.POLYGON_ZKEVM,
         priceTokenAddress: "0xF6D226f9Dc15d9bB51182815b320D3fBE324e1bA",
+        // WBTC
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0xF6D226f9Dc15d9bB51182815b320D3fBE324e1bA",
         tokenSymbol: "BTC",
@@ -36979,6 +37003,7 @@ var require_chain_info = __commonJS({
         priceTokenAddress: "0x721EF6871f1c4Efe730Dce047D40D1743B886946",
         tokenAddress: "0x0000000000000000000000000000000000000000",
         wrappedTokenAddress: "0x721EF6871f1c4Efe730Dce047D40D1743B886946",
+        // WCHZ
         tokenSymbol: "CHZ",
         tokenDecimals: 18,
         explorerUrl: "https://chiliscan.com",
@@ -36993,6 +37018,7 @@ var require_chain_info = __commonJS({
         variation: EthVariation.ZKSYNC,
         priceTokenAddress: "0x000000000000000000000000000000000000800A",
         tokenAddress: "0x000000000000000000000000000000000000800A",
+        //special
         wrappedTokenAddress: "0x000000000000000000000000000000000000800A",
         tokenSymbol: "ETH",
         tokenDecimals: 18,
@@ -37271,7 +37297,7 @@ var require_chain_info = __commonJS({
         wrappedTokenAddress: "0x0000000000000000000000000000000000000000",
         tokenSymbol: "HYPE",
         tokenDecimals: 18,
-        explorerUrl: "https://hyperevmscan.io/",
+        explorerUrl: "https://hyperevmscan.io",
         explorerApi: "https://hyperevmscan.io/v2",
         explorerApiType: ExplorerApiType.ETHERSCAN_V2,
         lightIcon: "https://assets.sentio.xyz/chains/hype.svg",
@@ -37302,7 +37328,7 @@ var require_chain_info = __commonJS({
         wrappedTokenAddress: "0x0000000000000000000000000000000000000000",
         tokenSymbol: "ETH",
         tokenDecimals: 18,
-        explorerUrl: "https://www.mev-commit.xyz/",
+        explorerUrl: "https://www.mev-commit.xyz",
         lightIcon: "https://assets.sentio.xyz/chains/mev-commit-dark.svg",
         darkIcon: "https://assets.sentio.xyz/chains/mev-commit.svg"
       },
@@ -37336,6 +37362,37 @@ var require_chain_info = __commonJS({
         lightIcon: "https://assets.sentio.xyz/chains/abstract.svg",
         darkIcon: "https://assets.sentio.xyz/chains/abstract.svg"
       },
+      [chain_id_1.EthChainId.PLASMA_MAINNET]: {
+        name: "Plasma Mainnet",
+        slug: "plasma-mainnet",
+        chainId: chain_id_1.EthChainId.PLASMA_MAINNET,
+        variation: EthVariation.DEFAULT,
+        priceTokenAddress: "0x0000000000000000000000000000000000000000",
+        tokenAddress: "0x0000000000000000000000000000000000000000",
+        wrappedTokenAddress: "0x6100E367285b01F48D07953803A2d8dCA5D19873",
+        tokenSymbol: "XPL",
+        tokenDecimals: 18,
+        explorerUrl: "https://plasmascan.to",
+        explorerApiType: ExplorerApiType.UNKNOWN,
+        lightIcon: "https://assets.sentio.xyz/chains/plasma.svg",
+        darkIcon: "https://assets.sentio.xyz/chains/plasma-dark.svg"
+      },
+      [chain_id_1.EthChainId.PLASMA_TESTNET]: {
+        name: "Plasma Testnet",
+        slug: "plasma-testnet",
+        chainId: chain_id_1.EthChainId.PLASMA_TESTNET,
+        mainnetChainId: chain_id_1.EthChainId.PLASMA_MAINNET,
+        variation: EthVariation.DEFAULT,
+        priceTokenAddress: "0x0000000000000000000000000000000000000000",
+        tokenAddress: "0x0000000000000000000000000000000000000000",
+        wrappedTokenAddress: "0x6100E367285b01F48D07953803A2d8dCA5D19873",
+        tokenSymbol: "XPL",
+        tokenDecimals: 18,
+        explorerUrl: "https://testnet.plasmascan.to",
+        explorerApiType: ExplorerApiType.UNKNOWN,
+        lightIcon: "https://assets.sentio.xyz/chains/plasma.svg",
+        darkIcon: "https://assets.sentio.xyz/chains/plasma-dark.svg"
+      },
       [chain_id_1.EthChainId.CUSTOM]: {
         name: "Custom",
         slug: "custom",
@@ -37676,7 +37733,6 @@ var require_chain_info = __commonJS({
       }
       return;
     }
-    exports.getChainExternalUrl = getChainExternalUrl;
     function getChainBlockscoutUrl(chainId, hash2, subtype) {
       if (!chainId || !hash2 || !subtype) {
         return;
@@ -37690,14 +37746,12 @@ var require_chain_info = __commonJS({
       }
       return `${supportedChain.blockscoutUrl}/${subtype}/${hash2}`;
     }
-    exports.getChainBlockscoutUrl = getChainBlockscoutUrl;
     function getSuiscanUrl(chainId, hash2, subtype) {
       if (!chainId || !hash2 || !subtype) {
         return;
       }
       return getSuiChainScanUrl(chainId, hash2, subtype);
     }
-    exports.getSuiscanUrl = getSuiscanUrl;
     function getLogoUrl(info, dark) {
       const defaultUrl = "https://assets.sentio.xyz/chains/chain-unknown.webp";
       if (!info) {
@@ -37718,7 +37772,6 @@ var require_chain_info = __commonJS({
       const chainInfo = exports.ChainInfo[chainId.toString()];
       return getLogoUrl(chainInfo, dark);
     }
-    exports.getChainLogo = getChainLogo;
     function getMainnetChain(chainId) {
       const chainInfo = exports.ChainInfo[chainId.toString()];
       if (!chainInfo) {
@@ -37726,16 +37779,15 @@ var require_chain_info = __commonJS({
       }
       return chainInfo.mainnetChainId || chainId;
     }
-    exports.getMainnetChain = getMainnetChain;
   }
 });
 
-// ../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-name.js
+// ../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-name.js
 var require_chain_name = __commonJS({
-  "../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/chain-name.js"(exports) {
+  "../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/chain-name.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getChainName = void 0;
+    exports.getChainName = getChainName;
     var chain_info_1 = require_chain_info();
     function getChainName(chainId) {
       if (typeof chainId === "number") {
@@ -37757,13 +37809,12 @@ var require_chain_name = __commonJS({
       }
       return chainId || "";
     }
-    exports.getChainName = getChainName;
   }
 });
 
-// ../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/index.js
+// ../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/index.js
 var require_dist = __commonJS({
-  "../../node_modules/.pnpm/@sentio+chain@3.4.7/node_modules/@sentio/chain/dist/index.js"(exports) {
+  "../../node_modules/.pnpm/@sentio+chain@3.4.8/node_modules/@sentio/chain/dist/index.js"(exports) {
     "use strict";
     var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
       if (k2 === void 0) k2 = k;
@@ -55162,52 +55213,45 @@ function spelunkMessage(value) {
 // ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
 
-// ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
-var TimeoutError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-};
-var AbortError2 = class extends Error {
-  constructor(message) {
-    super();
-    this.name = "AbortError";
-    this.message = message;
+// ../../node_modules/.pnpm/p-timeout@7.0.0/node_modules/p-timeout/index.js
+var TimeoutError = class _TimeoutError extends Error {
+  name = "TimeoutError";
+  constructor(message, options) {
+    super(message, options);
+    Error.captureStackTrace?.(this, _TimeoutError);
   }
 };
-var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError2(errorMessage) : new DOMException(errorMessage);
-var getAbortedReason = (signal) => {
-  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
-  return reason instanceof Error ? reason : getDOMException(reason);
-};
+var getAbortedReason = (signal) => signal.reason ?? new DOMException("This operation was aborted.", "AbortError");
 function pTimeout(promise, options) {
   const {
     milliseconds,
     fallback,
     message,
-    customTimers = { setTimeout, clearTimeout }
+    customTimers = { setTimeout, clearTimeout },
+    signal
   } = options;
   let timer;
+  let abortHandler;
   const wrappedPromise = new Promise((resolve, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (options.signal) {
-      const { signal } = options;
-      if (signal.aborted) {
-        reject(getAbortedReason(signal));
-      }
-      signal.addEventListener("abort", () => {
+    if (signal?.aborted) {
+      reject(getAbortedReason(signal));
+      return;
+    }
+    if (signal) {
+      abortHandler = () => {
         reject(getAbortedReason(signal));
-      });
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
     }
+    promise.then(resolve, reject);
     if (milliseconds === Number.POSITIVE_INFINITY) {
-      promise.then(resolve, reject);
       return;
     }
     const timeoutError2 = new TimeoutError();
-    timer = customTimers.setTimeout.call(void 0, () => {
+    timer = customTimers.setTimeout(() => {
       if (fallback) {
         try {
           resolve(fallback());
@@ -55228,25 +55272,21 @@ function pTimeout(promise, options) {
         reject(timeoutError2);
       }
     }, milliseconds);
-    (async () => {
-      try {
-        resolve(await promise);
-      } catch (error) {
-        reject(error);
-      }
-    })();
   });
   const cancelablePromise = wrappedPromise.finally(() => {
     cancelablePromise.clear();
+    if (abortHandler && signal) {
+      signal.removeEventListener("abort", abortHandler);
+    }
   });
   cancelablePromise.clear = () => {
-    customTimers.clearTimeout.call(void 0, timer);
+    customTimers.clearTimeout(timer);
     timer = void 0;
   };
   return cancelablePromise;
 }
 
-// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/lower-bound.js
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/lower-bound.js
 function lowerBound(array, value, comparator) {
   let first = 0;
   let count = array.length;
@@ -55263,25 +55303,31 @@ function lowerBound(array, value, comparator) {
   return first;
 }
 
-// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/priority-queue.js
 var PriorityQueue = class {
   #queue = [];
   enqueue(run2, options) {
-    options = {
-      priority: 0,
-      ...options
-    };
+    const { priority = 0, id: id2 } = options ?? {};
     const element = {
-      priority: options.priority,
+      priority,
+      id: id2,
       run: run2
     };
-    if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= priority) {
       this.#queue.push(element);
       return;
     }
     const index = lowerBound(this.#queue, element, (a, b2) => b2.priority - a.priority);
     this.#queue.splice(index, 0, element);
   }
+  setPriority(id2, priority) {
+    const index = this.#queue.findIndex((element) => element.id === id2);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id2}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { priority, id: id2 });
+  }
   dequeue() {
     const item = this.#queue.shift();
     return item?.run;
@@ -55294,14 +55340,17 @@ var PriorityQueue = class {
   }
 };
 
-// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+// ../../node_modules/.pnpm/p-queue@9.0.0/node_modules/p-queue/dist/index.js
 var PQueue = class extends import_index.default {
-  #carryoverConcurrencyCount;
+  #carryoverIntervalCount;
   #isIntervalIgnored;
   #intervalCount = 0;
   #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
   #interval;
   #intervalEnd = 0;
+  #lastExecutionTime = 0;
   #intervalId;
   #timeoutId;
   #queue;
@@ -55310,18 +55359,30 @@ var PQueue = class extends import_index.default {
   // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
   #concurrency;
   #isPaused;
-  #throwOnTimeout;
+  // Use to assign a unique identifier to a promise function, if not explicitly specified
+  #idAssigner = 1n;
+  // Track currently running tasks for debugging
+  #runningTasks = /* @__PURE__ */ new Map();
   /**
-      Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+      Get or set the default timeout for all tasks. Can be changed at runtime.
+  
+      Operations will throw a `TimeoutError` if they don't complete within the specified time.
+  
+      The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
   
-      Applies to each future operation.
+      @example
+      ```
+      const queue = new PQueue({timeout: 5000});
+  
+      // Change timeout for all future tasks
+      queue.timeout = 10000;
+      ```
       */
   timeout;
-  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
   constructor(options) {
     super();
     options = {
-      carryoverConcurrencyCount: false,
+      carryoverIntervalCount: false,
       intervalCap: Number.POSITIVE_INFINITY,
       interval: 0,
       concurrency: Number.POSITIVE_INFINITY,
@@ -55335,16 +55396,19 @@ var PQueue = class extends import_index.default {
     if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
       throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
     }
-    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
     this.#intervalCap = options.intervalCap;
     this.#interval = options.interval;
     this.#queue = new options.queueClass();
     this.#queueClass = options.queueClass;
     this.concurrency = options.concurrency;
+    if (options.timeout !== void 0 && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
     this.timeout = options.timeout;
-    this.#throwOnTimeout = options.throwOnTimeout === true;
     this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
   }
   get #doesIntervalAllowAnother() {
     return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
@@ -55354,6 +55418,9 @@ var PQueue = class extends import_index.default {
   }
   #next() {
     this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
     this.#tryToStartAnother();
     this.emit("next");
   }
@@ -55367,46 +55434,70 @@ var PQueue = class extends import_index.default {
     if (this.#intervalId === void 0) {
       const delay2 = this.#intervalEnd - now;
       if (delay2 < 0) {
-        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-      } else {
-        if (this.#timeoutId === void 0) {
-          this.#timeoutId = setTimeout(() => {
-            this.#onResumeInterval();
-          }, delay2);
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
         }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay2);
         return true;
       }
     }
     return false;
   }
+  #createIntervalTimeout(delay2) {
+    if (this.#timeoutId !== void 0) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay2);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = void 0;
+    }
+  }
   #tryToStartAnother() {
     if (this.#queue.size === 0) {
-      if (this.#intervalId) {
-        clearInterval(this.#intervalId);
-      }
-      this.#intervalId = void 0;
+      this.#clearIntervalTimer();
       this.emit("empty");
       if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
         this.emit("idle");
       }
       return false;
     }
+    let taskStarted = false;
     if (!this.#isPaused) {
       const canInitializeInterval = !this.#isIntervalPaused;
       if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
         const job = this.#queue.dequeue();
-        if (!job) {
-          return false;
+        if (!this.#isIntervalIgnored) {
+          this.#intervalCount++;
+          this.#scheduleRateLimitUpdate();
         }
         this.emit("active");
+        this.#lastExecutionTime = Date.now();
         job();
         if (canInitializeInterval) {
           this.#initializeIntervalIfNeeded();
         }
-        return true;
+        taskStarted = true;
       }
     }
-    return false;
+    return taskStarted;
   }
   #initializeIntervalIfNeeded() {
     if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
@@ -55419,11 +55510,11 @@ var PQueue = class extends import_index.default {
   }
   #onInterval() {
     if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-      clearInterval(this.#intervalId);
-      this.#intervalId = void 0;
+      this.#clearIntervalTimer();
     }
-    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
     this.#processQueue();
+    this.#scheduleRateLimitUpdate();
   }
   /**
   Executes all queued functions until it reaches the limit.
@@ -55449,21 +55540,81 @@ var PQueue = class extends import_index.default {
       }, { once: true });
     });
   }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(id2, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
+    this.#queue.setPriority(id2, priority);
+  }
   async add(function_, options = {}) {
+    options.id ??= (this.#idAssigner++).toString();
     options = {
       timeout: this.timeout,
-      throwOnTimeout: this.#throwOnTimeout,
       ...options
     };
     return new Promise((resolve, reject) => {
+      const taskSymbol = Symbol(`task-${options.id}`);
       this.#queue.enqueue(async () => {
         this.#pending++;
-        this.#intervalCount++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          // Match priority-queue default
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
         try {
-          options.signal?.throwIfAborted();
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            if (!this.#isIntervalIgnored) {
+              this.#intervalCount--;
+            }
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
           let operation = function_({ signal: options.signal });
           if (options.timeout) {
-            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
           }
           if (options.signal) {
             operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
@@ -55472,14 +55623,13 @@ var PQueue = class extends import_index.default {
           resolve(result);
           this.emit("completed", result);
         } catch (error) {
-          if (error instanceof TimeoutError && !options.throwOnTimeout) {
-            resolve();
-            return;
-          }
           reject(error);
           this.emit("error", error);
         } finally {
-          this.#next();
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
         }
       }, options);
       this.emit("add");
@@ -55511,6 +55661,7 @@ var PQueue = class extends import_index.default {
   */
   clear() {
     this.#queue = new this.#queueClass();
+    this.#updateRateLimitState();
   }
   /**
       Can be called multiple times. Useful if you for example add additional items at a later time.
@@ -55547,6 +55698,74 @@ var PQueue = class extends import_index.default {
     }
     await this.#onEvent("idle");
   }
+  /**
+      The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+  
+      @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+      */
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  /**
+      @returns A promise that rejects when any task in the queue errors.
+  
+      Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+  
+      Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+  
+      @example
+      ```
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      queue.add(() => fetchData(1)).catch(() => {});
+      queue.add(() => fetchData(2)).catch(() => {});
+      queue.add(() => fetchData(3)).catch(() => {});
+  
+      // Stop processing on first error
+      try {
+          await Promise.race([
+              queue.onError(),
+              queue.onIdle()
+          ]);
+      } catch (error) {
+          queue.pause(); // Stop processing remaining tasks
+          console.error('Queue failed:', error);
+      }
+      ```
+      */
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  async onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = (error) => {
+        this.off("error", handleError);
+        reject(error);
+      };
+      this.on("error", handleError);
+    });
+  }
   async #onEvent(event, filter) {
     return new Promise((resolve) => {
       const listener = () => {
@@ -55585,6 +55804,104 @@ var PQueue = class extends import_index.default {
   get isPaused() {
     return this.#isPaused;
   }
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
+  }
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
+    }
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    const shouldBeRateLimited = !this.#isIntervalIgnored && this.#intervalCount >= this.#intervalCap && this.#queue.size > 0;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
+  }
+  /**
+      Whether the queue is saturated. Returns `true` when:
+      - All concurrency slots are occupied and tasks are waiting, OR
+      - The queue is rate-limited and tasks are waiting
+  
+      Useful for detecting backpressure and potential hanging tasks.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Backpressure handling
+      if (queue.isSaturated) {
+          console.log('Queue is saturated, waiting for capacity...');
+          await queue.onSizeLessThan(queue.concurrency);
+      }
+  
+      // Monitoring for stuck tasks
+      setInterval(() => {
+          if (queue.isSaturated) {
+              console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+          }
+      }, 60000);
+      ```
+      */
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  /**
+      The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+  
+      Returns an array of task info objects.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Add tasks with IDs for better debugging
+      queue.add(() => fetchUser(123), {id: 'user-123'});
+      queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+  
+      // Check what's running
+      console.log(queue.runningTasks);
+      // => [{
+      //   id: 'user-123',
+      //   priority: 0,
+      //   startTime: 1759253001716,
+      //   timeout: undefined
+      // }, {
+      //   id: 'posts-456',
+      //   priority: 1,
+      //   startTime: 1759253001916,
+      //   timeout: undefined
+      // }]
+      ```
+      */
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
 };
 
 // src/provider.ts
@@ -57329,7 +57646,7 @@ function toLength(value) {
 }
 
 // ../../node_modules/.pnpm/ix@7.0.0/node_modules/ix/aborterror.mjs
-var AbortError3 = class _AbortError extends Error {
+var AbortError2 = class _AbortError extends Error {
   constructor(message = "The operation has been aborted") {
     super(message);
     Object.setPrototypeOf(this, _AbortError.prototype);
@@ -57342,10 +57659,10 @@ var AbortError3 = class _AbortError extends Error {
 };
 function throwIfAborted2(signal) {
   if (signal && signal.aborted) {
-    throw new AbortError3();
+    throw new AbortError2();
   }
 }
-Object.defineProperty(AbortError3, Symbol.hasInstance, {
+Object.defineProperty(AbortError2, Symbol.hasInstance, {
   writable: true,
   configurable: true,
   value(x) {
@@ -57603,7 +57920,7 @@ var FromObservableAsyncIterable = class extends AsyncIterableX {
         }
       });
       function onAbort() {
-        sink.error(new AbortError3());
+        sink.error(new AbortError2());
       }
       if (signal) {
         signal.addEventListener("abort", onAbort);
@@ -59780,4 +60097,4 @@ long/umd/index.js:
 @noble/curves/esm/secp256k1.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-BIFWYVK4.js.map
+//# sourceMappingURL=chunk-FQYIWDRC.js.map