@secondlayer/cli 1.4.1 → 1.6.0

package/dist/cli.js

@@ -5,25 +5,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -2202,8 +2220,8 @@ function migrateConfig(raw) {
   if (typeof old.apiKey === "string") {
     migrated.apiKey = old.apiKey;
   }
-  if (typeof old.sessionToken === "string") {
-    migrated.sessionToken = old.sessionToken;
+  if (typeof old.sessionToken === "string" && !migrated.apiKey) {
+    console.warn("Warning: config contains sessionToken but no apiKey. Run `sl auth login` to re-authenticate.");
   }
   if (typeof old.apiUrl === "string" && old.apiUrl !== "http://localhost:3800") {
     migrated.apiUrl = old.apiUrl;
@@ -2268,9 +2286,6 @@ function applyEnvOverrides(config) {
   if (process.env.SECONDLAYER_API_KEY) {
     result.apiKey = process.env.SECONDLAYER_API_KEY;
   }
-  if (process.env.SECONDLAYER_SESSION_TOKEN) {
-    result.sessionToken = process.env.SECONDLAYER_SESSION_TOKEN;
-  }
   if (process.env.SL_DATA_DIR) {
     result.dataDir = process.env.SL_DATA_DIR;
   }
@@ -2406,7 +2421,6 @@ var init_config = __esm(() => {
     network: NetworkSchema.default("mainnet"),
     apiUrl: z.string().url().optional(),
     apiKey: z.string().optional(),
-    sessionToken: z.string().optional(),
     dataDir: z.string().default("~/.secondlayer/data"),
     defaultWebhookUrl: z.string().url().optional(),
     node: NodeSchema.optional(),
@@ -4533,27 +4547,42 @@ __export(exports_api_client, {
   rotateSecret: () => rotateSecret,
   resumeAllStreams: () => resumeAllStreams,
   resolveStreamId: () => resolveStreamId,
-  reindexViewApi: () => reindexViewApi,
-  queryViewTableCount: () => queryViewTableCount,
-  queryViewTable: () => queryViewTable,
+  reindexSubgraphApi: () => reindexSubgraphApi,
+  querySubgraphTableCount: () => querySubgraphTableCount,
+  querySubgraphTable: () => querySubgraphTable,
   pauseAllStreams: () => pauseAllStreams,
-  listViewsApi: () => listViewsApi,
+  listSubgraphsApi: () => listSubgraphsApi,
   listStreams: () => listStreams,
   handleApiError: () => handleApiError,
-  getViewApi: () => getViewApi,
+  getSubgraphApi: () => getSubgraphApi,
   getStream: () => getStream,
   getQueueStats: () => getQueueStats,
   enableStream: () => enableStream,
   disableStream: () => disableStream,
-  deployViewApi: () => deployViewApi,
-  deleteViewApi: () => deleteViewApi,
+  deploySubgraphApi: () => deploySubgraphApi,
+  deleteSubgraphApi: () => deleteSubgraphApi,
   deleteStream: () => deleteStream,
   createStream: () => createStream,
   authHeaders: () => authHeaders,
+  assertOk: () => assertOk,
   ApiError: () => ApiError
 });
 import { SecondLayer } from "@secondlayer/sdk";
 import { ApiError } from "@secondlayer/sdk";
+async function assertOk(res) {
+  if (res.ok)
+    return;
+  const body = await res.text();
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed.error === "string" && parsed.error)
+      throw new Error(parsed.error);
+  } catch (e) {
+    if (e instanceof Error && e.message !== body)
+      throw e;
+  }
+  throw new Error(`HTTP ${res.status}`);
+}
 function handleApiError(err, action) {
   if (err instanceof ApiError && err.status === 401) {
     console.error("Error: Authentication required. Run: sl auth login");
@@ -4565,10 +4594,10 @@ function handleApiError(err, action) {
 async function getClient() {
   const config = await loadConfig();
   const baseUrl = resolveApiUrl(config);
-  return new SecondLayer({ baseUrl, apiKey: config.sessionToken ?? config.apiKey });
+  return new SecondLayer({ baseUrl, apiKey: config.apiKey });
 }
 function authHeaders(config) {
-  return SecondLayer.authHeaders(config.sessionToken ?? config.apiKey);
+  return SecondLayer.authHeaders(config.apiKey);
 }
 async function createStream(data) {
   return (await getClient()).streams.create(data);
@@ -4609,26 +4638,26 @@ async function resumeAllStreams() {
 async function getQueueStats() {
   return (await getClient()).getQueueStats();
 }
-async function listViewsApi() {
-  return (await getClient()).views.list();
+async function listSubgraphsApi() {
+  return (await getClient()).subgraphs.list();
 }
-async function getViewApi(name) {
-  return (await getClient()).views.get(name);
+async function getSubgraphApi(name) {
+  return (await getClient()).subgraphs.get(name);
 }
-async function reindexViewApi(name, options) {
-  return (await getClient()).views.reindex(name, options);
+async function reindexSubgraphApi(name, options) {
+  return (await getClient()).subgraphs.reindex(name, options);
 }
-async function deleteViewApi(name) {
-  return (await getClient()).views.delete(name);
+async function deleteSubgraphApi(name) {
+  return (await getClient()).subgraphs.delete(name);
 }
-async function deployViewApi(data) {
-  return (await getClient()).views.deploy(data);
+async function deploySubgraphApi(data) {
+  return (await getClient()).subgraphs.deploy(data);
 }
-async function queryViewTable(name, table, params = {}) {
-  return (await getClient()).views.queryTable(name, table, params);
+async function querySubgraphTable(name, table, params = {}) {
+  return (await getClient()).subgraphs.queryTable(name, table, params);
 }
-async function queryViewTableCount(name, table, params = {}) {
-  return (await getClient()).views.queryTableCount(name, table, params);
+async function querySubgraphTableCount(name, table, params = {}) {
+  return (await getClient()).subgraphs.queryTableCount(name, table, params);
 }
 var init_api_client = __esm(() => {
   init_config();
@@ -6363,7 +6392,7 @@ var init_responselike = __esm(() => {
 
 // ../../node_modules/json-buffer/index.js
 var require_json_buffer = __commonJS((exports) => {
-  exports.stringify = function stringify(o) {
+  exports.stringify = function stringify2(o) {
     if (typeof o == "undefined")
       return o;
     if (o && Buffer.isBuffer(o))
@@ -6385,9 +6414,9 @@ var require_json_buffer = __commonJS((exports) => {
             if (o[k] == undefined)
               s += "null";
             else
-              s += stringify(o[k]);
+              s += stringify2(o[k]);
           } else if (o[k] !== undefined) {
-            s += stringify(k) + ":" + stringify(o[k]);
+            s += stringify2(k) + ":" + stringify2(o[k]);
           }
         }
       }
@@ -7331,7 +7360,7 @@ var init_FormDataEncoder = __esm(() => {
         }
       }
     }
-    [(_FormDataEncoder_CRLF = new WeakMap, _FormDataEncoder_CRLF_BYTES = new WeakMap, _FormDataEncoder_CRLF_BYTES_LENGTH = new WeakMap, _FormDataEncoder_DASHES = new WeakMap, _FormDataEncoder_encoder = new WeakMap, _FormDataEncoder_footer = new WeakMap, _FormDataEncoder_form = new WeakMap, _FormDataEncoder_options = new WeakMap, _FormDataEncoder_instances = new WeakSet, _FormDataEncoder_getFieldHeader = function _FormDataEncoder_getFieldHeader(name, value) {
+    [(_FormDataEncoder_CRLF = new WeakMap, _FormDataEncoder_CRLF_BYTES = new WeakMap, _FormDataEncoder_CRLF_BYTES_LENGTH = new WeakMap, _FormDataEncoder_DASHES = new WeakMap, _FormDataEncoder_encoder = new WeakMap, _FormDataEncoder_footer = new WeakMap, _FormDataEncoder_form = new WeakMap, _FormDataEncoder_options = new WeakMap, _FormDataEncoder_instances = new WeakSet, _FormDataEncoder_getFieldHeader = function _FormDataEncoder_getFieldHeader2(name, value) {
       let header = "";
       header += `${__classPrivateFieldGet(this, _FormDataEncoder_DASHES, "f")}${this.boundary}${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")}`;
       header += `Content-Disposition: form-data; name="${escapeName(name)}"`;
@@ -7344,7 +7373,7 @@ var init_FormDataEncoder = __esm(() => {
         header += `${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f")}Content-Length: ${isFile(value) ? value.size : value.byteLength}`;
       }
       return __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(`${header}${__classPrivateFieldGet(this, _FormDataEncoder_CRLF, "f").repeat(2)}`);
-    }, _FormDataEncoder_getContentLength = function _FormDataEncoder_getContentLength() {
+    }, _FormDataEncoder_getContentLength = function _FormDataEncoder_getContentLength2() {
       let length = 0;
       for (const [name, raw] of __classPrivateFieldGet(this, _FormDataEncoder_form, "f")) {
         const value = isFile(raw) ? raw : __classPrivateFieldGet(this, _FormDataEncoder_encoder, "f").encode(normalizeValue(raw));
@@ -13247,21 +13276,21 @@ var init_webhook_server = __esm(() => {
   init_output();
 });
 
-// src/services/view-processor.ts
+// src/services/subgraph-processor.ts
 import { resolve as resolve5, dirname as dirname4 } from "node:path";
-async function startViewProcessor(options2) {
+async function startSubgraphProcessor(options2) {
   const rootDir = dirname4(dirname4(dirname4(dirname4(import.meta.dir))));
-  const servicePath = resolve5(rootDir, "packages/views/src/service.ts");
+  const servicePath = resolve5(rootDir, "packages/subgraphs/src/service.ts");
   await serviceManager.start(SERVICE_NAME4, ["bun", "run", "--watch", servicePath], {
     env: {
-      VIEW_CONCURRENCY: String(options2.concurrency ?? 5)
+      SUBGRAPH_CONCURRENCY: String(options2.concurrency ?? 5)
     },
     onStdout: options2.onLog,
     onStderr: options2.onLog
   });
 }
-var SERVICE_NAME4 = "view-processor";
-var init_view_processor = __esm(() => {
+var SERVICE_NAME4 = "subgraph-processor";
+var init_subgraph_processor = __esm(() => {
   init_manager();
 });
 
@@ -13272,7 +13301,7 @@ var init_services = __esm(() => {
   init_worker();
   init_api2();
   init_webhook_server();
-  init_view_processor();
+  init_subgraph_processor();
 });
 
 // src/commands/dev-impl.ts
@@ -13411,19 +13440,19 @@ async function runBackground(options2) {
       console.log(green("  ✓ Worker"), dim("processing jobs"));
     }
     {
-      const viewsLogFile = getLogFile("views");
-      const viewsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/views/src/service.ts")], {
+      const subgraphsLogFile = getLogFile("subgraphs");
+      const subgraphsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/subgraphs/src/service.ts")], {
         env: { ...process.env, ...env },
-        stdout: Bun.file(viewsLogFile),
-        stderr: Bun.file(viewsLogFile)
+        stdout: Bun.file(subgraphsLogFile),
+        stderr: Bun.file(subgraphsLogFile)
       });
-      state.services.views = {
-        pid: viewsProc.pid,
+      state.services.subgraphs = {
+        pid: subgraphsProc.pid,
         port: null,
         startedAt: new Date().toISOString(),
-        logFile: viewsLogFile
+        logFile: subgraphsLogFile
       };
-      console.log(green("  ✓ View processor"), dim("processing views"));
+      console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
     }
     if (options2.webhook) {
       const webhookLogFile = getLogFile("webhook");
@@ -13556,8 +13585,8 @@ async function runForeground(options2) {
       await startWorker({ onLog: (line) => logService("worker", line) });
       console.log(green("  ✓ Worker"), dim("processing jobs"));
     }
-    await startViewProcessor({ onLog: (line) => logService("views", line) });
-    console.log(green("  ✓ View processor"), dim("processing views"));
+    await startSubgraphProcessor({ onLog: (line) => logService("subgraphs", line) });
+    console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
     console.log("");
     printUrls(indexerPort, apiPort, webhookPort, options2.webhook);
     console.log("");
@@ -13825,20 +13854,20 @@ async function restartDev() {
     };
     console.log(green("  ✓ Webhook server"), dim(`http://localhost:${webhookPort}`));
   }
-  if (state.services.views) {
-    const viewsLogFile = getLogFile("views");
-    const viewsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/views/src/service.ts")], {
+  if (state.services.subgraphs) {
+    const subgraphsLogFile = getLogFile("subgraphs");
+    const subgraphsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/subgraphs/src/service.ts")], {
       env: { ...process.env, ...env },
-      stdout: Bun.file(viewsLogFile),
-      stderr: Bun.file(viewsLogFile)
+      stdout: Bun.file(subgraphsLogFile),
+      stderr: Bun.file(subgraphsLogFile)
     });
-    newState.services.views = {
-      pid: viewsProc.pid,
+    newState.services.subgraphs = {
+      pid: subgraphsProc.pid,
       port: null,
       startedAt: new Date().toISOString(),
-      logFile: viewsLogFile
+      logFile: subgraphsLogFile
     };
-    console.log(green("  ✓ View processor"), dim("processing views"));
+    console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
   }
   await Bun.sleep(500);
   for (const [name, service] of Object.entries(newState.services)) {
@@ -13988,7 +14017,7 @@ var init_dev_impl = __esm(() => {
     api: blue,
     indexer: cyan,
     worker: yellow,
-    views: magenta,
+    subgraphs: magenta,
     webhook: green
   };
 });
@@ -20157,6 +20186,8 @@ function isDirectFileContract(c) {
 import { promises as fs3 } from "fs";
 import path from "path";
 import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
+import { getErrorMessage } from "@secondlayer/shared";
+import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
 
 class PluginManager {
   plugins = [];
@@ -20199,12 +20230,11 @@ class PluginManager {
             success: true
           });
         } catch (error2) {
-          const err = error2;
           this.recordHookResult(plugin.name, "transformConfig", {
             success: false,
-            error: err
+            error: error2 instanceof Error ? error2 : new Error(getErrorMessage(error2))
           });
-          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${err.message}`);
+          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${getErrorMessage(error2)}`);
         }
       }
     }
@@ -20218,31 +20248,11 @@ class PluginManager {
     const processedContracts = [];
     for (let contract of contracts) {
       if (isClarinetContract(contract) && contract.abi) {
-        const address = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(address);
-        const processed = {
-          name: contract.name || parsed.contractName,
-          address: parsed.address,
-          contractName: parsed.contractName,
-          abi: contract.abi,
-          source: "local",
-          metadata: { source: "clarinet" }
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "clarinet"));
         continue;
       }
       if (isDirectFileContract(contract) && contract.abi) {
-        const address = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(address);
-        const processed = {
-          name: contract.name || parsed.contractName,
-          address: parsed.address,
-          contractName: parsed.contractName,
-          abi: contract.abi,
-          source: "local",
-          metadata: { source: "direct" }
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "direct"));
         continue;
       }
       for (const plugin of this.plugins) {
@@ -20254,27 +20264,16 @@ class PluginManager {
               success: true
             });
           } catch (error2) {
-            const err = error2;
             this.recordHookResult(plugin.name, "transformContract", {
               success: false,
-              error: err
+              error: error2 instanceof Error ? error2 : new Error(getErrorMessage(error2))
             });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${err.message}`);
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${getErrorMessage(error2)}`);
           }
         }
       }
       if (contract.abi) {
-        const addressStr = typeof contract.address === "string" ? contract.address : "";
-        const parsed = parseContractId(addressStr);
-        const processed = {
-          name: contract.name || parsed.contractName || "unknown",
-          address: parsed.address || "unknown",
-          contractName: parsed.contractName || contract.name || "unknown",
-          abi: contract.abi,
-          source: "api",
-          metadata: contract.metadata
-        };
-        processedContracts.push(processed);
+        processedContracts.push(this.contractToProcessed(contract, "api"));
       }
     }
     return processedContracts;
@@ -20290,12 +20289,11 @@ class PluginManager {
             success: true
           });
         } catch (error2) {
-          const err = error2;
           this.recordHookResult(plugin.name, hookName, {
             success: false,
-            error: err
+            error: error2 instanceof Error ? error2 : new Error(getErrorMessage(error2))
           });
-          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`);
+          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${getErrorMessage(error2)}`);
         }
       }
     }
@@ -20335,12 +20333,11 @@ class PluginManager {
               success: true
             });
           } catch (error2) {
-            const err = error2;
             this.recordHookResult(plugin.name, "transformOutput", {
               success: false,
-              error: err
+              error: error2 instanceof Error ? error2 : new Error(getErrorMessage(error2))
             });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${err.message}`);
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${getErrorMessage(error2)}`);
           }
         }
       }
@@ -20358,15 +20355,26 @@ class PluginManager {
         await this.utils.ensureDir(path.dirname(resolvedPath));
         await this.utils.writeFile(resolvedPath, output.content);
       } catch (error2) {
-        const err = error2;
-        this.logger.error(`Failed to write ${output.path}: ${err.message}`);
-        throw err;
+        this.logger.error(`Failed to write ${output.path}: ${getErrorMessage(error2)}`);
+        throw error2;
       }
     }
   }
   getExecutionResults() {
     return new Map(this.executionContext.results);
   }
+  contractToProcessed(contract, source) {
+    const address = typeof contract.address === "string" ? contract.address : "";
+    const parsed = parseContractId(address);
+    return {
+      name: contract.name || parsed.contractName || "unknown",
+      address: parsed.address || "unknown",
+      contractName: parsed.contractName || contract.name || "unknown",
+      abi: contract.abi,
+      source: source === "api" ? "api" : "local",
+      metadata: contract.metadata ?? { source }
+    };
+  }
   augmentOutput(outputs, outputKey, contractName, content) {
     const existing = outputs.get(outputKey);
     if (!existing) {
@@ -20403,9 +20411,7 @@ ${JSON.stringify(content, null, 2)}`;
   }
   createUtils() {
     return {
-      toCamelCase: (str) => {
-        return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-      },
+      toCamelCase: toCamelCase2,
       toKebabCase: (str) => {
         return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
       },
@@ -20554,7 +20560,7 @@ var init_config2 = __esm(() => {
 
 // src/utils/type-mapping.ts
 import {
-  toCamelCase,
+  toCamelCase as toCamelCase3,
   isAbiList,
   isAbiTuple,
   isAbiOptional as isAbiOptional2,
@@ -20613,7 +20619,7 @@ function clarityTypeToTS(type) {
     return `${innerType}[]`;
   }
   if (isAbiTuple(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
     return `{ ${fields} }`;
   }
   if (isAbiResponse(type)) {
@@ -20630,7 +20636,7 @@ var init_type_mapping = () => {};
 
 // src/utils/clarity-conversion.ts
 import {
-  toCamelCase as toCamelCase2,
+  toCamelCase as toCamelCase4,
   isAbiStringAscii as isAbiStringAscii3,
   isAbiStringUtf8 as isAbiStringUtf83,
   isAbiBuffer as isAbiBuffer3,
@@ -20728,7 +20734,7 @@ function generateClarityConversion(argName, argType) {
     const requiredFields = type.tuple.map((f) => f.name);
     const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase2(field.name);
+      const camelFieldName = toCamelCase4(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20769,11 +20775,11 @@ function generateClarityConversion(argName, argType) {
 var init_clarity_conversion = () => {};
 
 // src/utils/generator-helpers.ts
-import { toCamelCase as toCamelCase3, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase5, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
 function generateMapKeyConversion(keyType) {
   if (isAbiTuple3(keyType)) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase3(field.name);
+      const camelFieldName = toCamelCase5(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20788,7 +20794,7 @@ var init_generator_helpers = __esm(() => {
 
 // src/generators/contract.ts
 import {
-  toCamelCase as toCamelCase4
+  toCamelCase as toCamelCase6
 } from "@secondlayer/stacks/clarity";
 function generateNetworkUtils() {
   return `/**
@@ -20880,7 +20886,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase6(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -20893,7 +20899,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase4(originalArgName);
+    const argName = toCamelCase6(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -20909,17 +20915,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase6(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase6(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase4(arg.name);
+    const argName = toCamelCase6(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase6(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -20941,7 +20947,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase4(map.name);
+    const methodName = toCamelCase6(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -21002,7 +21008,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase4(variable.name);
+    const methodName = toCamelCase6(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -21047,7 +21053,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase4(constant.name);
+    const methodName = toCamelCase6(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -21143,23 +21149,23 @@ var require_ansis = __commonJS((exports, module) => {
     }, s2 = t2, c2 = l2;
     return e2 && (s2 = e2.o + t2, c2 = l2 + e2.c), n(o2, r), o2.p = { open: t2, close: l2, o: s2, c: c2, p: e2 }, o2.open = s2, o2.close = c2, o2;
   };
-  var w = new function e(t2 = f) {
-    let s2 = { Ansis: e, level: t2, isSupported: () => a2, strip: (e2) => e2.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i), extend(e2) {
-      for (let t3 in e2) {
-        let r2 = e2[t3], l2 = (typeof r2)[0];
+  var w = new function e2(t2 = f) {
+    let s2 = { Ansis: e2, level: t2, isSupported: () => a2, strip: (e3) => e3.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, i), extend(e3) {
+      for (let t3 in e3) {
+        let r2 = e3[t3], l2 = (typeof r2)[0];
         l2 === "s" ? (c2(t3, T(...p(r2))), c2(_(t3), v(...p(r2)))) : c2(t3, r2, l2 === "f");
       }
       return r = o({}, O), n(s2, r), s2;
-    } }, c2 = (e2, t3, r2) => {
-      O[e2] = { get() {
-        let n2 = r2 ? (...e3) => m(this, t3(...e3)) : m(this, t3);
-        return l(this, e2, { value: n2 }), n2;
+    } }, c2 = (e3, t3, r2) => {
+      O[e3] = { get() {
+        let n2 = r2 ? (...e4) => m(this, t3(...e4)) : m(this, t3);
+        return l(this, e3, { value: n2 }), n2;
       } };
-    }, a2 = t2 > 0, w2 = (e2, t3) => a2 ? { open: `\x1B[${e2}m`, close: `\x1B[${t3}m` } : g, y = (e2) => (t3) => e2(...p(t3)), R = (e2, t3) => (r2, l2, n2) => w2(`${e2}8;2;${r2};${l2};${n2}`, t3), $ = (e2, t3) => (r2, l2, n2) => w2(((e3, t4, r3) => d(u(e3, t4, r3)))(r2, l2, n2) + e2, t3), x = (e2) => (t3, r2, l2) => e2(u(t3, r2, l2)), T = R(3, h), v = R(4, b2), C = (e2) => w2("38;5;" + e2, h), E = (e2) => w2("48;5;" + e2, b2);
-    t2 === 2 ? (T = x(C), v = x(E)) : t2 === 1 && (T = $(0, h), v = $(10, b2), C = (e2) => w2(d(e2), h), E = (e2) => w2(d(e2) + 10, b2));
-    let M, I = { fg: C, bg: E, rgb: T, bgRgb: v, hex: y(T), bgHex: y(v), visible: g, reset: w2(0, 0), bold: w2(1, 22), dim: w2(2, 22), italic: w2(3, 23), underline: w2(4, 24), inverse: w2(7, 27), hidden: w2(8, 28), strikethrough: w2(9, 29) }, _ = (e2) => "bg" + e2[0].toUpperCase() + e2.slice(1), k = "Bright";
-    return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map((e2, t3) => {
-      M = _(e2), 8 > t3 ? (I[e2 + k] = w2(90 + t3, h), I[M + k] = w2(100 + t3, b2)) : t3 = 60, I[e2] = w2(30 + t3, h), I[M] = w2(40 + t3, b2);
+    }, a2 = t2 > 0, w2 = (e3, t3) => a2 ? { open: `\x1B[${e3}m`, close: `\x1B[${t3}m` } : g, y = (e3) => (t3) => e3(...p(t3)), R = (e3, t3) => (r2, l2, n2) => w2(`${e3}8;2;${r2};${l2};${n2}`, t3), $ = (e3, t3) => (r2, l2, n2) => w2(((e4, t4, r3) => d(u(e4, t4, r3)))(r2, l2, n2) + e3, t3), x = (e3) => (t3, r2, l2) => e3(u(t3, r2, l2)), T = R(3, h), v = R(4, b2), C = (e3) => w2("38;5;" + e3, h), E = (e3) => w2("48;5;" + e3, b2);
+    t2 === 2 ? (T = x(C), v = x(E)) : t2 === 1 && (T = $(0, h), v = $(10, b2), C = (e3) => w2(d(e3), h), E = (e3) => w2(d(e3) + 10, b2));
+    let M, I = { fg: C, bg: E, rgb: T, bgRgb: v, hex: y(T), bgHex: y(v), visible: g, reset: w2(0, 0), bold: w2(1, 22), dim: w2(2, 22), italic: w2(3, 23), underline: w2(4, 24), inverse: w2(7, 27), hidden: w2(8, 28), strikethrough: w2(9, 29) }, _ = (e3) => "bg" + e3[0].toUpperCase() + e3.slice(1), k = "Bright";
+    return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map((e3, t3) => {
+      M = _(e3), 8 > t3 ? (I[e3 + k] = w2(90 + t3, h), I[M + k] = w2(100 + t3, b2)) : t3 = 60, I[e3] = w2(30 + t3, h), I[M] = w2(40 + t3, b2);
     }), s2.extend(I);
   };
   module.exports = w, w.default = w;
@@ -21171,302 +21177,11 @@ var init_ansis = __esm(() => {
   import__2 = __toESM(require_ansis(), 1);
 });
 
-// ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/commands.mjs
-function dashDashArg(agent, agentCommand) {
-  return (args) => {
-    if (args.length > 1) {
-      return [agent, agentCommand, args[0], "--", ...args.slice(1)];
-    } else {
-      return [agent, agentCommand, args[0]];
-    }
-  };
-}
-function denoExecute() {
-  return (args) => {
-    return ["deno", "run", `npm:${args[0]}`, ...args.slice(1)];
-  };
-}
-var npm, yarn, yarnBerry, pnpm, bun, deno, COMMANDS;
-var init_commands = __esm(() => {
-  npm = {
-    agent: ["npm", 0],
-    run: dashDashArg("npm", "run"),
-    install: ["npm", "i", 0],
-    frozen: ["npm", "ci", 0],
-    global: ["npm", "i", "-g", 0],
-    add: ["npm", "i", 0],
-    upgrade: ["npm", "update", 0],
-    "upgrade-interactive": null,
-    dedupe: ["npm", "dedupe", 0],
-    execute: ["npx", 0],
-    "execute-local": ["npx", 0],
-    uninstall: ["npm", "uninstall", 0],
-    global_uninstall: ["npm", "uninstall", "-g", 0]
-  };
-  yarn = {
-    agent: ["yarn", 0],
-    run: ["yarn", "run", 0],
-    install: ["yarn", "install", 0],
-    frozen: ["yarn", "install", "--frozen-lockfile", 0],
-    global: ["yarn", "global", "add", 0],
-    add: ["yarn", "add", 0],
-    upgrade: ["yarn", "upgrade", 0],
-    "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
-    dedupe: null,
-    execute: ["npx", 0],
-    "execute-local": dashDashArg("yarn", "exec"),
-    uninstall: ["yarn", "remove", 0],
-    global_uninstall: ["yarn", "global", "remove", 0]
-  };
-  yarnBerry = {
-    ...yarn,
-    frozen: ["yarn", "install", "--immutable", 0],
-    upgrade: ["yarn", "up", 0],
-    "upgrade-interactive": ["yarn", "up", "-i", 0],
-    dedupe: ["yarn", "dedupe", 0],
-    execute: ["yarn", "dlx", 0],
-    "execute-local": ["yarn", "exec", 0],
-    global: ["npm", "i", "-g", 0],
-    global_uninstall: ["npm", "uninstall", "-g", 0]
-  };
-  pnpm = {
-    agent: ["pnpm", 0],
-    run: ["pnpm", "run", 0],
-    install: ["pnpm", "i", 0],
-    frozen: ["pnpm", "i", "--frozen-lockfile", 0],
-    global: ["pnpm", "add", "-g", 0],
-    add: ["pnpm", "add", 0],
-    upgrade: ["pnpm", "update", 0],
-    "upgrade-interactive": ["pnpm", "update", "-i", 0],
-    dedupe: ["pnpm", "dedupe", 0],
-    execute: ["pnpm", "dlx", 0],
-    "execute-local": ["pnpm", "exec", 0],
-    uninstall: ["pnpm", "remove", 0],
-    global_uninstall: ["pnpm", "remove", "--global", 0]
-  };
-  bun = {
-    agent: ["bun", 0],
-    run: ["bun", "run", 0],
-    install: ["bun", "install", 0],
-    frozen: ["bun", "install", "--frozen-lockfile", 0],
-    global: ["bun", "add", "-g", 0],
-    add: ["bun", "add", 0],
-    upgrade: ["bun", "update", 0],
-    "upgrade-interactive": ["bun", "update", "-i", 0],
-    dedupe: null,
-    execute: ["bun", "x", 0],
-    "execute-local": ["bun", "x", 0],
-    uninstall: ["bun", "remove", 0],
-    global_uninstall: ["bun", "remove", "-g", 0]
-  };
-  deno = {
-    agent: ["deno", 0],
-    run: ["deno", "task", 0],
-    install: ["deno", "install", 0],
-    frozen: ["deno", "install", "--frozen", 0],
-    global: ["deno", "install", "-g", 0],
-    add: ["deno", "add", 0],
-    upgrade: ["deno", "outdated", "--update", 0],
-    "upgrade-interactive": ["deno", "outdated", "--update", 0],
-    dedupe: null,
-    execute: denoExecute(),
-    "execute-local": ["deno", "task", "--eval", 0],
-    uninstall: ["deno", "remove", 0],
-    global_uninstall: ["deno", "uninstall", "-g", 0]
-  };
-  COMMANDS = {
-    npm,
-    yarn,
-    "yarn@berry": yarnBerry,
-    pnpm,
-    "pnpm@6": {
-      ...pnpm,
-      run: dashDashArg("pnpm", "run")
-    },
-    bun,
-    deno
-  };
-});
-
-// ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/constants.mjs
-var AGENTS, LOCKS, INSTALL_METADATA, INSTALL_PAGE;
-var init_constants = __esm(() => {
-  AGENTS = [
-    "npm",
-    "yarn",
-    "yarn@berry",
-    "pnpm",
-    "pnpm@6",
-    "bun",
-    "deno"
-  ];
-  LOCKS = {
-    "bun.lock": "bun",
-    "bun.lockb": "bun",
-    "deno.lock": "deno",
-    "pnpm-lock.yaml": "pnpm",
-    "pnpm-workspace.yaml": "pnpm",
-    "yarn.lock": "yarn",
-    "package-lock.json": "npm",
-    "npm-shrinkwrap.json": "npm"
-  };
-  INSTALL_METADATA = {
-    "node_modules/.deno/": "deno",
-    "node_modules/.pnpm/": "pnpm",
-    "node_modules/.yarn-state.yml": "yarn",
-    "node_modules/.yarn_integrity": "yarn",
-    "node_modules/.package-lock.json": "npm",
-    ".pnp.cjs": "yarn",
-    ".pnp.js": "yarn",
-    "bun.lock": "bun",
-    "bun.lockb": "bun"
-  };
-  INSTALL_PAGE = {
-    bun: "https://bun.sh",
-    deno: "https://deno.com",
-    pnpm: "https://pnpm.io/installation",
-    "pnpm@6": "https://pnpm.io/6.x/installation",
-    yarn: "https://classic.yarnpkg.com/en/docs/install",
-    "yarn@berry": "https://yarnpkg.com/getting-started/install",
-    npm: "https://docs.npmjs.com/cli/configuring-npm/install"
-  };
-});
-
-// ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/detect.mjs
-import fs5 from "node:fs/promises";
-import path3 from "node:path";
-import process5 from "node:process";
-async function pathExists(path22, type) {
-  try {
-    const stat2 = await fs5.stat(path22);
-    return type === "file" ? stat2.isFile() : stat2.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function* lookup(cwd = process5.cwd()) {
-  let directory = path3.resolve(cwd);
-  const { root } = path3.parse(directory);
-  while (directory && directory !== root) {
-    yield directory;
-    directory = path3.dirname(directory);
-  }
-}
-async function parsePackageJson(filepath, options2) {
-  if (!filepath || !await pathExists(filepath, "file"))
-    return null;
-  return await handlePackageManager(filepath, options2);
-}
-async function detect(options2 = {}) {
-  const {
-    cwd,
-    strategies = ["lockfile", "packageManager-field", "devEngines-field"]
-  } = options2;
-  let stopDir;
-  if (typeof options2.stopDir === "string") {
-    const resolved = path3.resolve(options2.stopDir);
-    stopDir = (dir) => dir === resolved;
-  } else {
-    stopDir = options2.stopDir;
-  }
-  for (const directory of lookup(cwd)) {
-    for (const strategy of strategies) {
-      switch (strategy) {
-        case "lockfile": {
-          for (const lock of Object.keys(LOCKS)) {
-            if (await pathExists(path3.join(directory, lock), "file")) {
-              const name = LOCKS[lock];
-              const result = await parsePackageJson(path3.join(directory, "package.json"), options2);
-              if (result)
-                return result;
-              else
-                return { name, agent: name };
-            }
-          }
-          break;
-        }
-        case "packageManager-field":
-        case "devEngines-field": {
-          const result = await parsePackageJson(path3.join(directory, "package.json"), options2);
-          if (result)
-            return result;
-          break;
-        }
-        case "install-metadata": {
-          for (const metadata of Object.keys(INSTALL_METADATA)) {
-            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
-            if (await pathExists(path3.join(directory, metadata), fileOrDir)) {
-              const name = INSTALL_METADATA[metadata];
-              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
-              return { name, agent };
-            }
-          }
-          break;
-        }
-      }
-    }
-    if (stopDir?.(directory))
-      break;
-  }
-  return null;
-}
-function getNameAndVer(pkg) {
-  const handelVer = (version) => version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
-  if (typeof pkg.packageManager === "string") {
-    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
-    return { name, ver: handelVer(ver) };
-  }
-  if (typeof pkg.devEngines?.packageManager?.name === "string") {
-    return {
-      name: pkg.devEngines.packageManager.name,
-      ver: handelVer(pkg.devEngines.packageManager.version)
-    };
-  }
-  return;
-}
-async function handlePackageManager(filepath, options2) {
-  try {
-    const content = await fs5.readFile(filepath, "utf8");
-    const pkg = options2.packageJsonParser ? await options2.packageJsonParser(content, filepath) : JSON.parse(content);
-    let agent;
-    const nameAndVer = getNameAndVer(pkg);
-    if (nameAndVer) {
-      const name = nameAndVer.name;
-      const ver = nameAndVer.ver;
-      let version = ver;
-      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
-        agent = "yarn@berry";
-        version = "berry";
-        return { name, agent, version };
-      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
-        agent = "pnpm@6";
-        return { name, agent, version };
-      } else if (AGENTS.includes(name)) {
-        agent = name;
-        return { name, agent, version };
-      } else {
-        return options2.onUnknown?.(pkg.packageManager) ?? null;
-      }
-    }
-  } catch {}
-  return null;
-}
-function isMetadataYarnClassic(metadataPath) {
-  return metadataPath.endsWith(".yarn_integrity");
-}
-var init_detect = __esm(() => {
-  init_constants();
-});
-
 // ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/index.mjs
 import"node:fs/promises";
 import"node:path";
 import"node:process";
-var init_dist3 = __esm(() => {
-  init_commands();
-  init_constants();
-  init_detect();
-});
+var init_dist3 = () => {};
 
 // ../../node_modules/tinyexec/dist/main.js
 import { createRequire as e } from "module";
@@ -22161,12 +21876,143 @@ var init_main = __esm(() => {
   q = K;
 });
 
+// ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/constants.mjs
+var INSTALL_PAGE2;
+var init_constants = __esm(() => {
+  INSTALL_PAGE2 = {
+    bun: "https://bun.sh",
+    deno: "https://deno.com",
+    pnpm: "https://pnpm.io/installation",
+    "pnpm@6": "https://pnpm.io/6.x/installation",
+    yarn: "https://classic.yarnpkg.com/en/docs/install",
+    "yarn@berry": "https://yarnpkg.com/getting-started/install",
+    npm: "https://docs.npmjs.com/cli/configuring-npm/install"
+  };
+});
+
+// ../../node_modules/@antfu/ni/node_modules/package-manager-detector/dist/commands.mjs
+function dashDashArg(agent, agentCommand) {
+  return (args) => {
+    if (args.length > 1) {
+      return [agent, agentCommand, args[0], "--", ...args.slice(1)];
+    } else {
+      return [agent, agentCommand, args[0]];
+    }
+  };
+}
+function denoExecute() {
+  return (args) => {
+    return ["deno", "run", `npm:${args[0]}`, ...args.slice(1)];
+  };
+}
+var npm, yarn, yarnBerry, pnpm, bun, deno, COMMANDS2;
+var init_commands = __esm(() => {
+  npm = {
+    agent: ["npm", 0],
+    run: dashDashArg("npm", "run"),
+    install: ["npm", "i", 0],
+    frozen: ["npm", "ci", 0],
+    global: ["npm", "i", "-g", 0],
+    add: ["npm", "i", 0],
+    upgrade: ["npm", "update", 0],
+    "upgrade-interactive": null,
+    dedupe: ["npm", "dedupe", 0],
+    execute: ["npx", 0],
+    "execute-local": ["npx", 0],
+    uninstall: ["npm", "uninstall", 0],
+    global_uninstall: ["npm", "uninstall", "-g", 0]
+  };
+  yarn = {
+    agent: ["yarn", 0],
+    run: ["yarn", "run", 0],
+    install: ["yarn", "install", 0],
+    frozen: ["yarn", "install", "--frozen-lockfile", 0],
+    global: ["yarn", "global", "add", 0],
+    add: ["yarn", "add", 0],
+    upgrade: ["yarn", "upgrade", 0],
+    "upgrade-interactive": ["yarn", "upgrade-interactive", 0],
+    dedupe: null,
+    execute: ["npx", 0],
+    "execute-local": dashDashArg("yarn", "exec"),
+    uninstall: ["yarn", "remove", 0],
+    global_uninstall: ["yarn", "global", "remove", 0]
+  };
+  yarnBerry = {
+    ...yarn,
+    frozen: ["yarn", "install", "--immutable", 0],
+    upgrade: ["yarn", "up", 0],
+    "upgrade-interactive": ["yarn", "up", "-i", 0],
+    dedupe: ["yarn", "dedupe", 0],
+    execute: ["yarn", "dlx", 0],
+    "execute-local": ["yarn", "exec", 0],
+    global: ["npm", "i", "-g", 0],
+    global_uninstall: ["npm", "uninstall", "-g", 0]
+  };
+  pnpm = {
+    agent: ["pnpm", 0],
+    run: ["pnpm", "run", 0],
+    install: ["pnpm", "i", 0],
+    frozen: ["pnpm", "i", "--frozen-lockfile", 0],
+    global: ["pnpm", "add", "-g", 0],
+    add: ["pnpm", "add", 0],
+    upgrade: ["pnpm", "update", 0],
+    "upgrade-interactive": ["pnpm", "update", "-i", 0],
+    dedupe: ["pnpm", "dedupe", 0],
+    execute: ["pnpm", "dlx", 0],
+    "execute-local": ["pnpm", "exec", 0],
+    uninstall: ["pnpm", "remove", 0],
+    global_uninstall: ["pnpm", "remove", "--global", 0]
+  };
+  bun = {
+    agent: ["bun", 0],
+    run: ["bun", "run", 0],
+    install: ["bun", "install", 0],
+    frozen: ["bun", "install", "--frozen-lockfile", 0],
+    global: ["bun", "add", "-g", 0],
+    add: ["bun", "add", 0],
+    upgrade: ["bun", "update", 0],
+    "upgrade-interactive": ["bun", "update", "-i", 0],
+    dedupe: null,
+    execute: ["bun", "x", 0],
+    "execute-local": ["bun", "x", 0],
+    uninstall: ["bun", "remove", 0],
+    global_uninstall: ["bun", "remove", "-g", 0]
+  };
+  deno = {
+    agent: ["deno", 0],
+    run: ["deno", "task", 0],
+    install: ["deno", "install", 0],
+    frozen: ["deno", "install", "--frozen", 0],
+    global: ["deno", "install", "-g", 0],
+    add: ["deno", "add", 0],
+    upgrade: ["deno", "outdated", "--update", 0],
+    "upgrade-interactive": ["deno", "outdated", "--update", 0],
+    dedupe: null,
+    execute: denoExecute(),
+    "execute-local": ["deno", "task", "--eval", 0],
+    uninstall: ["deno", "remove", 0],
+    global_uninstall: ["deno", "uninstall", "-g", 0]
+  };
+  COMMANDS2 = {
+    npm,
+    yarn,
+    "yarn@berry": yarnBerry,
+    pnpm,
+    "pnpm@6": {
+      ...pnpm,
+      run: dashDashArg("pnpm", "run")
+    },
+    bun,
+    deno
+  };
+});
+
 // ../../node_modules/@antfu/ni/dist/shared/ni.B5qNAuoI.mjs
-import path4, { join as join7, dirname as dirname6, resolve as resolve7 } from "node:path";
+import path3, { join as join7, dirname as dirname6, resolve as resolve7 } from "node:path";
 import process$1 from "node:process";
 import require$$0 from "readline";
 import require$$2 from "events";
-import fs6, { promises, existsSync as existsSync2 } from "node:fs";
+import fs5, { promises, existsSync as existsSync2 } from "node:fs";
 import require$$0$1 from "os";
 import require$$1 from "tty";
 import os4 from "node:os";
@@ -25015,10 +24861,10 @@ function requirePosix() {
   posix.sync = posix.isexe = undefined;
   const fs_1 = require$$0$2;
   const promises_1 = require$$1$1;
-  const isexe = async (path5, options2 = {}) => {
+  const isexe = async (path4, options2 = {}) => {
     const { ignoreErrors = false } = options2;
     try {
-      return checkStat(await (0, promises_1.stat)(path5), options2);
+      return checkStat(await (0, promises_1.stat)(path4), options2);
     } catch (e2) {
       const er = e2;
       if (ignoreErrors || er.code === "EACCES")
@@ -25027,10 +24873,10 @@ function requirePosix() {
     }
   };
   posix.isexe = isexe;
-  const sync = (path5, options2 = {}) => {
+  const sync = (path4, options2 = {}) => {
     const { ignoreErrors = false } = options2;
     try {
-      return checkStat((0, fs_1.statSync)(path5), options2);
+      return checkStat((0, fs_1.statSync)(path4), options2);
     } catch (e2) {
       const er = e2;
       if (ignoreErrors || er.code === "EACCES")
@@ -25067,10 +24913,10 @@ function requireWin32() {
   win32.sync = win32.isexe = undefined;
   const fs_1 = require$$0$2;
   const promises_1 = require$$1$1;
-  const isexe = async (path5, options2 = {}) => {
+  const isexe = async (path4, options2 = {}) => {
     const { ignoreErrors = false } = options2;
     try {
-      return checkStat(await (0, promises_1.stat)(path5), path5, options2);
+      return checkStat(await (0, promises_1.stat)(path4), path4, options2);
     } catch (e2) {
       const er = e2;
       if (ignoreErrors || er.code === "EACCES")
@@ -25079,10 +24925,10 @@ function requireWin32() {
     }
   };
   win32.isexe = isexe;
-  const sync = (path5, options2 = {}) => {
+  const sync = (path4, options2 = {}) => {
     const { ignoreErrors = false } = options2;
     try {
-      return checkStat((0, fs_1.statSync)(path5), path5, options2);
+      return checkStat((0, fs_1.statSync)(path4), path4, options2);
     } catch (e2) {
       const er = e2;
       if (ignoreErrors || er.code === "EACCES")
@@ -25091,7 +24937,7 @@ function requireWin32() {
     }
   };
   win32.sync = sync;
-  const checkPathExt = (path5, options2) => {
+  const checkPathExt = (path4, options2) => {
     const { pathExt = process.env.PATHEXT || "" } = options2;
     const peSplit = pathExt.split(";");
     if (peSplit.indexOf("") !== -1) {
@@ -25099,14 +24945,14 @@ function requireWin32() {
     }
     for (let i2 = 0;i2 < peSplit.length; i2++) {
       const p2 = peSplit[i2].toLowerCase();
-      const ext = path5.substring(path5.length - p2.length).toLowerCase();
+      const ext = path4.substring(path4.length - p2.length).toLowerCase();
       if (p2 && ext === p2) {
         return true;
       }
     }
     return false;
   };
-  const checkStat = (stat2, path5, options2) => stat2.isFile() && checkPathExt(path5, options2);
+  const checkStat = (stat2, path4, options2) => stat2.isFile() && checkPathExt(path4, options2);
   return win32;
 }
 function requireOptions() {
@@ -25281,7 +25127,7 @@ async function detect2({ autoInstall, programmatic, cwd } = {}) {
 `);
       if (process$1.env.CI)
         process$1.exit(1);
-      const link2 = terminalLink(name, INSTALL_PAGE[name]);
+      const link2 = terminalLink(name, INSTALL_PAGE2[name]);
       const { tryInstall } = await prompts({
         name: "tryInstall",
         type: "confirm",
@@ -25356,7 +25202,7 @@ var init_ni_B5qNAuoI = __esm(() => {
   CLI_TEMP_DIR = join7(os4.tmpdir(), "antfu-ni");
   customRcPath = process$1.env.NI_CONFIG_FILE;
   home = process$1.platform === "win32" ? process$1.env.USERPROFILE : process$1.env.HOME;
-  defaultRcPath = path4.join(home || "~/", ".nirc");
+  defaultRcPath = path3.join(home || "~/", ".nirc");
 });
 
 // ../../node_modules/@antfu/ni/dist/index.mjs
@@ -25564,10 +25410,10 @@ var init_template = __esm(() => {
 });
 
 // ../../node_modules/execa/lib/utils/standard-stream.js
-import process6 from "node:process";
+import process5 from "node:process";
 var isStandardStream = (stream2) => STANDARD_STREAMS.includes(stream2), STANDARD_STREAMS, STANDARD_STREAMS_ALIASES, getStreamName = (fdNumber) => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
 var init_standard_stream = __esm(() => {
-  STANDARD_STREAMS = [process6.stdin, process6.stdout, process6.stderr];
+  STANDARD_STREAMS = [process5.stdin, process5.stdout, process5.stderr];
   STANDARD_STREAMS_ALIASES = ["stdin", "stdout", "stderr"];
 });
 
@@ -25689,11 +25535,11 @@ var init_escape = __esm(() => {
 });
 
 // ../../node_modules/is-unicode-supported/index.js
-import process7 from "node:process";
+import process6 from "node:process";
 function isUnicodeSupported() {
-  const { env: env2 } = process7;
+  const { env: env2 } = process6;
   const { TERM, TERM_PROGRAM } = env2;
-  if (process7.platform !== "win32") {
+  if (process6.platform !== "win32") {
     return TERM !== "linux";
   }
   return Boolean(env2.WT_SESSION) || Boolean(env2.TERMINUS_SUBLIME) || env2.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env2.TERMINAL_EMULATOR === "JetBrains-JediTerm";
@@ -26055,7 +25901,6 @@ var init_base = __esm(() => {
 // ../../node_modules/yoctocolors/index.js
 var init_yoctocolors = __esm(() => {
   init_base();
-  init_base();
 });
 
 // ../../node_modules/execa/lib/verbose/default.js
@@ -26227,8 +26072,8 @@ var init_command = __esm(() => {
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs7 = __require("fs");
-  function checkPathExt(path5, options3) {
+  var fs6 = __require("fs");
+  function checkPathExt(path4, options3) {
     var pathext = options3.pathExt !== undefined ? options3.pathExt : process.env.PATHEXT;
     if (!pathext) {
       return true;
@@ -26239,25 +26084,25 @@ var require_windows = __commonJS((exports, module) => {
     }
     for (var i2 = 0;i2 < pathext.length; i2++) {
       var p2 = pathext[i2].toLowerCase();
-      if (p2 && path5.substr(-p2.length).toLowerCase() === p2) {
+      if (p2 && path4.substr(-p2.length).toLowerCase() === p2) {
         return true;
       }
     }
     return false;
   }
-  function checkStat(stat2, path5, options3) {
+  function checkStat(stat2, path4, options3) {
     if (!stat2.isSymbolicLink() && !stat2.isFile()) {
       return false;
     }
-    return checkPathExt(path5, options3);
+    return checkPathExt(path4, options3);
   }
-  function isexe(path5, options3, cb) {
-    fs7.stat(path5, function(er, stat2) {
-      cb(er, er ? false : checkStat(stat2, path5, options3));
+  function isexe(path4, options3, cb) {
+    fs6.stat(path4, function(er, stat2) {
+      cb(er, er ? false : checkStat(stat2, path4, options3));
     });
   }
-  function sync(path5, options3) {
-    return checkStat(fs7.statSync(path5), path5, options3);
+  function sync(path4, options3) {
+    return checkStat(fs6.statSync(path4), path4, options3);
   }
 });
 
@@ -26265,14 +26110,14 @@ var require_windows = __commonJS((exports, module) => {
 var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs7 = __require("fs");
-  function isexe(path5, options3, cb) {
-    fs7.stat(path5, function(er, stat2) {
+  var fs6 = __require("fs");
+  function isexe(path4, options3, cb) {
+    fs6.stat(path4, function(er, stat2) {
       cb(er, er ? false : checkStat(stat2, options3));
     });
   }
-  function sync(path5, options3) {
-    return checkStat(fs7.statSync(path5), options3);
+  function sync(path4, options3) {
+    return checkStat(fs6.statSync(path4), options3);
   }
   function checkStat(stat2, options3) {
     return stat2.isFile() && checkMode(stat2, options3);
@@ -26294,7 +26139,7 @@ var require_mode = __commonJS((exports, module) => {
 
 // ../../node_modules/isexe/index.js
 var require_isexe = __commonJS((exports, module) => {
-  var fs7 = __require("fs");
+  var fs6 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -26303,7 +26148,7 @@ var require_isexe = __commonJS((exports, module) => {
   }
   module.exports = isexe;
   isexe.sync = sync;
-  function isexe(path5, options3, cb) {
+  function isexe(path4, options3, cb) {
     if (typeof options3 === "function") {
       cb = options3;
       options3 = {};
@@ -26313,7 +26158,7 @@ var require_isexe = __commonJS((exports, module) => {
         throw new TypeError("callback not provided");
       }
       return new Promise(function(resolve8, reject) {
-        isexe(path5, options3 || {}, function(er, is2) {
+        isexe(path4, options3 || {}, function(er, is2) {
           if (er) {
             reject(er);
           } else {
@@ -26322,7 +26167,7 @@ var require_isexe = __commonJS((exports, module) => {
         });
       });
     }
-    core2(path5, options3 || {}, function(er, is2) {
+    core2(path4, options3 || {}, function(er, is2) {
       if (er) {
         if (er.code === "EACCES" || options3 && options3.ignoreErrors) {
           er = null;
@@ -26332,9 +26177,9 @@ var require_isexe = __commonJS((exports, module) => {
       cb(er, is2);
     });
   }
-  function sync(path5, options3) {
+  function sync(path4, options3) {
     try {
-      return core2.sync(path5, options3 || {});
+      return core2.sync(path4, options3 || {});
     } catch (er) {
       if (options3 && options3.ignoreErrors || er.code === "EACCES") {
         return false;
@@ -26348,7 +26193,7 @@ var require_isexe = __commonJS((exports, module) => {
 // ../../node_modules/which/which.js
 var require_which = __commonJS((exports, module) => {
   var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path5 = __require("path");
+  var path4 = __require("path");
   var COLON = isWindows ? ";" : ":";
   var isexe = require_isexe();
   var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -26384,7 +26229,7 @@ var require_which = __commonJS((exports, module) => {
         return opt.all && found.length ? resolve8(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path5.join(pathPart, cmd);
+      const pCmd = path4.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       resolve8(subStep(p2, i2, 0));
     });
@@ -26411,7 +26256,7 @@ var require_which = __commonJS((exports, module) => {
     for (let i2 = 0;i2 < pathEnv.length; i2++) {
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path5.join(pathPart, cmd);
+      const pCmd = path4.join(pathPart, cmd);
       const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
       for (let j2 = 0;j2 < pathExt.length; j2++) {
         const cur = p2 + pathExt[j2];
@@ -26452,7 +26297,7 @@ var require_path_key = __commonJS((exports, module) => {
 
 // ../../node_modules/cross-spawn/lib/util/resolveCommand.js
 var require_resolveCommand = __commonJS((exports, module) => {
-  var path5 = __require("path");
+  var path4 = __require("path");
   var which2 = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -26469,7 +26314,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     try {
       resolved = which2.sync(parsed.command, {
         path: env2[getPathKey({ env: env2 })],
-        pathExt: withoutPathExt ? path5.delimiter : undefined
+        pathExt: withoutPathExt ? path4.delimiter : undefined
       });
     } catch (e2) {} finally {
       if (shouldSwitchCwd) {
@@ -26477,7 +26322,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
       }
     }
     if (resolved) {
-      resolved = path5.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
     }
     return resolved;
   }
@@ -26522,8 +26367,8 @@ var require_shebang_command = __commonJS((exports, module) => {
     if (!match) {
       return null;
     }
-    const [path5, argument] = match[0].replace(/#! ?/, "").split(" ");
-    const binary = path5.split("/").pop();
+    const [path4, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path4.split("/").pop();
     if (binary === "env") {
       return argument;
     }
@@ -26533,16 +26378,16 @@ var require_shebang_command = __commonJS((exports, module) => {
 
 // ../../node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS((exports, module) => {
-  var fs7 = __require("fs");
+  var fs6 = __require("fs");
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size2 = 150;
     const buffer2 = Buffer.alloc(size2);
     let fd;
     try {
-      fd = fs7.openSync(command, "r");
-      fs7.readSync(fd, buffer2, 0, size2, 0);
-      fs7.closeSync(fd);
+      fd = fs6.openSync(command, "r");
+      fs6.readSync(fd, buffer2, 0, size2, 0);
+      fs6.closeSync(fd);
     } catch (e2) {}
     return shebangCommand(buffer2.toString());
   }
@@ -26551,7 +26396,7 @@ var require_readShebang = __commonJS((exports, module) => {
 
 // ../../node_modules/cross-spawn/lib/parse.js
 var require_parse3 = __commonJS((exports, module) => {
-  var path5 = __require("path");
+  var path4 = __require("path");
   var resolveCommand2 = require_resolveCommand();
   var escape2 = require_escape();
   var readShebang = require_readShebang();
@@ -26576,7 +26421,7 @@ var require_parse3 = __commonJS((exports, module) => {
     const needsShell = !isExecutableRegExp.test(commandFile);
     if (parsed.options.forceShell || needsShell) {
       const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path5.normalize(parsed.command);
+      parsed.command = path4.normalize(parsed.command);
       parsed.command = escape2.command(parsed.command);
       parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -26693,7 +26538,7 @@ function pathKey(options3 = {}) {
 // ../../node_modules/unicorn-magic/node.js
 import { promisify as promisify4 } from "node:util";
 import { execFile as execFileCallback, execFileSync as execFileSyncOriginal } from "node:child_process";
-import path5 from "node:path";
+import path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function toPath(urlOrPath) {
   return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
@@ -26701,12 +26546,12 @@ function toPath(urlOrPath) {
 function traversePathUp(startPath) {
   return {
     *[Symbol.iterator]() {
-      let currentPath = path5.resolve(toPath(startPath));
+      let currentPath = path4.resolve(toPath(startPath));
       let previousPath;
       while (previousPath !== currentPath) {
         yield currentPath;
         previousPath = currentPath;
-        currentPath = path5.resolve(currentPath, "..");
+        currentPath = path4.resolve(currentPath, "..");
       }
     }
   };
@@ -26718,38 +26563,38 @@ var init_node = __esm(() => {
 });
 
 // ../../node_modules/npm-run-path/index.js
-import process8 from "node:process";
-import path6 from "node:path";
+import process7 from "node:process";
+import path5 from "node:path";
 var npmRunPath = ({
-  cwd = process8.cwd(),
-  path: pathOption = process8.env[pathKey()],
+  cwd = process7.cwd(),
+  path: pathOption = process7.env[pathKey()],
   preferLocal = true,
-  execPath = process8.execPath,
+  execPath = process7.execPath,
   addExecPath = true
 } = {}) => {
-  const cwdPath = path6.resolve(toPath(cwd));
+  const cwdPath = path5.resolve(toPath(cwd));
   const result = [];
-  const pathParts = pathOption.split(path6.delimiter);
+  const pathParts = pathOption.split(path5.delimiter);
   if (preferLocal) {
     applyPreferLocal(result, pathParts, cwdPath);
   }
   if (addExecPath) {
     applyExecPath(result, pathParts, execPath, cwdPath);
   }
-  return pathOption === "" || pathOption === path6.delimiter ? `${result.join(path6.delimiter)}${pathOption}` : [...result, pathOption].join(path6.delimiter);
+  return pathOption === "" || pathOption === path5.delimiter ? `${result.join(path5.delimiter)}${pathOption}` : [...result, pathOption].join(path5.delimiter);
 }, applyPreferLocal = (result, pathParts, cwdPath) => {
   for (const directory of traversePathUp(cwdPath)) {
-    const pathPart = path6.join(directory, "node_modules/.bin");
+    const pathPart = path5.join(directory, "node_modules/.bin");
     if (!pathParts.includes(pathPart)) {
       result.push(pathPart);
     }
   }
 }, applyExecPath = (result, pathParts, execPath, cwdPath) => {
-  const pathPart = path6.resolve(cwdPath, toPath(execPath), "..");
+  const pathPart = path5.resolve(cwdPath, toPath(execPath), "..");
   if (!pathParts.includes(pathPart)) {
     result.push(pathPart);
   }
-}, npmRunPathEnv = ({ env: env2 = process8.env, ...options3 } = {}) => {
+}, npmRunPathEnv = ({ env: env2 = process7.env, ...options3 } = {}) => {
   env2 = { ...env2 };
   const pathName = pathKey({ env: env2 });
   options3.path = env2[pathName];
@@ -27855,7 +27700,7 @@ var init_timeout = __esm(() => {
 
 // ../../node_modules/execa/lib/methods/node.js
 import { execPath, execArgv } from "node:process";
-import path7 from "node:path";
+import path6 from "node:path";
 var mapNode = ({ options: options3 }) => {
   if (options3.node === false) {
     throw new TypeError('The "node" option cannot be false with `execaNode()`.');
@@ -27873,7 +27718,7 @@ var mapNode = ({ options: options3 }) => {
     throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
   }
   const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
-  const resolvedNodePath = path7.resolve(cwd, normalizedNodePath);
+  const resolvedNodePath = path6.resolve(cwd, normalizedNodePath);
   const newOptions = {
     ...options3,
     nodePath: resolvedNodePath,
@@ -27883,7 +27728,7 @@ var mapNode = ({ options: options3 }) => {
   if (!shouldHandleNode) {
     return [file, commandArguments, newOptions];
   }
-  if (path7.basename(file, ".exe") === "node") {
+  if (path6.basename(file, ".exe") === "node") {
     throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
   }
   return [
@@ -27974,14 +27819,14 @@ var init_encoding_option = __esm(() => {
 
 // ../../node_modules/execa/lib/arguments/cwd.js
 import { statSync } from "node:fs";
-import path8 from "node:path";
-import process9 from "node:process";
+import path7 from "node:path";
+import process8 from "node:process";
 var normalizeCwd = (cwd = getDefaultCwd()) => {
   const cwdString = safeNormalizeFileUrl(cwd, 'The "cwd" option');
-  return path8.resolve(cwdString);
+  return path7.resolve(cwdString);
 }, getDefaultCwd = () => {
   try {
-    return process9.cwd();
+    return process8.cwd();
   } catch (error2) {
     error2.message = `The current directory does not exist.
 ${error2.message}`;
@@ -28010,8 +27855,8 @@ var init_cwd = __esm(() => {
 });
 
 // ../../node_modules/execa/lib/arguments/options.js
-import path9 from "node:path";
-import process10 from "node:process";
+import path8 from "node:path";
+import process9 from "node:process";
 var import_cross_spawn, normalizeOptions = (filePath, rawArguments, rawOptions) => {
   rawOptions.cwd = normalizeCwd(rawOptions.cwd);
   const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
@@ -28028,7 +27873,7 @@ var import_cross_spawn, normalizeOptions = (filePath, rawArguments, rawOptions)
   options3.killSignal = normalizeKillSignal(options3.killSignal);
   options3.forceKillAfterDelay = normalizeForceKillAfterDelay(options3.forceKillAfterDelay);
   options3.lines = options3.lines.map((lines2, fdNumber) => lines2 && !BINARY_ENCODINGS.has(options3.encoding) && options3.buffer[fdNumber]);
-  if (process10.platform === "win32" && path9.basename(file, ".exe") === "cmd") {
+  if (process9.platform === "win32" && path8.basename(file, ".exe") === "cmd") {
     commandArguments.unshift("/q");
   }
   return { file, commandArguments, options: options3 };
@@ -28067,7 +27912,7 @@ var import_cross_spawn, normalizeOptions = (filePath, rawArguments, rawOptions)
   ipc,
   serialization
 }), getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath }) => {
-  const env2 = extendEnv ? { ...process10.env, ...envOption } : envOption;
+  const env2 = extendEnv ? { ...process9.env, ...envOption } : envOption;
   if (preferLocal || node) {
     return npmRunPathEnv({
       env: env2,
@@ -28185,10 +28030,6 @@ function i2() {
 function o2(r2) {
   return this[n2].return(r2);
 }
-function h2({ preventCancel: r2 = false } = {}) {
-  const e2 = this.getReader(), t2 = new c2(e2, r2), s2 = Object.create(u2);
-  return s2[n2] = t2, s2;
-}
 var a3, n2, u2;
 var init_asyncIterator = __esm(() => {
   a3 = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
@@ -28221,276 +28062,18 @@ var init_ponyfill = __esm(() => {
 });
 
 // ../../node_modules/get-stream/source/stream.js
-var getAsyncIterable = (stream2) => {
-  if (isReadableStream(stream2, { checkOpen: false }) && nodeImports.on !== undefined) {
-    return getStreamIterable(stream2);
-  }
-  if (typeof stream2?.[Symbol.asyncIterator] === "function") {
-    return stream2;
-  }
-  if (toString2.call(stream2) === "[object ReadableStream]") {
-    return h2.call(stream2);
-  }
-  throw new TypeError("The first argument must be a Readable, a ReadableStream, or an async iterable.");
-}, toString2, getStreamIterable = async function* (stream2) {
-  const controller = new AbortController;
-  const state = {};
-  handleStreamEnd(stream2, controller, state);
-  try {
-    for await (const [chunk] of nodeImports.on(stream2, "data", { signal: controller.signal })) {
-      yield chunk;
-    }
-  } catch (error2) {
-    if (state.error !== undefined) {
-      throw state.error;
-    } else if (!controller.signal.aborted) {
-      throw error2;
-    }
-  } finally {
-    stream2.destroy();
-  }
-}, handleStreamEnd = async (stream2, controller, state) => {
-  try {
-    await nodeImports.finished(stream2, {
-      cleanup: true,
-      readable: true,
-      writable: false,
-      error: false
-    });
-  } catch (error2) {
-    state.error = error2;
-  } finally {
-    controller.abort();
-  }
-}, nodeImports;
+var toString2, nodeImports;
 var init_stream = __esm(() => {
   init_ponyfill();
   ({ toString: toString2 } = Object.prototype);
   nodeImports = {};
 });
 
-// ../../node_modules/get-stream/source/contents.js
-var getStreamContents = async (stream2, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
-  const asyncIterable = getAsyncIterable(stream2);
-  const state = init2();
-  state.length = 0;
-  try {
-    for await (const chunk of asyncIterable) {
-      const chunkType = getChunkType(chunk);
-      const convertedChunk = convertChunk[chunkType](chunk, state);
-      appendChunk({
-        convertedChunk,
-        state,
-        getSize,
-        truncateChunk,
-        addChunk,
-        maxBuffer
-      });
-    }
-    appendFinalChunk({
-      state,
-      convertChunk,
-      getSize,
-      truncateChunk,
-      addChunk,
-      getFinalChunk,
-      maxBuffer
-    });
-    return finalize(state);
-  } catch (error2) {
-    const normalizedError = typeof error2 === "object" && error2 !== null ? error2 : new Error(error2);
-    normalizedError.bufferedData = finalize(state);
-    throw normalizedError;
-  }
-}, appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
-  const convertedChunk = getFinalChunk(state);
-  if (convertedChunk !== undefined) {
-    appendChunk({
-      convertedChunk,
-      state,
-      getSize,
-      truncateChunk,
-      addChunk,
-      maxBuffer
-    });
-  }
-}, appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
-  const chunkSize = getSize(convertedChunk);
-  const newLength = state.length + chunkSize;
-  if (newLength <= maxBuffer) {
-    addNewChunk(convertedChunk, state, addChunk, newLength);
-    return;
-  }
-  const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
-  if (truncatedChunk !== undefined) {
-    addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
-  }
-  throw new MaxBufferError;
-}, addNewChunk = (convertedChunk, state, addChunk, newLength) => {
-  state.contents = addChunk(convertedChunk, state, newLength);
-  state.length = newLength;
-}, getChunkType = (chunk) => {
-  const typeOfChunk = typeof chunk;
-  if (typeOfChunk === "string") {
-    return "string";
-  }
-  if (typeOfChunk !== "object" || chunk === null) {
-    return "others";
-  }
-  if (globalThis.Buffer?.isBuffer(chunk)) {
-    return "buffer";
-  }
-  const prototypeName = objectToString2.call(chunk);
-  if (prototypeName === "[object ArrayBuffer]") {
-    return "arrayBuffer";
-  }
-  if (prototypeName === "[object DataView]") {
-    return "dataView";
-  }
-  if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString2.call(chunk.buffer) === "[object ArrayBuffer]") {
-    return "typedArray";
-  }
-  return "others";
-}, objectToString2, MaxBufferError;
-var init_contents = __esm(() => {
-  init_stream();
-  ({ toString: objectToString2 } = Object.prototype);
-  MaxBufferError = class MaxBufferError extends Error {
-    name = "MaxBufferError";
-    constructor() {
-      super("maxBuffer exceeded");
-    }
-  };
-});
-
-// ../../node_modules/get-stream/source/utils.js
-var identity2 = (value) => value, noop5 = () => {
-  return;
-}, getContentsProperty = ({ contents }) => contents, throwObjectStream = (chunk) => {
-  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
-}, getLengthProperty = (convertedChunk) => convertedChunk.length;
-
-// ../../node_modules/get-stream/source/array.js
-async function getStreamAsArray(stream2, options3) {
-  return getStreamContents(stream2, arrayMethods, options3);
-}
-var initArray = () => ({ contents: [] }), increment = () => 1, addArrayChunk = (convertedChunk, { contents }) => {
-  contents.push(convertedChunk);
-  return contents;
-}, arrayMethods;
-var init_array = __esm(() => {
-  init_contents();
-  arrayMethods = {
-    init: initArray,
-    convertChunk: {
-      string: identity2,
-      buffer: identity2,
-      arrayBuffer: identity2,
-      dataView: identity2,
-      typedArray: identity2,
-      others: identity2
-    },
-    getSize: increment,
-    truncateChunk: noop5,
-    addChunk: addArrayChunk,
-    getFinalChunk: noop5,
-    finalize: getContentsProperty
-  };
-});
-
-// ../../node_modules/get-stream/source/array-buffer.js
-async function getStreamAsArrayBuffer(stream2, options3) {
-  return getStreamContents(stream2, arrayBufferMethods, options3);
-}
-var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) }), useTextEncoder = (chunk) => textEncoder2.encode(chunk), textEncoder2, useUint8Array = (chunk) => new Uint8Array(chunk), useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength), truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
-  const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
-  new Uint8Array(newContents).set(convertedChunk, previousLength);
-  return newContents;
-}, resizeArrayBufferSlow = (contents, length) => {
-  if (length <= contents.byteLength) {
-    return contents;
-  }
-  const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
-  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
-  return arrayBuffer;
-}, resizeArrayBuffer = (contents, length) => {
-  if (length <= contents.maxByteLength) {
-    contents.resize(length);
-    return contents;
-  }
-  const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
-  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
-  return arrayBuffer;
-}, getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR)), SCALE_FACTOR = 2, finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length), hasArrayBufferResize = () => ("resize" in ArrayBuffer.prototype), arrayBufferMethods;
-var init_array_buffer = __esm(() => {
-  init_contents();
-  textEncoder2 = new TextEncoder;
-  arrayBufferMethods = {
-    init: initArrayBuffer,
-    convertChunk: {
-      string: useTextEncoder,
-      buffer: useUint8Array,
-      arrayBuffer: useUint8Array,
-      dataView: useUint8ArrayWithOffset,
-      typedArray: useUint8ArrayWithOffset,
-      others: throwObjectStream
-    },
-    getSize: getLengthProperty,
-    truncateChunk: truncateArrayBufferChunk,
-    addChunk: addArrayBufferChunk,
-    getFinalChunk: noop5,
-    finalize: finalizeArrayBuffer
-  };
-});
-
-// ../../node_modules/get-stream/source/buffer.js
-var init_buffer = __esm(() => {
-  init_array_buffer();
-});
-
-// ../../node_modules/get-stream/source/string.js
-async function getStreamAsString(stream2, options3) {
-  return getStreamContents(stream2, stringMethods, options3);
-}
-var initString = () => ({ contents: "", textDecoder: new TextDecoder }), useTextDecoder = (chunk, { textDecoder: textDecoder2 }) => textDecoder2.decode(chunk, { stream: true }), addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk, truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), getFinalStringChunk = ({ textDecoder: textDecoder2 }) => {
-  const finalChunk = textDecoder2.decode();
-  return finalChunk === "" ? undefined : finalChunk;
-}, stringMethods;
-var init_string = __esm(() => {
-  init_contents();
-  stringMethods = {
-    init: initString,
-    convertChunk: {
-      string: identity2,
-      buffer: useTextDecoder,
-      arrayBuffer: useTextDecoder,
-      dataView: useTextDecoder,
-      typedArray: useTextDecoder,
-      others: throwObjectStream
-    },
-    getSize: getLengthProperty,
-    truncateChunk: truncateStringChunk,
-    addChunk: addStringChunk,
-    getFinalChunk: getFinalStringChunk,
-    finalize: getContentsProperty
-  };
-});
-
-// ../../node_modules/get-stream/source/exports.js
-var init_exports = __esm(() => {
-  init_array();
-  init_array_buffer();
-  init_buffer();
-  init_string();
-  init_contents();
-});
-
 // ../../node_modules/get-stream/source/index.js
 import { on } from "node:events";
 import { finished } from "node:stream/promises";
 var init_source5 = __esm(() => {
   init_stream();
-  init_exports();
   Object.assign(nodeImports, { on, finished });
 });
 
@@ -29254,7 +28837,7 @@ var init_normalize = __esm(() => {
 });
 
 // ../../node_modules/execa/lib/stdio/direction.js
-import process11 from "node:process";
+import process10 from "node:process";
 var getStreamDirection = (stdioItems, fdNumber, optionName) => {
   const directions = stdioItems.map((stdioItem) => getStdioItemDirection(stdioItem, fdNumber));
   if (directions.includes("input") && directions.includes("output")) {
@@ -29264,10 +28847,10 @@ var getStreamDirection = (stdioItems, fdNumber, optionName) => {
 }, getStdioItemDirection = ({ type, value }, fdNumber) => KNOWN_DIRECTIONS[fdNumber] ?? guessStreamDirection[type](value), KNOWN_DIRECTIONS, anyDirection = () => {
   return;
 }, alwaysInput = () => "input", guessStreamDirection, getStandardStreamDirection = (value) => {
-  if ([0, process11.stdin].includes(value)) {
+  if ([0, process10.stdin].includes(value)) {
     return "input";
   }
-  if ([1, 2, process11.stdout, process11.stderr].includes(value)) {
+  if ([1, 2, process10.stdout, process10.stderr].includes(value)) {
     return "output";
   }
 }, DEFAULT_DIRECTION = "output";
@@ -29846,11 +29429,11 @@ var getEncodingTransformGenerator = (binary, encoding, skipped) => {
     transform: encodingStringGenerator.bind(undefined, stringDecoder),
     final: encodingStringFinal.bind(undefined, stringDecoder)
   };
-}, encodingUint8ArrayGenerator = function* (textEncoder3, chunk) {
+}, encodingUint8ArrayGenerator = function* (textEncoder2, chunk) {
   if (Buffer5.isBuffer(chunk)) {
     yield bufferToUint8Array(chunk);
   } else if (typeof chunk === "string") {
-    yield textEncoder3.encode(chunk);
+    yield textEncoder2.encode(chunk);
   } else {
     yield chunk;
   }
@@ -30160,13 +29743,13 @@ var transformOutputSync = ({ fileDescriptors, syncResult: { output }, options: o
     state.error ??= error2;
   }
 }, writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-  for (const { path: path10, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-    const pathString = typeof path10 === "string" ? path10 : path10.toString();
+  for (const { path: path9, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+    const pathString = typeof path9 === "string" ? path9 : path9.toString();
     if (append || outputFiles.has(pathString)) {
-      appendFileSync(path10, serializedResult);
+      appendFileSync(path9, serializedResult);
     } else {
       outputFiles.add(pathString);
-      writeFileSync(path10, serializedResult);
+      writeFileSync(path9, serializedResult);
     }
   }
 };
@@ -30532,13 +30115,13 @@ var init_get_each = __esm(() => {
 });
 
 // ../../node_modules/execa/lib/ipc/methods.js
-import process12 from "node:process";
+import process11 from "node:process";
 var addIpcMethods = (subprocess, { ipc }) => {
   Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
 }, getIpcExport = () => {
-  const anyProcess = process12;
+  const anyProcess = process11;
   const isSubprocess = true;
-  const ipc = process12.channel !== undefined;
+  const ipc = process11.channel !== undefined;
   return {
     ...getIpcMethods(anyProcess, isSubprocess, ipc),
     getCancelSignal: getCancelSignal.bind(undefined, {
@@ -30820,13 +30403,13 @@ var getHighWaterMark = (streams, objectMode) => {
   }
 }, errorStream = (stream2, error2) => {
   if (!stream2.destroyed) {
-    stream2.once("error", noop6);
+    stream2.once("error", noop5);
     stream2.destroy(error2);
   }
-}, noop6 = () => {}, updateMaxListeners = (passThroughStream, increment2) => {
+}, noop5 = () => {}, updateMaxListeners = (passThroughStream, increment) => {
   const maxListeners = passThroughStream.getMaxListeners();
   if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
-    passThroughStream.setMaxListeners(maxListeners + increment2);
+    passThroughStream.setMaxListeners(maxListeners + increment);
   }
 }, PASSTHROUGH_LISTENERS_COUNT = 2, PASSTHROUGH_LISTENERS_PER_STREAM = 1;
 var init_merge_streams = __esm(() => {
@@ -31032,7 +30615,7 @@ class Emitter {
 
 class SignalExitBase {
 }
-var processOk = (process13) => !!process13 && typeof process13 === "object" && typeof process13.removeListener === "function" && typeof process13.emit === "function" && typeof process13.reallyExit === "function" && typeof process13.listeners === "function" && typeof process13.kill === "function" && typeof process13.pid === "number" && typeof process13.on === "function", kExitEmitter, global2, ObjectDefineProperty, signalExitWrap = (handler) => {
+var processOk = (process12) => !!process12 && typeof process12 === "object" && typeof process12.removeListener === "function" && typeof process12.emit === "function" && typeof process12.reallyExit === "function" && typeof process12.listeners === "function" && typeof process12.kill === "function" && typeof process12.pid === "number" && typeof process12.on === "function", kExitEmitter, global2, ObjectDefineProperty, signalExitWrap = (handler) => {
   return {
     onExit(cb, opts) {
       return handler.onExit(cb, opts);
@@ -31044,7 +30627,7 @@ var processOk = (process13) => !!process13 && typeof process13 === "object" && t
       return handler.unload();
     }
   };
-}, SignalExitFallback, SignalExit, process13, onExit, load, unload;
+}, SignalExitFallback, SignalExit, process12, onExit, load, unload;
 var init_mjs = __esm(() => {
   init_signals2();
   kExitEmitter = Symbol.for("signal-exit emitter");
@@ -31058,22 +30641,22 @@ var init_mjs = __esm(() => {
     unload() {}
   };
   SignalExit = class SignalExit extends SignalExitBase {
-    #hupSig = process13.platform === "win32" ? "SIGINT" : "SIGHUP";
+    #hupSig = process12.platform === "win32" ? "SIGINT" : "SIGHUP";
     #emitter = new Emitter;
     #process;
     #originalProcessEmit;
     #originalProcessReallyExit;
     #sigListeners = {};
     #loaded = false;
-    constructor(process13) {
+    constructor(process12) {
       super();
-      this.#process = process13;
+      this.#process = process12;
       this.#sigListeners = {};
       for (const sig of signals) {
         this.#sigListeners[sig] = () => {
           const listeners = this.#process.listeners(sig);
           let { count: count2 } = this.#emitter;
-          const p2 = process13;
+          const p2 = process12;
           if (typeof p2.__signal_exit_emitter__ === "object" && typeof p2.__signal_exit_emitter__.count === "number") {
             count2 += p2.__signal_exit_emitter__.count;
           }
@@ -31082,12 +30665,12 @@ var init_mjs = __esm(() => {
             const ret = this.#emitter.emit("exit", null, sig);
             const s2 = sig === "SIGHUP" ? this.#hupSig : sig;
             if (!ret)
-              process13.kill(process13.pid, s2);
+              process12.kill(process12.pid, s2);
           }
         };
       }
-      this.#originalProcessReallyExit = process13.reallyExit;
-      this.#originalProcessEmit = process13.emit;
+      this.#originalProcessReallyExit = process12.reallyExit;
+      this.#originalProcessEmit = process12.emit;
     }
     onExit(cb, opts) {
       if (!processOk(this.#process)) {
@@ -31165,12 +30748,12 @@ var init_mjs = __esm(() => {
       }
     }
   };
-  process13 = globalThis.process;
+  process12 = globalThis.process;
   ({
     onExit,
     load,
     unload
-  } = signalExitWrap(processOk(process13) ? new SignalExit(process13) : new SignalExitFallback));
+  } = signalExitWrap(processOk(process12) ? new SignalExit(process12) : new SignalExitFallback));
 });
 
 // ../../node_modules/execa/lib/terminate/cleanup.js
@@ -31556,7 +31139,7 @@ var getStreamOutput = async ({ stream: stream2, onStreamEnd, fdNumber, encoding,
     allMixed
   });
   const [output] = await Promise.all([
-    getStreamContents2({
+    getStreamContents({
       stream: stream2,
       iterable,
       fdNumber,
@@ -31590,7 +31173,7 @@ var getStreamOutput = async ({ stream: stream2, onStreamEnd, fdNumber, encoding,
   if (stream2.readableFlowing === null) {
     stream2.resume();
   }
-}, getStreamContents2 = async ({ stream: stream2, stream: { readableObjectMode }, iterable, fdNumber, encoding, maxBuffer, lines: lines2 }) => {
+}, getStreamContents = async ({ stream: stream2, stream: { readableObjectMode }, iterable, fdNumber, encoding, maxBuffer, lines: lines2 }) => {
   try {
     if (readableObjectMode || lines2) {
       return await getStreamAsArray(iterable, { maxBuffer });
@@ -31598,7 +31181,7 @@ var getStreamOutput = async ({ stream: stream2, onStreamEnd, fdNumber, encoding,
     if (encoding === "buffer") {
       return new Uint8Array(await getStreamAsArrayBuffer(iterable, { maxBuffer }));
     }
-    return await getStreamAsString(iterable, { maxBuffer });
+    return await default4(iterable, { maxBuffer });
   } catch (error2) {
     return handleBufferedData(handleMaxBuffer({
       error: error2,
@@ -31616,7 +31199,7 @@ var getStreamOutput = async ({ stream: stream2, onStreamEnd, fdNumber, encoding,
     return handleBufferedData(error2);
   }
 }, handleBufferedData = ({ bufferedData }) => isArrayBuffer(bufferedData) ? new Uint8Array(bufferedData) : bufferedData;
-var init_contents2 = __esm(() => {
+var init_contents = __esm(() => {
   init_source5();
   init_uint_array();
   init_output2();
@@ -31711,7 +31294,7 @@ var waitForStdioStreams = ({ subprocess, encoding, buffer: buffer2, maxBuffer, l
   return output;
 };
 var init_stdio = __esm(() => {
-  init_contents2();
+  init_contents();
   init_wait_stream();
 });
 
@@ -31921,7 +31504,7 @@ var init_wait_subprocess = __esm(() => {
   init_graceful2();
   init_standard_stream();
   init_type();
-  init_contents2();
+  init_contents();
   init_buffer_messages();
   init_ipc_input();
   init_all_async();
@@ -32569,8 +32152,8 @@ var init_execa = __esm(() => {
 });
 
 // src/utils/dependencies.ts
-import { promises as fs7 } from "fs";
-import path10 from "path";
+import { promises as fs6 } from "fs";
+import path9 from "path";
 async function getPackageManager(targetDir) {
   const packageManager = await detect2({ programmatic: true, cwd: targetDir });
   if (packageManager === "yarn@berry")
@@ -32585,16 +32168,16 @@ async function getPackageManager(targetDir) {
 }
 async function hasPackageJson(targetDir) {
   try {
-    const packageJsonPath = path10.join(targetDir, "package.json");
-    await fs7.access(packageJsonPath);
+    const packageJsonPath = path9.join(targetDir, "package.json");
+    await fs6.access(packageJsonPath);
     return true;
   } catch {
     return false;
   }
 }
 async function readPackageJson(targetDir) {
-  const packageJsonPath = path10.join(targetDir, "package.json");
-  const content = await fs7.readFile(packageJsonPath, "utf-8");
+  const packageJsonPath = path9.join(targetDir, "package.json");
+  const content = await fs6.readFile(packageJsonPath, "utf-8");
   return JSON.parse(content);
 }
 async function getMissingDependenciesFor(targetDir, requiredDeps) {
@@ -32647,8 +32230,9 @@ __export(exports_generate, {
   resolveContract: () => resolveContract,
   generate: () => generate
 });
-import path11 from "path";
-import { toCamelCase as toCamelCase5 } from "@secondlayer/stacks/clarity";
+import path10 from "path";
+import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
 function isContractAddress(input4) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
   return contractIdPattern.test(input4);
@@ -32671,7 +32255,7 @@ async function parseInputs(inputs) {
       continue;
     }
     if (input4.endsWith(".clar")) {
-      const absolutePath = path11.resolve(process.cwd(), input4);
+      const absolutePath = path10.resolve(process.cwd(), input4);
       files.push(absolutePath);
     }
   }
@@ -32681,7 +32265,7 @@ async function parseInputs(inputs) {
   };
 }
 function deriveContractName(filePath) {
-  const basename = path11.basename(filePath, ".clar");
+  const basename = path10.basename(filePath, ".clar");
   return basename.replace(/[-_](.)/g, (_2, char) => char.toUpperCase()).replace(/^(.)/, (_2, char) => char.toLowerCase()).replace(/^\d/, "_$&");
 }
 async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddress) {
@@ -32709,7 +32293,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
       const apiClient = new StacksApiClient(network, apiKey);
       const contractInfo = await apiClient.getContractInfo(contractId);
       const abi = parseApiResponse(contractInfo);
-      const name = toCamelCase5(contractName);
+      const name = toCamelCase7(contractName);
       contracts.push({
         name,
         address: contractId,
@@ -32717,7 +32301,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
         _directFile: true
       });
     } catch (error2) {
-      throw new Error(`Failed to fetch contract ${contractId}: ${error2.message}`);
+      throw new Error(`Failed to fetch contract ${contractId}: ${getErrorMessage2(error2)}`);
     }
   }
   return {
@@ -32799,8 +32383,8 @@ To get started:`);
   } catch (error2) {
     console.error(source_default3.red("✗ Generation failed"));
     console.error(source_default3.red(`
-${error2.message}`));
-    if (process.env.DEBUG) {
+${getErrorMessage2(error2)}`));
+    if (process.env.DEBUG && error2 instanceof Error) {
       console.error(error2.stack);
     }
     process.exit(1);
@@ -32808,9 +32392,9 @@ ${error2.message}`));
 }
 async function resolveContract(source, network, apiKey, apiUrl) {
   if (source.source) {
-    const filePath = path11.resolve(process.cwd(), source.source);
+    const filePath = path10.resolve(process.cwd(), source.source);
     const abi = await parseClarityFile(filePath);
-    const name = source.name || path11.basename(source.source, ".clar").replace(/-/g, "_").replace(/^\d/, "_$&");
+    const name = source.name || path10.basename(source.source, ".clar").replace(/-/g, "_").replace(/^\d/, "_$&");
     const address = typeof source.address === "string" ? source.address : source.address?.[network] || DEFAULT_DEVNET_ADDRESS;
     const { address: contractAddress, contractName } = address.includes(".") ? parseContractId(address) : { address, contractName: name };
     return {
@@ -32867,7 +32451,7 @@ async function resolveContracts(source, defaultNetwork, apiKey, apiUrl) {
           source: "api"
         });
       } catch (error2) {
-        console.warn(`Warning: Failed to resolve contract for ${network}: ${error2.message}`);
+        console.warn(`Warning: Failed to resolve contract for ${network}: ${getErrorMessage2(error2)}`);
       }
     }
     return resolvedContracts;
@@ -32891,12 +32475,12 @@ var exports_init = {};
 __export(exports_init, {
   init: () => init2
 });
-import { promises as fs8 } from "fs";
-import path12 from "path";
+import { promises as fs7 } from "fs";
+import path11 from "path";
 async function init2() {
-  const configPath = path12.join(process.cwd(), "secondlayer.config.ts");
+  const configPath = path11.join(process.cwd(), "secondlayer.config.ts");
   try {
-    await fs8.access(configPath);
+    await fs7.access(configPath);
     console.log(source_default3.yellow("⚠ secondlayer.config.ts already exists"));
     return;
   } catch {}
@@ -32920,13 +32504,13 @@ export default defineConfig({
   plugins: [],
 });`;
   }
-  await fs8.writeFile(configPath, config);
+  await fs7.writeFile(configPath, config);
   console.log(source_default3.green("✓ Created `secondlayer.config.ts`"));
   console.log("\nRun `secondlayer generate` to generate type-safe interfaces, functions, and hooks!");
 }
 async function fileExists2(filePath) {
   try {
-    await fs8.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -32954,8 +32538,8 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "1.4.1",
-  description: "CLI for streams, views, and real-time blockchain indexing on Stacks",
+  version: "1.6.0",
+  description: "CLI for streams, subgraphs, and real-time blockchain indexing on Stacks",
   type: "module",
   bin: {
     secondlayer: "./dist/cli.js",
@@ -32995,10 +32579,10 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
-    "@secondlayer/sdk": "^0.4.1",
-    "@secondlayer/shared": "^0.3.0",
-    "@secondlayer/stacks": "^0.1.0",
-    "@secondlayer/views": "^0.2.4",
+    "@secondlayer/sdk": "^0.6.0",
+    "@secondlayer/shared": "^0.5.0",
+    "@secondlayer/stacks": "^0.2.0",
+    "@secondlayer/subgraphs": "^0.5.0",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
     esbuild: "^0.19.0",
@@ -33387,6 +32971,7 @@ async function validateDatabaseConnection(url) {
 }
 // src/commands/setup.ts
 init_output();
+init_api_client();
 import { select as select2, input, confirm } from "@inquirer/prompts";
 init_config();
 var STREAMS_DIR = "streams";
@@ -33639,13 +33224,10 @@ async function hostedLogin(config) {
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ email })
   });
-  if (!mlRes.ok) {
-    const body = await mlRes.text();
-    let msg = `HTTP ${mlRes.status}`;
-    try {
-      msg = JSON.parse(body).error || msg;
-    } catch {}
-    error(`Failed to send magic link: ${msg}`);
+  try {
+    await assertOk(mlRes);
+  } catch (e) {
+    error(`Failed to send magic link: ${e instanceof Error ? e.message : e}`);
     return false;
   }
   info("Check your email for a login token.");
@@ -33658,18 +33240,41 @@ async function hostedLogin(config) {
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ token: token.trim() })
   });
-  if (!verifyRes.ok) {
-    const body = await verifyRes.text();
-    let msg = `HTTP ${verifyRes.status}`;
-    try {
-      msg = JSON.parse(body).error || msg;
-    } catch {}
-    error(`Verification failed: ${msg}`);
+  try {
+    await assertOk(verifyRes);
+  } catch (e) {
+    error(`Verification failed: ${e instanceof Error ? e.message : e}`);
     return false;
   }
   const result = await verifyRes.json();
-  config.sessionToken = result.sessionToken;
+  const { hostname } = await import("node:os");
+  const sessionHeaders = { Authorization: `Bearer ${result.sessionToken}`, "Content-Type": "application/json" };
+  const keyName = `cli-${hostname().toLowerCase()}`;
+  const listRes = await fetch(`${apiUrl}/api/keys`, { headers: sessionHeaders });
+  if (listRes.ok) {
+    const { keys } = await listRes.json();
+    const existing = keys.find((k) => k.name === keyName && k.status === "active");
+    if (existing) {
+      await fetch(`${apiUrl}/api/keys/${existing.id}`, { method: "DELETE", headers: sessionHeaders });
+    }
+  }
+  const createRes = await fetch(`${apiUrl}/api/keys`, {
+    method: "POST",
+    headers: sessionHeaders,
+    body: JSON.stringify({ name: keyName })
+  });
+  try {
+    await assertOk(createRes);
+  } catch (e) {
+    error(`Failed to create API key: ${e instanceof Error ? e.message : e}`);
+    return false;
+  }
+  const { key } = await createRes.json();
+  config.apiKey = key;
   await saveConfig(config);
+  try {
+    await fetch(`${apiUrl}/api/auth/logout`, { method: "POST", headers: sessionHeaders });
+  } catch {}
   const account = result.account;
   console.log();
   success(`Authenticated as ${account.email}!`);
@@ -34556,11 +34161,11 @@ function printStatus(status) {
     ["  Error", status.streams.error > 0 ? red(status.streams.error.toString()) : "0"]
   ]));
   console.log("");
-  if (status.activeViews !== undefined || status.recentDeliveries !== undefined) {
+  if (status.activeSubgraphs !== undefined || status.recentDeliveries !== undefined) {
     console.log(blue("Activity"));
     const pairs = [];
-    if (status.activeViews !== undefined)
-      pairs.push(["  Active Views", status.activeViews.toString()]);
+    if (status.activeSubgraphs !== undefined)
+      pairs.push(["  Active Subgraphs", status.activeSubgraphs.toString()]);
     if (status.recentDeliveries !== undefined)
       pairs.push(["  Deliveries (24h)", status.recentDeliveries.toString()]);
     console.log(formatKeyValue(pairs));
@@ -35444,21 +35049,21 @@ async function generatePackageJson(dir, name) {
   await Bun.write(join5(dir, "package.json"), JSON.stringify(content, null, 2) + `
 `);
 }
-// src/commands/views.ts
+// src/commands/subgraphs.ts
 init_output();
 import { resolve } from "node:path";
 import { existsSync, mkdirSync, watch } from "node:fs";
 
-// src/templates/view.ts
-function generateViewTemplate(name) {
-  return `import { defineView } from "@secondlayer/views";
+// src/templates/subgraph.ts
+function generateSubgraphTemplate(name) {
+  return `import { defineSubgraph } from "@secondlayer/subgraphs";
 
-export default defineView({
+export default defineSubgraph({
   name: "${name}",
   version: "1.0.0",
-  description: "TODO: describe what this view tracks",
+  description: "TODO: describe what this subgraph tracks",
 
-  // Sources define what blockchain data this view processes.
+  // Sources define what blockchain data this subgraph processes.
   // Each source filters transactions/events by contract, type, function, or event.
   // Examples:
   //   { contract: "SP000...::my-contract" }              — all txs to a contract
@@ -35469,7 +35074,7 @@ export default defineView({
     { contract: "SP000000000000000000002Q6VF78.pox-4" },
   ],
 
-  // Schema defines the tables this view creates.
+  // Schema defines the tables this subgraph creates.
   // Each table gets auto-columns: _id, _block_height, _tx_id, _created_at.
   // Column types: text, uint, int, principal, boolean, timestamp, jsonb
   schema: {
@@ -35500,22 +35105,22 @@ export default defineView({
 `;
 }
 
-// src/commands/views.ts
+// src/commands/subgraphs.ts
 init_api_client();
 init_config();
 init_fs();
 
-// src/generators/view-scaffold.ts
+// src/generators/subgraph-scaffold.ts
 init_format();
 
-// src/generators/clarity-to-view.ts
+// src/generators/clarity-to-subgraph.ts
 import {
   isAbiBuffer,
   isAbiStringAscii,
   isAbiStringUtf8,
   isAbiOptional
 } from "@secondlayer/stacks/clarity";
-function clarityTypeToViewColumn(abiType) {
+function clarityTypeToSubgraphColumn(abiType) {
   return mapType(abiType, false);
 }
 function mapType(abiType, nullable) {
@@ -35555,19 +35160,19 @@ function mapType(abiType, nullable) {
   return { type: "jsonb", nullable };
 }
 
-// src/generators/view-scaffold.ts
-async function generateViewScaffold(input2) {
+// src/generators/subgraph-scaffold.ts
+async function generateSubgraphScaffold(input2) {
   const { contractId, functions } = input2;
   const contractParts = contractId.split(".");
   const contractName = contractParts[contractParts.length - 1] ?? contractId;
-  const viewName = input2.viewName ?? contractName;
+  const subgraphName = input2.subgraphName ?? contractName;
   const publicFunctions = functions.filter((f) => f.access === "public");
   if (publicFunctions.length === 0) {
     throw new Error(`No public functions found in ${contractId}`);
   }
   const tables = publicFunctions.map((fn) => {
     const columns = fn.args.map((arg) => {
-      const mapped = clarityTypeToViewColumn(arg.type);
+      const mapped = clarityTypeToSubgraphColumn(arg.type);
       const nullable = mapped.nullable ? ", nullable: true" : "";
       return `        ${arg.name.replace(/-/g, "_")}: { type: '${mapped.type}'${nullable} }`;
     }).join(`,
@@ -35592,10 +35197,10 @@ ${columns || "        _placeholder: { type: 'text' }"}
 
 `);
   const code = `
-import { defineView } from '@secondlayer/views';
+import { defineSubgraph } from '@secondlayer/subgraphs';
 
-export default defineView({
-  name: '${viewName}',
+export default defineSubgraph({
+  name: '${subgraphName}',
   sources: [{ contract: '${contractId}' }],
   schema: {
 ${schemaBlock}
@@ -35608,14 +35213,25 @@ ${handlersBlock}
   return formatCode(code);
 }
 
-// src/generators/views.ts
+// src/generators/subgraphs.ts
 init_format();
-async function generateViewConsumer(viewName, detail) {
+
+// src/utils/case-conversion.ts
+import { toCamelCase } from "@secondlayer/stacks/clarity";
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toPascalCase(str) {
+  return capitalize(toCamelCase(str));
+}
+
+// src/generators/subgraphs.ts
+async function generateSubgraphConsumer(subgraphName, detail) {
   const tables = Object.entries(detail.tables);
   const rowInterfaces = tables.map(([tableName, tableDef]) => {
     const typeName = toPascalCase(tableName) + "Row";
     const fields = Object.entries(tableDef.columns).map(([colName, colMeta]) => {
-      const tsType = viewTypeToTS(colMeta.type);
+      const tsType = subgraphTypeToTS(colMeta.type);
       const optional = colMeta.nullable ? "?" : "";
       return `  ${colName}${optional}: ${tsType};`;
     }).join(`
@@ -35640,32 +35256,29 @@ ${cols}
 `);
   const code = `
 // Auto-generated by secondlayer. Do not edit.
-import { getView } from '@secondlayer/sdk';
-import type { InferViewClient } from '@secondlayer/views';
+import { getSubgraph } from '@secondlayer/sdk';
+import type { InferSubgraphClient } from '@secondlayer/subgraphs';
 
 ${rowInterfaces.join(`
 
 `)}
 
 const _schema = {
-  name: '${viewName}',
+  name: '${subgraphName}',
   schema: {
 ${schemaBlock}
   }
 } as const;
 
-export type Client = InferViewClient<typeof _schema>;
+export type Client = InferSubgraphClient<typeof _schema>;
 
 export function createClient(options?: { apiKey?: string; baseUrl?: string }): Client {
-  return getView(_schema, options ?? {});
+  return getSubgraph(_schema, options ?? {});
 }
 `.trimStart();
   return formatCode(code);
 }
-function toPascalCase(str) {
-  return str.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
-}
-function viewTypeToTS(type) {
+function subgraphTypeToTS(type) {
   switch (type) {
     case "uint":
     case "int":
@@ -35685,13 +35298,13 @@ function viewTypeToTS(type) {
   }
 }
 
-// src/commands/views.ts
+// src/commands/subgraphs.ts
 init_api();
 init_clarity();
-function registerViewsCommand(program2) {
-  const views = program2.command("views").description("Manage materialized views");
-  views.command("new <name>").description("Scaffold a new view definition file").action(async (name) => {
-    const dir = resolve("views");
+function registerSubgraphsCommand(program2) {
+  const subgraphs = program2.command("subgraphs").description("Manage materialized subgraphs");
+  subgraphs.command("new <name>").description("Scaffold a new subgraph definition file").action(async (name) => {
+    const dir = resolve("subgraphs");
     const filePath = resolve(dir, `${name}.ts`);
     if (existsSync(filePath)) {
       error(`File already exists: ${filePath}`);
@@ -35700,12 +35313,12 @@ function registerViewsCommand(program2) {
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
     }
-    const content = generateViewTemplate(name);
+    const content = generateSubgraphTemplate(name);
     await writeTextFile(filePath, content);
     success(`Created ${filePath}`);
-    info(`Next: sl views deploy views/${name}.ts`);
+    info(`Next: sl subgraphs deploy subgraphs/${name}.ts`);
   });
-  views.command("dev <file>").description("Watch a view file and auto-redeploy on change").action(async (file) => {
+  subgraphs.command("dev <file>").description("Watch a subgraph file and auto-redeploy on change").action(async (file) => {
     await requireLocalNetwork();
     const absPath = resolve(file);
     if (!existsSync(absPath)) {
@@ -35715,27 +35328,27 @@ function registerViewsCommand(program2) {
     info(`Watching ${absPath} for changes...`);
     info(`Press Ctrl+C to stop
 `);
-    const deployView = async () => {
+    const deploySubgraph = async () => {
       try {
         delete __require.cache[absPath];
         const mod = await import(`${absPath}?t=${Date.now()}`);
         const def = mod.default ?? mod;
-        const { validateViewDefinition } = await import("@secondlayer/views/validate");
-        const { deploySchema } = await import("@secondlayer/views");
+        const { validateSubgraphDefinition } = await import("@secondlayer/subgraphs/validate");
+        const { deploySchema } = await import("@secondlayer/subgraphs");
         const { getDb: getDb3 } = await import("@secondlayer/shared/db");
-        validateViewDefinition(def);
+        validateSubgraphDefinition(def);
         const db = getDb3();
         const result = await deploySchema(db, def, absPath, { forceReindex: false });
         if (result.action === "unchanged") {
           info(`[${new Date().toLocaleTimeString()}] No schema changes`);
         } else if (result.action === "created") {
-          success(`[${new Date().toLocaleTimeString()}] View "${def.name}" created`);
+          success(`[${new Date().toLocaleTimeString()}] Subgraph "${def.name}" created`);
         } else if (result.action === "updated") {
-          success(`[${new Date().toLocaleTimeString()}] View "${def.name}" updated (additive)`);
+          success(`[${new Date().toLocaleTimeString()}] Subgraph "${def.name}" updated (additive)`);
         } else if (result.action === "reindexed") {
-          success(`[${new Date().toLocaleTimeString()}] View "${def.name}" reindexed (breaking schema change)`);
+          success(`[${new Date().toLocaleTimeString()}] Subgraph "${def.name}" reindexed (breaking schema change)`);
         } else {
-          success(`[${new Date().toLocaleTimeString()}] View "${def.name}" deployed (${result.action})`);
+          success(`[${new Date().toLocaleTimeString()}] Subgraph "${def.name}" deployed (${result.action})`);
         }
         const handlerKeys = Object.keys(def.handlers);
         info(`  Handlers: ${handlerKeys.join(", ")}`);
@@ -35743,7 +35356,7 @@ function registerViewsCommand(program2) {
         error(`[${new Date().toLocaleTimeString()}] ${err}`);
       }
     };
-    await deployView();
+    await deploySubgraph();
     let timeout = null;
     const watcher = watch(absPath, () => {
       if (timeout)
@@ -35751,7 +35364,7 @@ function registerViewsCommand(program2) {
       timeout = setTimeout(async () => {
         console.log("");
         info("File changed, redeploying...");
-        await deployView();
+        await deploySubgraph();
       }, 300);
     });
     process.on("SIGINT", () => {
@@ -35764,15 +35377,15 @@ Stopped watching.`);
     });
     await new Promise(() => {});
   });
-  views.command("deploy <file>").description("Deploy a view definition file").option("--reindex", "Force reindex on breaking schema change (drops and rebuilds all data)").action(async (file, options2) => {
+  subgraphs.command("deploy <file>").description("Deploy a subgraph definition file").option("--reindex", "Force reindex on breaking schema change (drops and rebuilds all data)").action(async (file, options2) => {
     try {
       const absPath = resolve(file);
       const config = await loadConfig();
-      info(`Loading view from ${absPath}`);
+      info(`Loading subgraph from ${absPath}`);
       const mod = await import(absPath);
       const def = mod.default ?? mod;
-      const { validateViewDefinition } = await import("@secondlayer/views/validate");
-      validateViewDefinition(def);
+      const { validateSubgraphDefinition } = await import("@secondlayer/subgraphs/validate");
+      validateSubgraphDefinition(def);
       if (config.network !== "local") {
         info(`Bundling for remote deploy (${config.network})...`);
         const esbuild = await import("esbuild");
@@ -35781,11 +35394,11 @@ Stopped watching.`);
           bundle: true,
           platform: "node",
           format: "esm",
-          external: ["@secondlayer/views"],
+          external: ["@secondlayer/subgraphs"],
           write: false
         });
         const handlerCode = new TextDecoder().decode(buildResult.outputFiles[0].contents);
-        const result = await deployViewApi({
+        const result = await deploySubgraphApi({
           name: def.name,
           version: def.version,
           description: def.description,
@@ -35795,41 +35408,41 @@ Stopped watching.`);
           reindex: options2.reindex
         });
         if (result.action === "unchanged") {
-          info(`View "${def.name}" is up to date (no schema changes)`);
+          info(`Subgraph "${def.name}" is up to date (no schema changes)`);
         } else {
-          success(`View "${def.name}" ${result.action} (remote)`);
+          success(`Subgraph "${def.name}" ${result.action} (remote)`);
         }
       } else {
-        const { deploySchema } = await import("@secondlayer/views");
+        const { deploySchema } = await import("@secondlayer/subgraphs");
         const { getDb: getDb3, closeDb } = await import("@secondlayer/shared/db");
         const db = getDb3();
         const result = await deploySchema(db, def, absPath, { forceReindex: options2.reindex });
         if (result.action === "unchanged") {
-          info(`View "${def.name}" is up to date (no schema changes)`);
+          info(`Subgraph "${def.name}" is up to date (no schema changes)`);
         } else if (result.action === "created") {
-          success(`View "${def.name}" created (id: ${result.viewId.slice(0, 8)})`);
+          success(`Subgraph "${def.name}" created (id: ${result.subgraphId.slice(0, 8)})`);
         } else if (result.action === "reindexed") {
-          success(`View "${def.name}" schema rebuilt (id: ${result.viewId.slice(0, 8)})`);
-          info(`Reindexing will begin when view processor starts.`);
+          success(`Subgraph "${def.name}" schema rebuilt (id: ${result.subgraphId.slice(0, 8)})`);
+          info(`Reindexing will begin when subgraph processor starts.`);
         } else {
-          success(`View "${def.name}" updated (id: ${result.viewId.slice(0, 8)})`);
+          success(`Subgraph "${def.name}" updated (id: ${result.subgraphId.slice(0, 8)})`);
         }
         await closeDb();
       }
     } catch (err) {
-      error(`Failed to deploy view: ${err}`);
+      error(`Failed to deploy subgraph: ${err}`);
       process.exit(1);
     }
   });
-  views.command("list").alias("ls").description("List all deployed views").option("--json", "Output as JSON").action(async (options2) => {
+  subgraphs.command("list").alias("ls").description("List all deployed subgraphs").option("--json", "Output as JSON").action(async (options2) => {
     try {
-      const { data } = await listViewsApi();
+      const { data } = await listSubgraphsApi();
       if (options2.json) {
         console.log(JSON.stringify(data, null, 2));
         return;
       }
       if (data.length === 0) {
-        console.log("No views deployed");
+        console.log("No subgraphs deployed");
         return;
       }
       const tableRows = data.map((v) => {
@@ -35844,31 +35457,31 @@ Stopped watching.`);
       });
       console.log(formatTable(["Name", "Version", "Status", "Last Block", "Tables"], tableRows));
       console.log(dim(`
-${data.length} view(s) total`));
+${data.length} subgraph(s) total`));
     } catch (err) {
-      handleApiError(err, "list views");
+      handleApiError(err, "list subgraphs");
     }
   });
-  views.command("status <name>").description("Show detailed view status").action(async (name) => {
+  subgraphs.command("status <name>").description("Show detailed subgraph status").action(async (name) => {
     try {
-      const view = await getViewApi(name);
-      const rowCounts = Object.entries(view.tables).map(([t, info2]) => `${t}: ${info2.rowCount}`).join(", ") || "N/A";
-      const errorRate = view.health.totalProcessed > 0 ? `${(view.health.errorRate * 100).toFixed(2)}%` : "N/A";
+      const subgraph = await getSubgraphApi(name);
+      const rowCounts = Object.entries(subgraph.tables).map(([t, info2]) => `${t}: ${info2.rowCount}`).join(", ") || "N/A";
+      const errorRate = subgraph.health.totalProcessed > 0 ? `${(subgraph.health.errorRate * 100).toFixed(2)}%` : "N/A";
       console.log(formatKeyValue([
-        ["Name", view.name],
-        ["Version", view.version],
-        ["Status", view.status],
-        ["Last Block", String(view.lastProcessedBlock)],
+        ["Name", subgraph.name],
+        ["Version", subgraph.version],
+        ["Status", subgraph.status],
+        ["Last Block", String(subgraph.lastProcessedBlock)],
         ["Row Count", rowCounts],
-        ["Total Processed", String(view.health.totalProcessed)],
-        ["Total Errors", String(view.health.totalErrors)],
+        ["Total Processed", String(subgraph.health.totalProcessed)],
+        ["Total Errors", String(subgraph.health.totalErrors)],
         ["Error Rate", errorRate],
-        ["Last Error", view.health.lastError ?? "none"],
-        ["Last Error At", view.health.lastErrorAt ?? "N/A"],
-        ["Created", view.createdAt],
-        ["Updated", view.updatedAt]
+        ["Last Error", subgraph.health.lastError ?? "none"],
+        ["Last Error At", subgraph.health.lastErrorAt ?? "N/A"],
+        ["Created", subgraph.createdAt],
+        ["Updated", subgraph.updatedAt]
       ]));
-      const tableEntries = Object.entries(view.tables);
+      const tableEntries = Object.entries(subgraph.tables);
       if (tableEntries.length > 0) {
         console.log(dim(`
 Table endpoints:`));
@@ -35877,23 +35490,23 @@ Table endpoints:`));
         }
       }
     } catch (err) {
-      handleApiError(err, "get view status");
+      handleApiError(err, "get subgraph status");
     }
   });
-  views.command("reindex <name>").description("Reindex a view from historical blocks").option("--from <block>", "Start block height").option("--to <block>", "End block height").action(async (name, options2) => {
+  subgraphs.command("reindex <name>").description("Reindex a subgraph from historical blocks").option("--from <block>", "Start block height").option("--to <block>", "End block height").action(async (name, options2) => {
     try {
-      info(`Reindexing view "${name}"...`);
-      const result = await reindexViewApi(name, {
+      info(`Reindexing subgraph "${name}"...`);
+      const result = await reindexSubgraphApi(name, {
         fromBlock: options2.from ? parseInt(options2.from, 10) : undefined,
         toBlock: options2.to ? parseInt(options2.to, 10) : undefined
       });
       success(result.message);
       info(`From block ${result.fromBlock} to ${result.toBlock}`);
     } catch (err) {
-      handleApiError(err, "reindex view");
+      handleApiError(err, "reindex subgraph");
     }
   });
-  views.command("query <name> <table>").description("Query a view table").option("--sort <column>", "Sort by column").option("--order <dir>", "Sort direction (asc|desc)", "asc").option("--limit <n>", "Max rows to return", "20").option("--offset <n>", "Skip first N rows").option("--fields <cols>", "Comma-separated columns to include").option("--filter <kv...>", "Filter as key=value (supports .gte/.lte/.gt/.lt/.neq suffixes)").option("--count", "Return row count only").option("--json", "Output as JSON").action(async (name, table, options2) => {
+  subgraphs.command("query <name> <table>").description("Query a subgraph table").option("--sort <column>", "Sort by column").option("--order <dir>", "Sort direction (asc|desc)", "asc").option("--limit <n>", "Max rows to return", "20").option("--offset <n>", "Skip first N rows").option("--fields <cols>", "Comma-separated columns to include").option("--filter <kv...>", "Filter as key=value (supports .gte/.lte/.gt/.lt/.neq suffixes)").option("--count", "Return row count only").option("--json", "Output as JSON").action(async (name, table, options2) => {
     try {
       const filters = {};
       if (options2.filter) {
@@ -35915,7 +35528,7 @@ Table endpoints:`));
         filters: Object.keys(filters).length > 0 ? filters : undefined
       };
       if (options2.count) {
-        const result = await queryViewTableCount(name, table, params);
+        const result = await querySubgraphTableCount(name, table, params);
         if (options2.json) {
           console.log(JSON.stringify(result, null, 2));
         } else {
@@ -35923,7 +35536,7 @@ Table endpoints:`));
         }
         return;
       }
-      const rows = await queryViewTable(name, table, params);
+      const rows = await querySubgraphTable(name, table, params);
       if (options2.json) {
         console.log(JSON.stringify(rows, null, 2));
         return;
@@ -35945,28 +35558,28 @@ Table endpoints:`));
       console.log(dim(`
 ${rows.length} row(s)`));
     } catch (err) {
-      handleApiError(err, "query view");
+      handleApiError(err, "query subgraph");
     }
   });
-  views.command("delete <name>").description("Delete a view and its data").option("-y, --yes", "Skip confirmation").action(async (name, options2) => {
+  subgraphs.command("delete <name>").description("Delete a subgraph and its data").option("-y, --yes", "Skip confirmation").action(async (name, options2) => {
     try {
       if (!options2.yes) {
         const { confirm: confirm6 } = await import("@inquirer/prompts");
         const ok = await confirm6({
-          message: `Delete view "${name}" and all its data? This cannot be undone.`
+          message: `Delete subgraph "${name}" and all its data? This cannot be undone.`
         });
         if (!ok) {
           info("Cancelled");
           return;
         }
       }
-      const result = await deleteViewApi(name);
+      const result = await deleteSubgraphApi(name);
       success(result.message);
     } catch (err) {
-      handleApiError(err, "delete view");
+      handleApiError(err, "delete subgraph");
     }
   });
-  views.command("scaffold <contractAddress>").description("Scaffold a defineView() file from a contract ABI").option("-o, --output <path>", "Output file path (required)").option("--api-key <key>", "Hiro API key").action(async (contractAddress, options2) => {
+  subgraphs.command("scaffold <contractAddress>").description("Scaffold a defineSubgraph() file from a contract ABI").option("-o, --output <path>", "Output file path (required)").option("--api-key <key>", "Hiro API key").action(async (contractAddress, options2) => {
     try {
       if (!options2.output) {
         error("--output <path> is required");
@@ -35980,7 +35593,7 @@ ${rows.length} row(s)`));
       const contractInfo = await client.getContractInfo(contractAddress);
       const abi = parseApiResponse(contractInfo);
       info(`Generating scaffold...`);
-      const content = await generateViewScaffold({
+      const content = await generateSubgraphScaffold({
         contractId: contractAddress,
         functions: abi.functions
       });
@@ -35989,30 +35602,30 @@ ${rows.length} row(s)`));
         mkdirSync(dir, { recursive: true });
       await writeTextFile(outPath, content);
       success(`Created ${outPath}`);
-      info(`Next: sl views deploy ${options2.output}`);
+      info(`Next: sl subgraphs deploy ${options2.output}`);
     } catch (err) {
-      error(`Failed to scaffold view: ${err}`);
+      error(`Failed to scaffold subgraph: ${err}`);
       process.exit(1);
     }
   });
-  views.command("generate <viewName>").description("Generate a typed client for a deployed view").option("-o, --output <path>", "Output file path (required)").action(async (viewName, options2) => {
+  subgraphs.command("generate <subgraphName>").description("Generate a typed client for a deployed subgraph").option("-o, --output <path>", "Output file path (required)").action(async (subgraphName, options2) => {
     try {
       if (!options2.output) {
         error("--output <path> is required");
         process.exit(1);
       }
       const outPath = resolve(options2.output);
-      info(`Fetching view metadata for "${viewName}"...`);
-      const viewDetail = await getViewApi(viewName);
+      info(`Fetching subgraph metadata for "${subgraphName}"...`);
+      const subgraphDetail = await getSubgraphApi(subgraphName);
       info(`Generating typed client...`);
-      const content = await generateViewConsumer(viewName, viewDetail);
+      const content = await generateSubgraphConsumer(subgraphName, subgraphDetail);
       const dir = resolve(outPath, "..");
       if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
       await writeTextFile(outPath, content);
       success(`Created ${outPath}`);
     } catch (err) {
-      handleApiError(err, "generate view client");
+      handleApiError(err, "generate subgraph client");
     }
   });
 }
@@ -36564,6 +36177,7 @@ async function runLocalDoctor(jsonOutput) {
 init_config();
 init_api_client();
 init_output();
+import { hostname } from "node:os";
 import { input as input2 } from "@inquirer/prompts";
 function registerAuthCommand(program2) {
   const auth = program2.command("auth").description("Manage authentication and API keys");
@@ -36584,17 +36198,10 @@ function registerAuthCommand(program2) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ email })
       });
-      if (!mlRes.ok) {
-        const body = await mlRes.text();
-        let msg = `HTTP ${mlRes.status}`;
-        try {
-          msg = JSON.parse(body).error || msg;
-        } catch {}
-        throw new Error(msg);
-      }
-      console.log(dim("Check your email for a login token."));
+      await assertOk(mlRes);
+      console.log(dim("Check your email for a 6-digit login code."));
       const token = await input2({
-        message: "Token:",
+        message: "Code:",
         validate: (v) => v.trim().length > 0 || "Token is required"
       });
       const verifyRes = await fetch(`${apiUrl}/api/auth/verify`, {
@@ -36602,19 +36209,32 @@ function registerAuthCommand(program2) {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ token: token.trim() })
       });
-      if (!verifyRes.ok) {
-        const body = await verifyRes.text();
-        let msg = `HTTP ${verifyRes.status}`;
-        try {
-          msg = JSON.parse(body).error || msg;
-        } catch {}
-        throw new Error(msg);
-      }
+      await assertOk(verifyRes);
       const result = await verifyRes.json();
-      config.sessionToken = result.sessionToken;
+      const sessionHeaders = { Authorization: `Bearer ${result.sessionToken}`, "Content-Type": "application/json" };
+      const keyName = `cli-${hostname().toLowerCase()}`;
+      const listRes = await fetch(`${apiUrl}/api/keys`, { headers: sessionHeaders });
+      if (listRes.ok) {
+        const { keys: keys2 } = await listRes.json();
+        const existing = keys2.find((k) => k.name === keyName && k.status === "active");
+        if (existing) {
+          await fetch(`${apiUrl}/api/keys/${existing.id}`, { method: "DELETE", headers: sessionHeaders });
+        }
+      }
+      const createRes = await fetch(`${apiUrl}/api/keys`, {
+        method: "POST",
+        headers: sessionHeaders,
+        body: JSON.stringify({ name: keyName })
+      });
+      await assertOk(createRes);
+      const { key, prefix } = await createRes.json();
+      config.apiKey = key;
       await saveConfig(config);
+      try {
+        await fetch(`${apiUrl}/api/auth/logout`, { method: "POST", headers: sessionHeaders });
+      } catch {}
       success(`Authenticated as ${result.account.email}`);
-      console.log(dim(`Plan: ${result.account.plan}`));
+      console.log(dim(`Key: ${prefix}...`));
       console.log(dim(`Network: ${config.network}`));
       console.log(dim(`API: ${apiUrl}`));
     } catch (err) {
@@ -36622,37 +36242,41 @@ function registerAuthCommand(program2) {
       process.exit(1);
     }
   });
-  auth.command("logout").description("Revoke session and remove from config").action(async () => {
+  auth.command("logout").description("Revoke API key and remove from config").action(async () => {
     const config = await loadConfig();
     const apiUrl = resolveApiUrl(config);
-    if (!config.sessionToken) {
+    if (!config.apiKey) {
       error("Not logged in.");
       process.exit(1);
     }
     try {
-      await fetch(`${apiUrl}/api/auth/logout`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${config.sessionToken}` }
-      });
+      const headers = authHeaders(config);
+      const listRes = await fetch(`${apiUrl}/api/keys`, { headers });
+      if (listRes.ok) {
+        const { keys: keys2 } = await listRes.json();
+        const currentPrefix = config.apiKey.slice(0, 14);
+        const match = keys2.find((k) => currentPrefix.startsWith(k.prefix));
+        if (match) {
+          await fetch(`${apiUrl}/api/keys/${match.id}`, { method: "DELETE", headers });
+        }
+      }
     } catch {}
-    delete config.sessionToken;
+    delete config.apiKey;
     await saveConfig(config);
-    success("Logged out. Session revoked.");
+    success("Logged out. API key revoked.");
   });
   auth.command("status").description("Show current auth status").action(async () => {
     const config = await loadConfig();
     const apiUrl = resolveApiUrl(config);
-    const token = config.sessionToken ?? config.apiKey;
     const pairs = [
       ["Network", config.network],
       ["API", apiUrl || "(not configured)"],
-      ["Session", config.sessionToken ? config.sessionToken.slice(0, 14) + "..." : "(none)"],
       ["API Key", config.apiKey ? config.apiKey.slice(0, 14) + "..." : "(none)"]
     ];
-    if (token && apiUrl) {
+    if (config.apiKey && apiUrl) {
       try {
         const res = await fetch(`${apiUrl}/api/accounts/me`, {
-          headers: { Authorization: `Bearer ${token}` }
+          headers: authHeaders(config)
         });
         if (res.ok) {
           const data = await res.json();
@@ -36696,14 +36320,7 @@ function registerAuthCommand(program2) {
         headers,
         body: JSON.stringify({ name: options2.name })
       });
-      if (!res.ok) {
-        const body = await res.text();
-        let msg = `HTTP ${res.status}`;
-        try {
-          msg = JSON.parse(body).error || msg;
-        } catch {}
-        throw new Error(msg);
-      }
+      await assertOk(res);
       const { key, prefix } = await res.json();
       success(`Created API key: ${prefix}...`);
       console.log();
@@ -36737,24 +36354,18 @@ function registerAuthCommand(program2) {
         method: "DELETE",
         headers
       });
-      if (!res.ok) {
-        const body = await res.text();
-        let msg = `HTTP ${res.status}`;
-        try {
-          msg = JSON.parse(body).error || msg;
-        } catch {}
-        throw new Error(msg);
-      }
+      await assertOk(res);
       success(`Revoked key ${idOrPrefix}`);
     } catch (err) {
       error(`Failed to revoke key: ${err}`);
       process.exit(1);
     }
   });
-  keys.command("rotate").description("Revoke current API key and create a new one").option("--name <name>", "Name for the new API key", "cli").action(async (options2) => {
+  const defaultKeyName = `cli-${hostname().toLowerCase()}`;
+  keys.command("rotate").description("Revoke current API key and create a new one").option("--name <name>", "Name for the new API key", defaultKeyName).action(async (options2) => {
     await rotateKey(options2);
   });
-  auth.command("rotate").description("Revoke current API key and create a new one").option("--name <name>", "Name for the new API key", "cli").action(async (options2) => {
+  auth.command("rotate").description("Revoke current API key and create a new one").option("--name <name>", "Name for the new API key", defaultKeyName).action(async (options2) => {
     await rotateKey(options2);
   });
 }
@@ -36762,7 +36373,7 @@ async function rotateKey(options2) {
   const config = await loadConfig();
   const apiUrl = resolveApiUrl(config);
   const headers = authHeaders(config);
-  if (!config.sessionToken && !config.apiKey) {
+  if (!config.apiKey) {
     error("Not logged in. Run `sl auth login` first.");
     process.exit(1);
   }
@@ -36787,14 +36398,7 @@ async function rotateKey(options2) {
       headers: { ...headers, "Content-Type": "application/json" },
       body: JSON.stringify({ name: options2.name })
     });
-    if (!createRes.ok) {
-      const body = await createRes.text();
-      let msg = `HTTP ${createRes.status}`;
-      try {
-        msg = JSON.parse(body).error || msg;
-      } catch {}
-      throw new Error(msg);
-    }
+    await assertOk(createRes);
     const { key, prefix } = await createRes.json();
     config.apiKey = key;
     await saveConfig(config);
@@ -36809,7 +36413,7 @@ init_config();
 init_dev_state();
 init_node_manager();
 init_output();
-var DEV_SERVICES = ["api", "indexer", "worker", "webhook", "views"];
+var DEV_SERVICES = ["api", "indexer", "worker", "webhook", "subgraphs"];
 function registerLocalCommand(program2) {
   const local = program2.command("local").description("Manage local development environment and Stacks node").hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.name() === "help")
@@ -36838,7 +36442,7 @@ function registerLocalCommand(program2) {
   local.command("status").description("Show local environment status").action(async () => {
     await showLocalStatus();
   });
-  local.command("logs").description("View local service logs (dev + node)").option("-s, --service <name>", "Filter by service (api, indexer, worker, webhook, views, node)").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines to show", "50").option("-q, --quiet", "Filter out common noise").option("-v, --verbose", "Show full payloads").action(async (options2) => {
+  local.command("logs").description("View local service logs (dev + node)").option("-s, --service <name>", "Filter by service (api, indexer, worker, webhook, subgraphs, node)").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines to show", "50").option("-q, --quiet", "Filter out common noise").option("-v, --verbose", "Show full payloads").action(async (options2) => {
     await showLocalLogs(options2);
   });
   const node = local.command("node").description("Manage local Stacks node");
@@ -36914,7 +36518,7 @@ var serviceColors2 = {
   api: blue,
   indexer: cyan,
   worker: yellow,
-  views: magenta,
+  subgraphs: magenta,
   webhook: green,
   node: red
 };
@@ -37098,8 +36702,7 @@ function registerWhoamiCommand(program2) {
   program2.command("whoami").description("Show current authenticated account").action(async () => {
     const config = await loadConfig();
     const apiUrl = resolveApiUrl(config);
-    const token = config.sessionToken ?? config.apiKey;
-    if (!token) {
+    if (!config.apiKey) {
       error("Not authenticated. Run: sl auth login");
       process.exit(1);
     }
@@ -37129,7 +36732,7 @@ function registerWhoamiCommand(program2) {
 }
 // src/cli.ts
 var { version } = package_default;
-program.name("secondlayer").alias("sl").description("SecondLayer CLI — streams, views, and real-time indexing for Stacks").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
+program.name("secondlayer").alias("sl").description("SecondLayer CLI — streams, subgraphs, and real-time indexing for Stacks").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
 program.hook("preAction", (thisCommand) => {
   const net3 = thisCommand.opts().network;
   if (net3)
@@ -37151,7 +36754,7 @@ program.command("init").description("Initialize a new secondlayer.config.ts file
   await init3();
 });
 registerStreamsCommand(program);
-registerViewsCommand(program);
+registerSubgraphsCommand(program);
 registerStatusCommand(program);
 registerLocalCommand(program);
 registerStackCommand(program);
@@ -37165,5 +36768,5 @@ registerWhoamiCommand(program);
 registerWebhookCommand(program);
 program.parse();
 
-//# debugId=E0C86F93180D107264756E2164756E21
+//# debugId=2320C06E5C8D182A64756E2164756E21
 //# sourceMappingURL=cli.js.map