@alchemy/cli 0.9.2 → 0.9.3

package/dist/index.js

@@ -5,32 +5,35 @@ import {
   errNotLoggedInForPolicyLookup,
   errSponsorshipNeedsPolicy,
   selectOrCreatePolicy
-} from "./chunk-TTWOBNJP.js";
+} from "./chunk-D2RUM2DD.js";
 import {
   registerAuth
-} from "./chunk-L2WODD2D.js";
+} from "./chunk-L5E7GEUU.js";
 import {
   openBrowser
-} from "./chunk-RGVM5SNE.js";
+} from "./chunk-AMGGO36F.js";
 import {
   SETUP_CAPABILITY_LABELS,
   SETUP_CAPABILITY_ORDER,
   getSetupStatus,
   isSetupComplete,
   shouldRunOnboarding
-} from "./chunk-P56HOTPV.js";
+} from "./chunk-VN5JUWHO.js";
 import {
   isInteractiveAllowed
-} from "./chunk-75ICFV5K.js";
+} from "./chunk-3GBDYROJ.js";
 import {
+  RpcApiError,
   adminClientFromFlags,
   clearSession,
   clientFromFlags,
   createPendingSession,
   fromAdminNetworkId,
   gasManagerClientFromFlags,
+  getGatewayDomain,
   getRPCNetworks,
   getWalletSessionByChain,
+  globalRpcCall,
   hasAuthLoginToken,
   isSessionValid,
   isSolanaNetwork,
@@ -52,14 +55,17 @@ import {
   resolveWalletSession,
   resolveX402Client,
   saveSession,
+  supportedWalletNetworks,
   toAdminNetworkId,
-  updateSession
-} from "./chunk-SIIZGMK5.js";
+  updateSession,
+  validateNetwork,
+  walletNetworkToChain
+} from "./chunk-ANONMDDZ.js";
 import {
   getAvailableUpdate,
   getUpdateStatus,
   printUpdateNotice
-} from "./chunk-HGFU4JCS.js";
+} from "./chunk-NUSUQI7X.js";
 import {
   bold,
   brand,
@@ -83,7 +89,7 @@ import {
   weiToEth,
   withSpinner,
   yellow
-} from "./chunk-MV7O3XBG.js";
+} from "./chunk-PMNRIXJI.js";
 import {
   KEY_MAP,
   configDir,
@@ -94,7 +100,7 @@ import {
   save,
   toMap,
   validKeys
-} from "./chunk-GDLPBPG3.js";
+} from "./chunk-GLKB4JM7.js";
 import {
   CLIError,
   EXIT_CODES,
@@ -107,6 +113,7 @@ import {
   errNetwork,
   errNoActiveSession,
   errNotFound,
+  errRPC,
   errRateLimited,
   errSessionExpired,
   errSetupRequired,
@@ -129,8 +136,9 @@ import {
   quiet,
   setFlags,
   setNoColor,
+  timeout,
   verbose
-} from "./chunk-OVLQH6KL.js";
+} from "./chunk-CTTW4PA4.js";
 
 // src/index.ts
 import { Command, Help } from "commander";
@@ -577,8 +585,8 @@ function registerConfig(program2) {
           "Interactive policy selection requires an interactive terminal. Pass an ID: `alchemy config set evm-gas-policy-id <id>`."
         );
       }
-      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-4BV5AWVV.js");
-      const { resolveNetwork: resolveNetwork2 } = await import("./resolve-FQ66OWT7.js");
+      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-V6W7CPAO.js");
+      const { resolveNetwork: resolveNetwork2 } = await import("./resolve-REZCFZZ7.js");
       const network = resolveNetwork2(program2);
       await selectOrCreatePolicy2({
         flavor: "sponsorship",
@@ -632,8 +640,8 @@ function registerConfig(program2) {
           "Interactive policy selection requires an interactive terminal. Pass an ID: `alchemy config set solana-fee-policy-id <id>`."
         );
       }
-      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-4BV5AWVV.js");
-      const { resolveSolanaNetwork: resolveSolanaNetwork2 } = await import("./resolve-FQ66OWT7.js");
+      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-V6W7CPAO.js");
+      const { resolveSolanaNetwork: resolveSolanaNetwork2 } = await import("./resolve-REZCFZZ7.js");
       const network = resolveSolanaNetwork2(program2);
       await selectOrCreatePolicy2({
         flavor: "solana",
@@ -691,7 +699,7 @@ function registerConfig(program2) {
       printJSON(toMap(cfg));
       return;
     }
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-FQ66OWT7.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-REZCFZZ7.js");
     const validToken = resolveAuthToken2(cfg);
     const authStatus = cfg.auth_token ? validToken ? `${green("\u2713")} authenticated${cfg.auth_token_expires_at ? ` ${dim(`(expires ${cfg.auth_token_expires_at})`)}` : ""}` : `${yellow("\u25C6")} expired${cfg.auth_token_expires_at ? ` ${dim(`(${cfg.auth_token_expires_at})`)}` : ""}` : dim("(not set) \u2014 run 'alchemy auth' to log in");
     const pairs = [
@@ -1924,10 +1932,10 @@ function createInterruptibleDelay(ms, signal) {
   }
   return new Promise((resolve, reject) => {
     const onAbort = () => {
-      clearTimeout(timeout);
+      clearTimeout(timeout2);
       reject(new WalletConnectInterruptedError());
     };
-    const timeout = setTimeout(() => {
+    const timeout2 = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
       resolve();
     }, ms);
@@ -2568,25 +2576,25 @@ function printCrossModeHintAfterLocal(chain) {
 async function runConnectFlow(program2, opts) {
   const force = Boolean(opts.force);
   const importPath = opts.import;
-  let mode2;
+  let mode;
   if (opts.mode === "session" || opts.mode === "local") {
-    mode2 = opts.mode;
+    mode = opts.mode;
   } else if (opts.mode !== void 0) {
     throw errInvalidArgs("`--mode` must be 'session' or 'local'.");
   }
   if (opts.instanceName !== void 0) {
-    if (mode2 === "local") {
+    if (mode === "local") {
       throw errInvalidArgs("`--instance-name` is only valid with `--mode session`.");
     }
-    mode2 = "session";
+    mode = "session";
   }
   if (importPath) {
-    if (mode2 === "session") {
+    if (mode === "session") {
       throw errInvalidArgs("`--import` is only valid with `--mode local`.");
     }
-    mode2 = "local";
+    mode = "local";
   }
-  if (!mode2) {
+  if (!mode) {
     if (!isInteractiveAllowed(program2)) {
       throw errInvalidArgs(
         "Specify `--mode <session|local>` in non-interactive mode."
@@ -2602,9 +2610,9 @@ async function runConnectFlow(program2, opts) {
       cancelMessage: "Wallet connect cancelled."
     });
     if (choice === null) throw new WalletConnectInterruptedError();
-    mode2 = choice;
+    mode = choice;
   }
-  if (mode2 === "session") {
+  if (mode === "session") {
     await runSessionConnect({
       program: program2,
       force,
@@ -3097,15 +3105,15 @@ async function requestJSON(url, options) {
 async function callApiData(apiKey, path, options = {}) {
   if (!apiKey) throw errAuthRequired();
   const override = parseBaseURLOverride(DATA_API_BASE_URL_ENV);
-  const base2 = override ? new URL(`/data/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/data/v1/${apiKey}/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = override ? new URL(`/data/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/data/v1/${apiKey}/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, { ...options, path });
 }
 async function callApiPrices(apiKey, path, options = {}) {
   if (!apiKey) throw errAuthRequired();
   const override = parseBaseURLOverride(PRICES_API_BASE_URL_ENV);
-  const base2 = override ? new URL(`/prices/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/prices/v1/${apiKey}/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = override ? new URL(`/prices/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/prices/v1/${apiKey}/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, { ...options, path });
 }
 async function callNotify(token, path, options = {}) {
@@ -3114,8 +3122,8 @@ async function callNotify(token, path, options = {}) {
       "Webhook API key required. Set ALCHEMY_WEBHOOK_API_KEY (or ALCHEMY_NOTIFY_AUTH_TOKEN) or pass --webhook-api-key."
     );
   }
-  const base2 = new URL(`https://dashboard.${getBaseDomain()}/api/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = new URL(`https://dashboard.${getBaseDomain()}/api/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, {
     ...options,
     path,
@@ -4267,51 +4275,10 @@ import { createSmartWalletClient } from "@alchemy/wallet-apis";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/lib/chains.ts
-import * as viemChains from "viem/chains";
-var NETWORK_TO_CHAIN = {
-  "eth-mainnet": viemChains.mainnet,
-  "eth-sepolia": viemChains.sepolia,
-  "eth-holesky": viemChains.holesky,
-  "base-mainnet": viemChains.base,
-  "base-sepolia": viemChains.baseSepolia,
-  "arb-mainnet": viemChains.arbitrum,
-  "arb-sepolia": viemChains.arbitrumSepolia,
-  "opt-mainnet": viemChains.optimism,
-  "opt-sepolia": viemChains.optimismSepolia,
-  "polygon-mainnet": viemChains.polygon,
-  "polygon-amoy": viemChains.polygonAmoy,
-  "zksync-mainnet": viemChains.zksync,
-  "zksync-sepolia": viemChains.zksyncSepoliaTestnet,
-  "avax-mainnet": viemChains.avalanche,
-  "avax-fuji": viemChains.avalancheFuji,
-  "bnb-mainnet": viemChains.bsc,
-  "bnb-testnet": viemChains.bscTestnet,
-  "linea-mainnet": viemChains.linea,
-  "linea-sepolia": viemChains.lineaSepolia,
-  "scroll-mainnet": viemChains.scroll,
-  "scroll-sepolia": viemChains.scrollSepolia,
-  "blast-mainnet": viemChains.blast,
-  "blast-sepolia": viemChains.blastSepolia,
-  "zora-mainnet": viemChains.zora,
-  "zora-sepolia": viemChains.zoraSepolia,
-  "celo-mainnet": viemChains.celo,
-  "gnosis-mainnet": viemChains.gnosis,
-  "mantle-mainnet": viemChains.mantle,
-  "worldchain-mainnet": viemChains.worldchain,
-  "shape-mainnet": viemChains.shape,
-  "unichain-mainnet": viemChains.unichain,
-  "unichain-sepolia": viemChains.unichainSepolia,
-  "ink-mainnet": viemChains.ink,
-  "ink-sepolia": viemChains.inkSepolia,
-  "soneium-mainnet": viemChains.soneium,
-  "frax-mainnet": viemChains.fraxtal,
-  "mode-mainnet": viemChains.mode,
-  "berachain-mainnet": viemChains.berachain
-};
 function networkToChain(network) {
-  const chain = NETWORK_TO_CHAIN[network];
+  const chain = walletNetworkToChain(network);
   if (!chain) {
-    const supported = Object.keys(NETWORK_TO_CHAIN).sort().join(", ");
+    const supported = supportedWalletNetworks().join(", ");
     throw errInvalidArgs(
       `Network "${network}" is not supported for wallet operations. Supported networks: ${supported}`
     );
@@ -5102,6 +5069,517 @@ function formatError(error) {
   }
 }
 
+// ../../packages/sdk/dist/data/index.js
+var DEFAULT_DATA_TIMEOUT_MS = 3e4;
+var DEFAULT_BREADCRUMB_HEADER = "alchemy-sdk";
+var DataApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "DataApiError";
+  }
+};
+async function dataGet(baseUrl, apiKey, path, params, options = {}) {
+  const url = new URL(`${baseUrl}/${apiKey}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0)
+        continue;
+      if (Array.isArray(value)) {
+        for (const item of value)
+          url.searchParams.append(key, item);
+      } else {
+        url.searchParams.set(key, value);
+      }
+    }
+  }
+  const resp = await dataFetch(url.toString(), "GET", void 0, options);
+  return resp.json();
+}
+async function dataPost(baseUrl, apiKey, path, body, options = {}) {
+  const resp = await dataFetch(`${baseUrl}/${apiKey}${path}`, "POST", body, options);
+  return resp.json();
+}
+function nftBaseUrl(network, options = {}) {
+  validateNetwork(network);
+  return `https://${network}.${getGatewayDomain(options)}/nft/v3`;
+}
+function pricesBaseUrl(options = {}) {
+  return `https://api.${getGatewayDomain(options)}/prices/v1`;
+}
+function portfolioBaseUrl(options = {}) {
+  return `https://api.${getGatewayDomain(options)}/data/v1`;
+}
+function createAlchemyDataClient(apiKey, options = {}) {
+  return new AlchemyDataClient(apiKey, options);
+}
+var AlchemyDataClient = class {
+  apiKey;
+  options;
+  nft;
+  prices;
+  portfolio;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+    this.nft = new NftApiClient(apiKey, options);
+    this.prices = new PricesApiClient(apiKey, options);
+    this.portfolio = new PortfolioApiClient(apiKey, options);
+  }
+};
+var NftApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getNFTsForOwner(network, params) {
+    return this.get(network, "/getNFTsForOwner", params);
+  }
+  getNFTsForContract(network, params) {
+    return this.get(network, "/getNFTsForContract", params);
+  }
+  getNFTMetadata(network, params) {
+    return this.get(network, "/getNFTMetadata", params);
+  }
+  getNFTMetadataBatch(network, body) {
+    return this.post(network, "/getNFTMetadataBatch", body);
+  }
+  getContractMetadata(network, params) {
+    return this.get(network, "/getContractMetadata", params);
+  }
+  getOwnersForNFT(network, params) {
+    return this.get(network, "/getOwnersForNFT", params);
+  }
+  getOwnersForContract(network, params) {
+    return this.get(network, "/getOwnersForContract", params);
+  }
+  getFloorPrice(network, params) {
+    return this.get(network, "/getFloorPrice", params);
+  }
+  isSpamContract(network, params) {
+    return this.get(network, "/isSpamContract", params);
+  }
+  searchContractMetadata(network, params) {
+    return this.get(network, "/searchContractMetadata", params);
+  }
+  getNFTSales(network, params) {
+    return this.get(network, "/getNFTSales", params);
+  }
+  getContractsForOwner(network, params) {
+    return this.get(network, "/getContractsForOwner", params);
+  }
+  getNFTsForCollection(network, params) {
+    return this.get(network, "/getNFTsForCollection", params);
+  }
+  getCollectionMetadata(network, params) {
+    return this.get(network, "/getCollectionMetadata", params);
+  }
+  getContractMetadataBatch(network, body) {
+    return this.post(network, "/getContractMetadataBatch", body);
+  }
+  getSpamContracts(network) {
+    return this.get(network, "/getSpamContracts", {});
+  }
+  isAirdropNFT(network, params) {
+    return this.get(network, "/isAirdropNFT", params);
+  }
+  summarizeNFTAttributes(network, params) {
+    return this.get(network, "/summarizeNFTAttributes", params);
+  }
+  isHolderOfContract(network, params) {
+    return this.get(network, "/isHolderOfContract", params);
+  }
+  computeRarity(network, params) {
+    return this.get(network, "/computeRarity", params);
+  }
+  getCollectionsForOwner(network, params) {
+    return this.get(network, "/getCollectionsForOwner", params);
+  }
+  get(network, path, params) {
+    return dataGet(nftBaseUrl(network, this.options), this.apiKey, path, params, this.options);
+  }
+  post(network, path, body) {
+    return dataPost(nftBaseUrl(network, this.options), this.apiKey, path, body, this.options);
+  }
+};
+var PricesApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getTokenPricesBySymbol(params) {
+    return dataGet(pricesBaseUrl(this.options), this.apiKey, "/tokens/by-symbol", params, this.options);
+  }
+  getTokenPricesByAddress(body) {
+    return dataPost(pricesBaseUrl(this.options), this.apiKey, "/tokens/by-address", body, this.options);
+  }
+  getHistoricalTokenPrices(body) {
+    return dataPost(pricesBaseUrl(this.options), this.apiKey, "/tokens/historical", body, this.options);
+  }
+};
+var PortfolioApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getTokensByAddress(body) {
+    return this.post("/assets/tokens/by-address", body);
+  }
+  getTokenBalancesByAddress(body) {
+    return this.post("/assets/tokens/balances/by-address", body);
+  }
+  getNFTsByAddress(body) {
+    return this.post("/assets/nfts/by-address", body);
+  }
+  getNFTContractsByAddress(body) {
+    return this.post("/assets/nfts/contracts/by-address", body);
+  }
+  post(path, body) {
+    return dataPost(portfolioBaseUrl(this.options), this.apiKey, path, body, this.options);
+  }
+};
+async function dataFetch(url, method, body, options) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const resp = await fetchFn(url, {
+    method,
+    headers: {
+      ...body !== void 0 && { "Content-Type": "application/json" },
+      Accept: "application/json",
+      "x-alchemy-client-breadcrumb": options.breadcrumb ?? DEFAULT_BREADCRUMB_HEADER
+    },
+    ...body !== void 0 && { body: JSON.stringify(body) },
+    signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_DATA_TIMEOUT_MS)
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new DataApiError(resp.status, text || `HTTP ${resp.status}`);
+  }
+  return resp;
+}
+
+// ../../packages/sdk/dist/surfaces/index.js
+var RPC_API_SURFACE = [
+  { name: "ethGetBalance", rpcMethod: "eth_getBalance", family: "evm", gateway: "network" },
+  { name: "ethGetBlockByNumber", rpcMethod: "eth_getBlockByNumber", family: "evm", gateway: "network" },
+  { name: "ethGetBlockByHash", rpcMethod: "eth_getBlockByHash", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByHash", rpcMethod: "eth_getTransactionByHash", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionReceipt", rpcMethod: "eth_getTransactionReceipt", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionCount", rpcMethod: "eth_getTransactionCount", family: "evm", gateway: "network" },
+  { name: "ethBlockNumber", rpcMethod: "eth_blockNumber", family: "evm", gateway: "network" },
+  { name: "ethGasPrice", rpcMethod: "eth_gasPrice", family: "evm", gateway: "network" },
+  { name: "ethEstimateGas", rpcMethod: "eth_estimateGas", family: "evm", gateway: "network" },
+  { name: "ethGetCode", rpcMethod: "eth_getCode", family: "evm", gateway: "network" },
+  { name: "ethGetStorageAt", rpcMethod: "eth_getStorageAt", family: "evm", gateway: "network" },
+  { name: "ethGetLogs", rpcMethod: "eth_getLogs", family: "evm", gateway: "network" },
+  { name: "ethChainId", rpcMethod: "eth_chainId", family: "evm", gateway: "network" },
+  { name: "ethFeeHistory", rpcMethod: "eth_feeHistory", family: "evm", gateway: "network" },
+  { name: "ethMaxPriorityFeePerGas", rpcMethod: "eth_maxPriorityFeePerGas", family: "evm", gateway: "network" },
+  { name: "netVersion", rpcMethod: "net_version", family: "evm", gateway: "network" },
+  { name: "web3ClientVersion", rpcMethod: "web3_clientVersion", family: "evm", gateway: "network" },
+  { name: "ethGetBlockTransactionCountByHash", rpcMethod: "eth_getBlockTransactionCountByHash", family: "evm", gateway: "network" },
+  { name: "ethGetBlockTransactionCountByNumber", rpcMethod: "eth_getBlockTransactionCountByNumber", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByBlockHashAndIndex", rpcMethod: "eth_getTransactionByBlockHashAndIndex", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByBlockNumberAndIndex", rpcMethod: "eth_getTransactionByBlockNumberAndIndex", family: "evm", gateway: "network" },
+  { name: "ethSyncing", rpcMethod: "eth_syncing", family: "evm", gateway: "network" },
+  { name: "ethCallBundle", rpcMethod: "eth_callBundle", family: "evm", gateway: "network" },
+  { name: "ethCallMany", rpcMethod: "eth_callMany", family: "evm", gateway: "network" },
+  { name: "netListening", rpcMethod: "net_listening", family: "evm", gateway: "network" },
+  { name: "web3Sha3", rpcMethod: "web3_sha3", family: "evm", gateway: "network" },
+  { name: "getTokenBalances", rpcMethod: "alchemy_getTokenBalances", family: "evm", gateway: "network" },
+  { name: "getTokenMetadata", rpcMethod: "alchemy_getTokenMetadata", family: "evm", gateway: "network" },
+  { name: "getTokenAllowance", rpcMethod: "alchemy_getTokenAllowance", family: "evm", gateway: "network" },
+  { name: "getAssetTransfers", rpcMethod: "alchemy_getAssetTransfers", family: "evm", gateway: "network" },
+  { name: "getTransactionReceipts", rpcMethod: "alchemy_getTransactionReceipts", family: "evm", gateway: "network" },
+  { name: "simulateAssetChanges", rpcMethod: "alchemy_simulateAssetChanges", family: "evm", gateway: "network" },
+  { name: "simulateExecution", rpcMethod: "alchemy_simulateExecution", family: "evm", gateway: "network" },
+  { name: "traceCall", rpcMethod: "trace_call", family: "evm", gateway: "network" },
+  { name: "traceTransaction", rpcMethod: "trace_transaction", family: "evm", gateway: "network" },
+  { name: "traceBlock", rpcMethod: "trace_block", family: "evm", gateway: "network" },
+  { name: "debugTraceTransaction", rpcMethod: "debug_traceTransaction", family: "evm", gateway: "network" },
+  { name: "debugTraceCall", rpcMethod: "debug_traceCall", family: "evm", gateway: "network" },
+  { name: "estimateUserOperationGas", rpcMethod: "estimateUserOperationGas", family: "evm", gateway: "network" },
+  { name: "getUserOperationReceipt", rpcMethod: "getUserOperationReceipt", family: "evm", gateway: "network" },
+  { name: "getUserOperationByHash", rpcMethod: "getUserOperationByHash", family: "evm", gateway: "network" },
+  { name: "supportedEntryPoints", rpcMethod: "supportedEntryPoints", family: "evm", gateway: "network" },
+  { name: "solana_getAsset", rpcMethod: "getAsset", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByOwner", rpcMethod: "getAssetsByOwner", family: "solana", gateway: "network" },
+  { name: "solana_searchAssets", rpcMethod: "searchAssets", family: "solana", gateway: "network" },
+  { name: "getTokenAccounts", rpcMethod: "getTokenAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getAssets", rpcMethod: "getAssets", family: "solana", gateway: "network" },
+  { name: "solana_getAssetProof", rpcMethod: "getAssetProof", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByAuthority", rpcMethod: "getAssetsByAuthority", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByGroup", rpcMethod: "getAssetsByGroup", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByCreator", rpcMethod: "getAssetsByCreator", family: "solana", gateway: "network" },
+  { name: "solana_getAssetSignatures", rpcMethod: "getAssetSignatures", family: "solana", gateway: "network" },
+  { name: "getNftEditions", rpcMethod: "getNftEditions", family: "solana", gateway: "network" },
+  { name: "simulateAssetChangesBundle", rpcMethod: "alchemy_simulateAssetChangesBundle", family: "evm", gateway: "network" },
+  { name: "simulateExecutionBundle", rpcMethod: "alchemy_simulateExecutionBundle", family: "evm", gateway: "network" },
+  { name: "simulateUserOperationAssetChanges", rpcMethod: "alchemy_simulateUserOperationAssetChanges", family: "evm", gateway: "network" },
+  { name: "traceFilter", rpcMethod: "trace_filter", family: "evm", gateway: "network" },
+  { name: "traceReplayTransaction", rpcMethod: "trace_replayTransaction", family: "evm", gateway: "network" },
+  { name: "traceReplayBlockTransactions", rpcMethod: "trace_replayBlockTransactions", family: "evm", gateway: "network" },
+  { name: "debugTraceBlockByNumber", rpcMethod: "debug_traceBlockByNumber", family: "evm", gateway: "network" },
+  { name: "debugTraceBlockByHash", rpcMethod: "debug_traceBlockByHash", family: "evm", gateway: "network" },
+  { name: "debugGetRawBlock", rpcMethod: "debug_getRawBlock", family: "evm", gateway: "network" },
+  { name: "debugGetRawReceipts", rpcMethod: "debug_getRawReceipts", family: "evm", gateway: "network" },
+  { name: "requestGasAndPaymasterAndData", rpcMethod: "alchemy_requestGasAndPaymasterAndData", family: "evm", gateway: "network" },
+  { name: "requestPaymasterAndData", rpcMethod: "alchemy_requestPaymasterAndData", family: "evm", gateway: "network" },
+  { name: "ethCall", rpcMethod: "eth_call", family: "evm", gateway: "network" },
+  { name: "ethGetBlockReceipts", rpcMethod: "eth_getBlockReceipts", family: "evm", gateway: "network" },
+  { name: "ethGetProof", rpcMethod: "eth_getProof", family: "evm", gateway: "network" },
+  { name: "ethCreateAccessList", rpcMethod: "eth_createAccessList", family: "evm", gateway: "network" },
+  { name: "ethBlobBaseFee", rpcMethod: "eth_blobBaseFee", family: "evm", gateway: "network" },
+  { name: "rundlerMaxPriorityFeePerGas", rpcMethod: "rundler_maxPriorityFeePerGas", family: "evm", gateway: "network" },
+  { name: "solana_getBalance", rpcMethod: "getBalance", family: "solana", gateway: "network" },
+  { name: "solana_getAccountInfo", rpcMethod: "getAccountInfo", family: "solana", gateway: "network" },
+  { name: "solana_getMultipleAccounts", rpcMethod: "getMultipleAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getTransaction", rpcMethod: "getTransaction", family: "solana", gateway: "network" },
+  { name: "solana_getSignaturesForAddress", rpcMethod: "getSignaturesForAddress", family: "solana", gateway: "network" },
+  { name: "solana_getSignatureStatuses", rpcMethod: "getSignatureStatuses", family: "solana", gateway: "network" },
+  { name: "solana_simulateTransaction", rpcMethod: "simulateTransaction", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountBalance", rpcMethod: "getTokenAccountBalance", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountsByOwner", rpcMethod: "getTokenAccountsByOwner", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountsByDelegate", rpcMethod: "getTokenAccountsByDelegate", family: "solana", gateway: "network" },
+  { name: "solana_getTokenSupply", rpcMethod: "getTokenSupply", family: "solana", gateway: "network" },
+  { name: "solana_getTokenLargestAccounts", rpcMethod: "getTokenLargestAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getBlock", rpcMethod: "getBlock", family: "solana", gateway: "network" },
+  { name: "solana_getBlockHeight", rpcMethod: "getBlockHeight", family: "solana", gateway: "network" },
+  { name: "solana_getBlockTime", rpcMethod: "getBlockTime", family: "solana", gateway: "network" },
+  { name: "solana_getBlocks", rpcMethod: "getBlocks", family: "solana", gateway: "network" },
+  { name: "solana_getSlot", rpcMethod: "getSlot", family: "solana", gateway: "network" },
+  { name: "solana_getLatestBlockhash", rpcMethod: "getLatestBlockhash", family: "solana", gateway: "network" },
+  { name: "solana_isBlockhashValid", rpcMethod: "isBlockhashValid", family: "solana", gateway: "network" },
+  { name: "solana_getProgramAccounts", rpcMethod: "getProgramAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getEpochInfo", rpcMethod: "getEpochInfo", family: "solana", gateway: "network" },
+  { name: "solana_getSupply", rpcMethod: "getSupply", family: "solana", gateway: "network" },
+  { name: "solana_getVersion", rpcMethod: "getVersion", family: "solana", gateway: "network" },
+  { name: "solana_getTransactionCount", rpcMethod: "getTransactionCount", family: "solana", gateway: "network" },
+  { name: "solana_getInflationRate", rpcMethod: "getInflationRate", family: "solana", gateway: "network" },
+  { name: "solana_getInflationReward", rpcMethod: "getInflationReward", family: "solana", gateway: "network" },
+  { name: "solana_getVoteAccounts", rpcMethod: "getVoteAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getLargestAccounts", rpcMethod: "getLargestAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getFeeForMessage", rpcMethod: "getFeeForMessage", family: "solana", gateway: "network" },
+  { name: "solana_getRecentPrioritizationFees", rpcMethod: "getRecentPrioritizationFees", family: "solana", gateway: "network" },
+  { name: "solana_getMinimumBalanceForRentExemption", rpcMethod: "getMinimumBalanceForRentExemption", family: "solana", gateway: "network" },
+  { name: "solana_getPriorityFeeEstimate", rpcMethod: "getPriorityFeeEstimate", family: "solana", gateway: "network" },
+  { name: "solana_getClusterNodes", rpcMethod: "getClusterNodes", family: "solana", gateway: "network" },
+  { name: "solana_getLeaderSchedule", rpcMethod: "getLeaderSchedule", family: "solana", gateway: "network" },
+  { name: "solana_getMaxRetransmitSlot", rpcMethod: "getMaxRetransmitSlot", family: "solana", gateway: "network" },
+  { name: "solana_getMaxShredInsertSlot", rpcMethod: "getMaxShredInsertSlot", family: "solana", gateway: "network" },
+  { name: "solana_getRecentPerformanceSamples", rpcMethod: "getRecentPerformanceSamples", family: "solana", gateway: "network" },
+  { name: "solana_getFirstAvailableBlock", rpcMethod: "getFirstAvailableBlock", family: "solana", gateway: "network" },
+  { name: "solana_getGenesisHash", rpcMethod: "getGenesisHash", family: "solana", gateway: "network" },
+  { name: "solana_getHighestSnapshotSlot", rpcMethod: "getHighestSnapshotSlot", family: "solana", gateway: "network" },
+  { name: "solana_getIdentity", rpcMethod: "getIdentity", family: "solana", gateway: "network" },
+  { name: "solana_getInflationGovernor", rpcMethod: "getInflationGovernor", family: "solana", gateway: "network" },
+  { name: "solana_minimumLedgerSlot", rpcMethod: "minimumLedgerSlot", family: "solana", gateway: "network" },
+  { name: "solana_requestAirdrop", rpcMethod: "requestAirdrop", family: "solana", gateway: "network" },
+  { name: "solana_getBlockCommitment", rpcMethod: "getBlockCommitment", family: "solana", gateway: "network" },
+  { name: "solana_getBlockProduction", rpcMethod: "getBlockProduction", family: "solana", gateway: "network" },
+  { name: "solana_getSlotLeader", rpcMethod: "getSlotLeader", family: "solana", gateway: "network" },
+  { name: "solana_getSlotLeaders", rpcMethod: "getSlotLeaders", family: "solana", gateway: "network" },
+  { name: "solana_getEpochSchedule", rpcMethod: "getEpochSchedule", family: "solana", gateway: "network" },
+  { name: "solana_getBlocksWithLimit", rpcMethod: "getBlocksWithLimit", family: "solana", gateway: "network" },
+  { name: "solana_getStakeActivation", rpcMethod: "getStakeActivation", family: "solana", gateway: "network" },
+  { name: "solana_simulateBundle", rpcMethod: "simulateBundle", family: "solana", gateway: "network" }
+];
+var DATA_API_SURFACE = [
+  { name: "getNFTsForOwner", service: "nft", sdkMethod: "getNFTsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTsForContract", service: "nft", sdkMethod: "getNFTsForContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTMetadata", service: "nft", sdkMethod: "getNFTMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTMetadataBatch", service: "nft", sdkMethod: "getNFTMetadataBatch", transport: "post", input: "body", requiresNetwork: true },
+  { name: "getContractMetadata", service: "nft", sdkMethod: "getContractMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getOwnersForNFT", service: "nft", sdkMethod: "getOwnersForNFT", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getOwnersForContract", service: "nft", sdkMethod: "getOwnersForContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getFloorPrice", service: "nft", sdkMethod: "getFloorPrice", transport: "get", input: "query", requiresNetwork: true },
+  { name: "isSpamContract", service: "nft", sdkMethod: "isSpamContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "searchContractMetadata", service: "nft", sdkMethod: "searchContractMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTSales", service: "nft", sdkMethod: "getNFTSales", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getContractsForOwner", service: "nft", sdkMethod: "getContractsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTsForCollection", service: "nft", sdkMethod: "getNFTsForCollection", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getCollectionMetadata", service: "nft", sdkMethod: "getCollectionMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getContractMetadataBatch", service: "nft", sdkMethod: "getContractMetadataBatch", transport: "post", input: "body", requiresNetwork: true },
+  { name: "getSpamContracts", service: "nft", sdkMethod: "getSpamContracts", transport: "get", input: "none", requiresNetwork: true },
+  { name: "isAirdropNFT", service: "nft", sdkMethod: "isAirdropNFT", transport: "get", input: "query", requiresNetwork: true },
+  { name: "summarizeNFTAttributes", service: "nft", sdkMethod: "summarizeNFTAttributes", transport: "get", input: "query", requiresNetwork: true },
+  { name: "isHolderOfContract", service: "nft", sdkMethod: "isHolderOfContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "computeRarity", service: "nft", sdkMethod: "computeRarity", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getCollectionsForOwner", service: "nft", sdkMethod: "getCollectionsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getTokenPricesBySymbol", service: "prices", sdkMethod: "getTokenPricesBySymbol", transport: "get", input: "query", requiresNetwork: false },
+  { name: "getTokenPricesByAddress", service: "prices", sdkMethod: "getTokenPricesByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getHistoricalTokenPrices", service: "prices", sdkMethod: "getHistoricalTokenPrices", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getTokensByAddress", service: "portfolio", sdkMethod: "getTokensByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getTokenBalancesByAddress", service: "portfolio", sdkMethod: "getTokenBalancesByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getNFTsByAddress", service: "portfolio", sdkMethod: "getNFTsByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getNFTContractsByAddress", service: "portfolio", sdkMethod: "getNFTContractsByAddress", transport: "post", input: "body", requiresNetwork: false }
+];
+var RPC_API_TOOL_NAMES = RPC_API_SURFACE.map((method) => method.name);
+var DATA_API_TOOL_NAMES = DATA_API_SURFACE.map((method) => method.name);
+
+// src/commands/surface-parity.ts
+function registerEvmRpcSurfaceCommands(root, rpc) {
+  for (const method of RPC_API_SURFACE.filter((entry) => entry.family === "evm")) {
+    registerRpcSurfaceCommand({ root, parent: rpc, method });
+  }
+}
+function registerSolanaRpcSurfaceCommands(root, solana) {
+  for (const method of RPC_API_SURFACE.filter((entry) => entry.family === "solana")) {
+    registerRpcSurfaceCommand({ root, parent: solana, method });
+  }
+}
+function registerDataSurfaceCommands(root, data) {
+  for (const method of DATA_API_SURFACE) {
+    const command = data.command(method.name).description(`Call ${method.name}`);
+    if (method.input === "query") {
+      command.option("--query <json>", "Query parameters as a JSON object", "{}");
+    } else if (method.input === "body") {
+      command.option("--body <json>", "Request body as a JSON object", "{}");
+    }
+    command.action(async (opts) => {
+      try {
+        const apiKey = resolveAPIKey(root);
+        if (!apiKey) {
+          throw errAuthRequired();
+        }
+        const client = createAlchemyDataClient(apiKey, { breadcrumb: "alchemy-cli" });
+        const result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => callDataMethod(client, method, root, opts)
+        );
+        printSyntaxJSON(result);
+      } catch (err) {
+        exitWithError(mapDataError(err));
+      }
+    });
+  }
+}
+function registerRpcSurfaceCommand({ root, parent, method }) {
+  parent.command(method.name).description(`Call ${method.rpcMethod}`).option("--params <json>", "JSON-RPC params as an array or object", "[]").action(async (opts) => {
+    try {
+      const params = parseRpcParams(opts.params);
+      let result;
+      if (method.gateway === "global") {
+        const apiKey = resolveAPIKey(root);
+        if (!apiKey) {
+          throw errAuthRequired();
+        }
+        if (!Array.isArray(params)) {
+          throw errInvalidArgs("--params must be a JSON array for global RPC methods.");
+        }
+        result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => globalRpcCall(apiKey, method.rpcMethod, params, {
+            breadcrumb: "alchemy-cli",
+            ...timeout && { timeoutMs: timeout }
+          })
+        );
+      } else {
+        const client = method.family === "solana" ? clientFromFlags(root, { forceNetwork: resolveSolanaNetwork(root) }) : clientFromFlags(root);
+        result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => client.call(method.rpcMethod, params)
+        );
+      }
+      printSyntaxJSON(result);
+    } catch (err) {
+      exitWithError(mapRpcError(err));
+    }
+  });
+}
+function parseRpcParams(input) {
+  const parsed = parseRequiredJSON(input, "--params");
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  throw errInvalidArgs("--params must be a JSON array or object.");
+}
+async function callDataMethod(client, method, root, opts) {
+  if (method.service === "nft") {
+    const fn2 = client.nft[method.sdkMethod];
+    const network = resolveNetwork(root);
+    if (method.input === "none") {
+      return await fn2.call(client.nft, network);
+    }
+    if (method.input === "body") {
+      return await fn2.call(client.nft, network, parseDataObject(opts.body ?? "{}", "--body"));
+    }
+    return await fn2.call(client.nft, network, normalizeQuery(parseDataObject(opts.query ?? "{}", "--query")));
+  }
+  if (method.service === "prices") {
+    const fn2 = client.prices[method.sdkMethod];
+    if (method.input === "body") {
+      return await fn2.call(client.prices, parseDataObject(opts.body ?? "{}", "--body"));
+    }
+    return await fn2.call(client.prices, parseDataObject(opts.query ?? "{}", "--query"));
+  }
+  const fn = client.portfolio[method.sdkMethod];
+  return await fn.call(client.portfolio, parseDataObject(opts.body ?? "{}", "--body"));
+}
+function parseDataObject(input, label) {
+  const parsed = parseRequiredJSON(input, label);
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  throw errInvalidArgs(`${label} must be a JSON object.`);
+}
+function normalizeQuery(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      out[key] = value.map((item) => String(item));
+    } else {
+      out[key] = String(value);
+    }
+  }
+  return out;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mapRpcError(err) {
+  if (!(err instanceof RpcApiError)) {
+    return err;
+  }
+  if (err.status === 429) {
+    return errRateLimited();
+  }
+  if (err.status === 401 || err.status === 403) {
+    return errInvalidAPIKey(err.message);
+  }
+  if (err.status !== void 0) {
+    return errNetwork(`HTTP ${err.status}: ${err.message}`);
+  }
+  return errRPC(err.code, err.message);
+}
+function mapDataError(err) {
+  if (!(err instanceof DataApiError)) {
+    return err;
+  }
+  if (err.status === 429) {
+    return errRateLimited();
+  }
+  if (err.status === 401 || err.status === 403) {
+    return errInvalidAPIKey(err.message);
+  }
+  return errNetwork(`HTTP ${err.status}: ${err.message}`);
+}
+
 // src/commands/solana.ts
 function registerReservedSolanaCommand(args) {
   args.cmd.command(args.signature).description(args.description).action(() => {
@@ -5159,6 +5637,7 @@ function registerSolana(program2) {
   registerSolanaProgram(cmd);
   registerSolanaDelegate(cmd);
   registerStatus(cmd, { networkMode: "solana" });
+  registerSolanaRpcSurfaceCommands(program2, cmd);
   registerReservedSolanaCommands(cmd);
 }
 
@@ -7110,6 +7589,7 @@ function registerData(program2) {
   registerTransfers(cmd);
   registerPrices(cmd);
   registerPortfolio(cmd);
+  registerDataSurfaceCommands(program2, cmd);
 }
 
 // src/commands/debug.ts
@@ -7409,7 +7889,7 @@ Tip: use 'alchemy evm tx <hash>' for transaction details (value, block, nonce).
 
 // src/commands/rpc.ts
 function registerRPC(program2) {
-  program2.command("rpc").argument("<method>", "JSON-RPC method name (e.g. eth_blockNumber)").argument("[params...]", "Method parameters as JSON values").description("Make a raw JSON-RPC call").addHelpText(
+  const cmd = program2.command("rpc").argument("<method>", "JSON-RPC method name (e.g. eth_blockNumber)").argument("[params...]", "Method parameters as JSON values").description("Make a raw JSON-RPC call").addHelpText(
     "after",
     `
 Examples:
@@ -7418,6 +7898,9 @@ Examples:
   alchemy evm rpc eth_getBlockByNumber "0x1" true`
   ).action(async (method, params) => {
     try {
+      if (outputRpcHelp(cmd, method, params)) {
+        return;
+      }
       const client = clientFromFlags(program2);
       const parsed = params.map((p) => {
         try {
@@ -7437,6 +7920,24 @@ Examples:
       exitWithError(err);
     }
   });
+  registerEvmRpcSurfaceCommands(program2, cmd);
+}
+function outputRpcHelp(cmd, method, params) {
+  if (method !== "help") {
+    return false;
+  }
+  const [topic] = params;
+  if (!topic) {
+    cmd.outputHelp();
+    return true;
+  }
+  const subcommand = cmd.commands.find((command) => command.name() === topic);
+  if (subcommand) {
+    subcommand.outputHelp();
+    return true;
+  }
+  cmd.outputHelp();
+  return true;
 }
 
 // src/commands/send-evm.ts
@@ -7470,7 +7971,7 @@ Examples:
         dryRun: opts.dryRun
       });
     } catch (err) {
-      const { exitWithError: exitWithError2 } = await import("./errors-T6XE2I2L.js");
+      const { exitWithError: exitWithError2 } = await import("./errors-YPNK3AVF.js");
       exitWithError2(err);
     }
   });
@@ -9387,7 +9888,7 @@ async function flushProcessOutput() {
 }
 program.name("alchemy").description(
   "The Alchemy CLI lets you query blockchain data, call JSON-RPC methods, and manage your Alchemy configuration."
-).version("0.9.2", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
+).version("0.9.3", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
   "-n, --network <network>",
   "Target network (default: eth-mainnet) (env: ALCHEMY_NETWORK)"
 ).option("--x402", "Use x402 wallet-based gateway auth").option(
@@ -9574,11 +10075,11 @@ ${styledLine}`;
     "wallet"
   ];
   if (!skipAppPrompt.includes(cmdName) && isInteractiveAllowed(program) && !opts.apiKey && !process.env.ALCHEMY_API_KEY) {
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-FQ66OWT7.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-REZCFZZ7.js");
     const authToken = resolveAuthToken2(cfg);
     const hasApiKey = Boolean(cfg.api_key?.trim() || cfg.app?.apiKey);
     if (authToken && !hasApiKey) {
-      const { selectAppAfterAuth } = await import("./auth-6BBITIOZ.js");
+      const { selectAppAfterAuth } = await import("./auth-23OYLRWN.js");
       console.log("");
       console.log(`  No app selected. Please select an app to continue.`);
       await selectAppAfterAuth(authToken);
@@ -9613,7 +10114,7 @@ ${styledLine}`;
   if (isInteractiveAllowed(program)) {
     let latestForInteractiveStartup = null;
     if (shouldRunOnboarding(program, cfg)) {
-      const { runOnboarding } = await import("./onboarding-CW7XGRE4.js");
+      const { runOnboarding } = await import("./onboarding-IJQ72DK7.js");
       const latest = getAvailableUpdateOnce();
       const completed = await runOnboarding(program, latest);
       updateShownDuringInteractiveStartup = Boolean(latest);
@@ -9627,7 +10128,7 @@ ${styledLine}`;
         latestForInteractiveStartup
       );
     }
-    const { startREPL } = await import("./interactive-IBR6RN74.js");
+    const { startREPL } = await import("./interactive-KLVEYTQM.js");
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {