@secondlayer/cli 2.1.0 → 3.0.0

package/dist/cli.js

@@ -2140,14 +2140,109 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// src/lib/session.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { z } from "zod/v4";
+async function readSession() {
+  try {
+    const raw = await readFile(SESSION_PATH, "utf8");
+    return SessionSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    return null;
+  }
+}
+async function writeSession(session) {
+  await mkdir(dirname(SESSION_PATH), { recursive: true });
+  await writeFile(SESSION_PATH, JSON.stringify(session, null, 2) + `
+`, "utf8");
+  await chmod(SESSION_PATH, 384);
+}
+async function clearSession() {
+  await rm(SESSION_PATH, { force: true });
+}
+var SessionSchema, SESSION_DIR, SESSION_PATH;
+var init_session = __esm(() => {
+  SessionSchema = z.object({
+    token: z.string().min(1),
+    email: z.string().email(),
+    accountId: z.string().uuid(),
+    expiresAt: z.string()
+  });
+  SESSION_DIR = join(homedir(), ".secondlayer");
+  SESSION_PATH = join(SESSION_DIR, "session.json");
+});
+
+// src/lib/http.ts
+async function request(url, opts) {
+  const headers = {
+    "content-type": "application/json",
+    ...opts.headers ?? {}
+  };
+  if (opts.bearer)
+    headers.authorization = `Bearer ${opts.bearer}`;
+  const res = await fetch(url, {
+    method: opts.method ?? "GET",
+    headers,
+    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined
+  });
+  if (!res.ok) {
+    let body = {};
+    try {
+      body = await res.json();
+    } catch {
+      body = { error: await res.text().catch(() => "") };
+    }
+    const code = body.code ?? (res.status === 401 ? "SESSION_EXPIRED" : res.status === 404 ? "NOT_FOUND" : `HTTP_${res.status}`);
+    const message = body.message ?? body.error ?? `HTTP ${res.status}`;
+    throw new CliHttpError(res.status, code, body, message);
+  }
+  if (res.status === 204)
+    return;
+  return await res.json();
+}
+async function httpPlatform(path, opts = {}) {
+  const session = await readSession();
+  if (!session) {
+    throw new CliHttpError(401, "SESSION_EXPIRED", { error: "Not logged in" }, "Not logged in — run `sl login`");
+  }
+  return request(`${PLATFORM_API_URL}${path}`, {
+    ...opts,
+    bearer: session.token
+  });
+}
+async function httpPlatformAnon(path, opts = {}) {
+  return request(`${PLATFORM_API_URL}${path}`, opts);
+}
+var CliHttpError, PLATFORM_API_URL;
+var init_http = __esm(() => {
+  init_session();
+  CliHttpError = class CliHttpError extends Error {
+    status;
+    code;
+    body;
+    name = "CliHttpError";
+    constructor(status, code, body, message) {
+      super(message);
+      this.status = status;
+      this.code = code;
+      this.body = body;
+    }
+  };
+  PLATFORM_API_URL = process.env.SL_PLATFORM_API_URL ?? "https://api.secondlayer.tools";
+});
+
 // src/lib/fs.ts
-import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, stat, unlink, writeFile as writeFile2 } from "node:fs/promises";
 async function readJsonFile(path) {
-  const text = await readFile(path, "utf-8");
+  const text = await readFile2(path, "utf-8");
   return JSON.parse(text);
 }
 async function writeTextFile(path, content) {
-  await writeFile(path, content, "utf-8");
+  await writeFile2(path, content, "utf-8");
 }
 async function fileExists(path) {
   try {
@@ -2158,7 +2253,7 @@ async function fileExists(path) {
   }
 }
 async function ensureDir(path) {
-  await mkdir(path, { recursive: true });
+  await mkdir2(path, { recursive: true });
 }
 async function removeFile(path) {
   await unlink(path);
@@ -2171,7 +2266,6 @@ __export(exports_config, {
   setConfigValue: () => setConfigValue,
   saveConfig: () => saveConfig,
   resolvePath: () => resolvePath,
-  resolveApiUrl: () => resolveApiUrl,
   resetConfig: () => resetConfig,
   requireLocalNetwork: () => requireLocalNetwork,
   loadConfig: () => loadConfig,
@@ -2185,20 +2279,15 @@ __export(exports_config, {
   NetworkSchema: () => NetworkSchema,
   ConfigSchema: () => ConfigSchema
 });
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { z } from "zod/v4";
-function resolveApiUrl(config) {
-  if (config.apiUrl)
-    return config.apiUrl;
-  return API_URLS[config.network] || API_URLS.local;
-}
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+import { z as z2 } from "zod/v4";
 async function ensureConfigDir() {
   await ensureDir(CONFIG_DIR);
 }
 function resolvePath(path) {
   if (path.startsWith("~/")) {
-    return join(homedir(), path.slice(2));
+    return join2(homedir2(), path.slice(2));
   }
   return path;
 }
@@ -2214,21 +2303,13 @@ function migrateConfig(raw) {
   const migrated = { ...DEFAULT_CONFIG };
   if (typeof old.network === "string" && ["local", "testnet", "mainnet"].includes(old.network)) {
     migrated.network = old.network;
-  } else if (typeof old.apiUrl === "string" && old.apiUrl !== "http://localhost:3800") {
-    migrated.network = "local";
-  }
-  if (typeof old.apiKey === "string") {
-    migrated.apiKey = old.apiKey;
-  }
-  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;
   }
   if (typeof old.dataDir === "string") {
     migrated.dataDir = old.dataDir;
   }
+  if (typeof old.defaultProject === "string") {
+    migrated.defaultProject = old.defaultProject;
+  }
   if (typeof old.nodeInstallPath === "string" || typeof old.nodeNetwork === "string") {
     migrated.node = {
       installPath: old.nodeInstallPath || "",
@@ -2280,9 +2361,6 @@ function applyEnvOverrides(config) {
       result.network = net;
     }
   }
-  if (process.env.SECONDLAYER_API_KEY) {
-    result.apiKey = process.env.SECONDLAYER_API_KEY;
-  }
   if (process.env.SL_DATA_DIR) {
     result.dataDir = process.env.SL_DATA_DIR;
   }
@@ -2388,39 +2466,33 @@ function isDefaultValue(config, key) {
   const defaultValue = getConfigValue(DEFAULT_CONFIG, key);
   return JSON.stringify(currentValue) === JSON.stringify(defaultValue);
 }
-var PortsSchema, NodeSchema, DatabaseSchema, NetworkSchema, API_URLS, ConfigSchema, CONFIG_DIR, CONFIG_PATH, DEFAULT_CONFIG;
+var PortsSchema, NodeSchema, DatabaseSchema, NetworkSchema, ConfigSchema, CONFIG_DIR, CONFIG_PATH, DEFAULT_CONFIG;
 var init_config = __esm(() => {
   init_fs();
-  PortsSchema = z.object({
-    api: z.number().int().min(1).max(65535).default(3800),
-    indexer: z.number().int().min(1).max(65535).default(3700)
+  PortsSchema = z2.object({
+    api: z2.number().int().min(1).max(65535).default(3800),
+    indexer: z2.number().int().min(1).max(65535).default(3700)
   });
-  NodeSchema = z.object({
-    installPath: z.string().min(1),
-    network: z.enum(["mainnet", "testnet"]).default("mainnet")
+  NodeSchema = z2.object({
+    installPath: z2.string().min(1),
+    network: z2.enum(["mainnet", "testnet"]).default("mainnet")
   });
-  DatabaseSchema = z.object({
-    type: z.enum(["docker", "external"]).default("docker"),
-    url: z.string().url().optional()
+  DatabaseSchema = z2.object({
+    type: z2.enum(["docker", "external"]).default("docker"),
+    url: z2.string().url().optional()
   });
-  NetworkSchema = z.enum(["local", "testnet", "mainnet"]);
-  API_URLS = {
-    local: "http://localhost:3800",
-    testnet: "https://api.secondlayer.tools",
-    mainnet: "https://api.secondlayer.tools"
-  };
-  ConfigSchema = z.object({
+  NetworkSchema = z2.enum(["local", "testnet", "mainnet"]);
+  ConfigSchema = z2.object({
     network: NetworkSchema.default("mainnet"),
-    apiUrl: z.string().url().optional(),
-    apiKey: z.string().optional(),
-    nodeRpcUrl: z.string().url().optional(),
-    dataDir: z.string().default("~/.secondlayer/data"),
+    nodeRpcUrl: z2.string().url().optional(),
+    dataDir: z2.string().default("~/.secondlayer/data"),
     node: NodeSchema.optional(),
     ports: PortsSchema.default({ api: 3800, indexer: 3700 }),
-    database: DatabaseSchema.default({ type: "docker" })
+    database: DatabaseSchema.default({ type: "docker" }),
+    defaultProject: z2.string().optional()
   });
-  CONFIG_DIR = join(homedir(), ".secondlayer");
-  CONFIG_PATH = join(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join2(homedir2(), ".secondlayer");
+  CONFIG_PATH = join2(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     network: "mainnet",
     dataDir: "~/.secondlayer/data",
@@ -2429,135 +2501,91 @@ var init_config = __esm(() => {
   };
 });
 
-// src/lib/api-client.ts
-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;
+// src/lib/project-file.ts
+import { existsSync } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname2, join as join3, parse as parsePath, resolve } from "node:path";
+import { z as z3 } from "zod/v4";
+async function readActiveProject(cwd, globalDefault) {
+  let dir = resolve(cwd);
+  const home = resolve(homedir3());
+  const fsRoot = parsePath(dir).root;
+  while (true) {
+    const candidate = join3(dir, DIRNAME, FILENAME);
+    if (existsSync(candidate)) {
+      try {
+        const raw = await readFile3(candidate, "utf8");
+        const parsed = ProjectFileSchema.parse(JSON.parse(raw));
+        return { slug: parsed.slug, resolvedFrom: candidate };
+      } catch {}
+    }
+    if (existsSync(join3(dir, ".git")))
+      break;
+    if (dir === home || dir === fsRoot)
+      break;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
   }
-  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");
-    process.exit(1);
+  if (globalDefault) {
+    return {
+      slug: globalDefault,
+      resolvedFrom: join3(homedir3(), ".secondlayer", "config.json")
+    };
   }
-  console.error(`Error: Failed to ${action}: ${err}`);
-  process.exit(1);
+  return null;
 }
-function withErrorHandling(fn, options) {
-  return async (...args) => {
-    try {
-      await fn(...args);
-    } catch (err) {
-      if (options?.onError) {
-        options.onError(err);
-      } else {
-        handleApiError(err, options?.action ?? "execute command");
+async function writeActiveProject(slug, cwd) {
+  const dir = join3(resolve(cwd), DIRNAME);
+  await mkdir3(dir, { recursive: true });
+  const file = join3(dir, FILENAME);
+  await writeFile3(file, JSON.stringify({ slug }, null, 2) + `
+`, "utf8");
+  return file;
+}
+var ProjectFileSchema, FILENAME = "project", DIRNAME = ".secondlayer";
+var init_project_file = __esm(() => {
+  ProjectFileSchema = z3.object({
+    slug: z3.string().min(1)
+  });
+});
+
+// src/lib/resolve-tenant.ts
+async function resolveActiveTenant(opts = {}) {
+  const envUrl = process.env.SL_API_URL;
+  const envKey = process.env.SL_SERVICE_KEY;
+  if (envUrl && envKey) {
+    return { apiUrl: envUrl, ephemeralKey: envKey, fromEnv: true };
+  }
+  opts.tenant;
+  try {
+    const res = await httpPlatform("/api/tenants/me/keys/mint-ephemeral", { method: "POST" });
+    return {
+      apiUrl: res.apiUrl,
+      ephemeralKey: res.serviceKey,
+      fromEnv: false
+    };
+  } catch (err) {
+    if (err instanceof CliHttpError) {
+      if (err.status === 404) {
+        const config = await loadConfig();
+        const active = await readActiveProject(process.cwd(), config.defaultProject);
+        const hint = active ? `Run 'sl instance create --plan launch' to provision for project ${active.slug}` : "Run 'sl project create <name>' then 'sl instance create --plan launch'";
+        throw new CliHttpError(404, "NO_TENANT_FOR_PROJECT", { error: hint }, hint);
       }
     }
-  };
-}
-async function getClient() {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  return new SecondLayer({ baseUrl, apiKey: config.apiKey });
-}
-function authHeaders(config) {
-  return SecondLayer.authHeaders(config.apiKey);
-}
-async function listSubgraphsApi() {
-  return (await getClient()).subgraphs.list();
-}
-async function getSubgraphApi(name) {
-  return (await getClient()).subgraphs.get(name);
-}
-async function reindexSubgraphApi(name, options) {
-  return (await getClient()).subgraphs.reindex(name, options);
-}
-async function backfillSubgraphApi(name, options) {
-  return (await getClient()).subgraphs.backfill(name, options);
-}
-async function stopSubgraphApi(name) {
-  return (await getClient()).subgraphs.stop(name);
-}
-async function deleteSubgraphApi(name) {
-  return (await getClient()).subgraphs.delete(name);
-}
-async function deploySubgraphApi(data) {
-  return (await getClient()).subgraphs.deploy(data);
-}
-async function querySubgraphTable(name, table, params = {}) {
-  return (await getClient()).subgraphs.queryTable(name, table, params);
-}
-async function querySubgraphTableCount(name, table, params = {}) {
-  return (await getClient()).subgraphs.queryTableCount(name, table, params);
-}
-async function getSubgraphGaps(name, opts) {
-  return (await getClient()).subgraphs.gaps(name, opts);
-}
-async function getAccountProfile() {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  const res = await fetch(`${baseUrl}/api/accounts/me`, {
-    headers: authHeaders(config)
-  });
-  await assertOk(res);
-  return res.json();
-}
-async function updateAccountProfile(data) {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  const res = await fetch(`${baseUrl}/api/accounts/me`, {
-    method: "PATCH",
-    headers: authHeaders(config),
-    body: JSON.stringify(data)
-  });
-  await assertOk(res);
-  return res.json();
-}
-async function browseMarketplace(opts = {}) {
-  return (await getClient()).marketplace.browse(opts);
-}
-async function getMarketplaceSubgraph(name) {
-  return (await getClient()).marketplace.get(name);
-}
-async function forkMarketplaceSubgraph(name, newName) {
-  return (await getClient()).marketplace.fork(name, newName);
-}
-async function publishSubgraphApi(name, opts) {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  const res = await fetch(`${baseUrl}/api/subgraphs/${name}/publish`, {
-    method: "POST",
-    headers: authHeaders(config),
-    body: JSON.stringify(opts ?? {})
-  });
-  await assertOk(res);
-  return res.json();
+    throw err;
+  }
 }
-async function unpublishSubgraphApi(name) {
-  const config = await loadConfig();
-  const baseUrl = resolveApiUrl(config);
-  const res = await fetch(`${baseUrl}/api/subgraphs/${name}/unpublish`, {
-    method: "POST",
-    headers: authHeaders(config),
-    body: JSON.stringify({})
-  });
-  await assertOk(res);
-  return res.json();
+function isOssMode() {
+  return !!process.env.SL_API_URL && !process.env.SL_SERVICE_KEY;
 }
-var init_api_client = __esm(() => {
+var init_resolve_tenant = __esm(() => {
+  init_http();
   init_config();
+  init_project_file();
 });
 
 // src/lib/output.ts
@@ -2690,9 +2718,9 @@ var init_query = __esm(() => {
   CLOSE = {};
   Query = class Query extends Promise {
     constructor(strings, args, handler, canceller, options = {}) {
-      let resolve, reject;
+      let resolve2, reject;
       super((a, b) => {
-        resolve = a;
+        resolve2 = a;
         reject = b;
       });
       this.tagged = Array.isArray(strings.raw);
@@ -2703,7 +2731,7 @@ var init_query = __esm(() => {
       this.options = options;
       this.state = null;
       this.statement = null;
-      this.resolve = (x) => (this.active = false, resolve(x));
+      this.resolve = (x) => (this.active = false, resolve2(x));
       this.reject = (x) => (this.active = false, reject(x));
       this.active = false;
       this.cancelled = null;
@@ -2751,12 +2779,12 @@ var init_query = __esm(() => {
             if (this.executed && !this.active)
               return { done: true };
             prev && prev();
-            const promise = new Promise((resolve, reject) => {
+            const promise = new Promise((resolve2, reject) => {
               this.cursorFn = (value) => {
-                resolve({ value, done: false });
+                resolve2({ value, done: false });
                 return new Promise((r) => prev = r);
               };
-              this.resolve = () => (this.active = false, resolve({ done: true }));
+              this.resolve = () => (this.active = false, resolve2({ done: true }));
               this.reject = (x) => (this.active = false, reject(x));
             });
             this.execute();
@@ -3310,12 +3338,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     x.on("drain", drain);
     return x;
   }
-  async function cancel({ pid, secret }, resolve, reject) {
+  async function cancel({ pid, secret }, resolve2, reject) {
     try {
       cancelMessage = bytes_default().i32(16).i32(80877102).i32(pid).i32(secret).end(16);
       await connect();
       socket.once("error", reject);
-      socket.once("close", resolve);
+      socket.once("close", resolve2);
     } catch (error3) {
       reject(error3);
     }
@@ -4188,7 +4216,7 @@ var noop2 = () => {};
 // ../../node_modules/postgres/src/large.js
 import Stream2 from "stream";
 function largeObject(sql, oid, mode = 131072 | 262144) {
-  return new Promise(async (resolve, reject) => {
+  return new Promise(async (resolve2, reject) => {
     await sql.begin(async (sql2) => {
       let finish;
       !oid && ([{ oid }] = await sql2`select lo_creat(-1) as oid`);
@@ -4214,7 +4242,7 @@ function largeObject(sql, oid, mode = 131072 | 262144) {
           ) seek
         `
       };
-      resolve(lo);
+      resolve2(lo);
       return new Promise(async (r) => finish = r);
       async function readable({
         highWaterMark = 2048 * 8,
@@ -4374,8 +4402,8 @@ function Postgres(a, b2) {
   }
   async function reserve() {
     const queue = queue_default();
-    const c = open.length ? open.shift() : await new Promise((resolve, reject) => {
-      const query = { reserve: resolve, reject };
+    const c = open.length ? open.shift() : await new Promise((resolve2, reject) => {
+      const query = { reserve: resolve2, reject };
       queries.push(query);
       closed.length && connect(closed.shift(), query);
     });
@@ -4412,9 +4440,9 @@ function Postgres(a, b2) {
       let uncaughtError, result;
       name && await sql2`savepoint ${sql2(name)}`;
       try {
-        result = await new Promise((resolve, reject) => {
+        result = await new Promise((resolve2, reject) => {
           const x = fn2(sql2);
-          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve, reject);
+          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve2, reject);
         });
         if (uncaughtError)
           throw uncaughtError;
@@ -4471,8 +4499,8 @@ function Postgres(a, b2) {
     return c.execute(query) ? move(c, busy) : move(c, full);
   }
   function cancel(query) {
-    return new Promise((resolve, reject) => {
-      query.state ? query.active ? connection_default(options).cancel(query.state, resolve, reject) : query.cancelled = { resolve, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve());
+    return new Promise((resolve2, reject) => {
+      query.state ? query.active ? connection_default(options).cancel(query.state, resolve2, reject) : query.cancelled = { resolve: resolve2, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve2());
     });
   }
   async function end({ timeout = null } = {}) {
@@ -4488,11 +4516,11 @@ function Postgres(a, b2) {
   async function close() {
     await Promise.all(connections.map((c) => c.end()));
   }
-  async function destroy(resolve) {
+  async function destroy(resolve2) {
     await Promise.all(connections.map((c) => c.terminate()));
     while (queries.length)
       queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
-    resolve();
+    resolve2();
   }
   function connect(c, query) {
     move(c, connecting);
@@ -4676,13 +4704,13 @@ __export(exports_dev_state, {
   clearLogs: () => clearLogs,
   clearDevState: () => clearDevState
 });
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
 function getLogsDir() {
   return LOGS_DIR;
 }
 function getLogFile(service) {
-  return join3(LOGS_DIR, `${service}.log`);
+  return join5(LOGS_DIR, `${service}.log`);
 }
 async function ensureDirs() {
   await Bun.$`mkdir -p ${STATE_DIR}`.quiet();
@@ -4739,9 +4767,9 @@ async function isDevRunning() {
 }
 var STATE_DIR, DEV_STATE_PATH, LOGS_DIR;
 var init_dev_state = __esm(() => {
-  STATE_DIR = join3(homedir3(), ".secondlayer");
-  DEV_STATE_PATH = join3(STATE_DIR, "dev.json");
-  LOGS_DIR = join3(STATE_DIR, "logs");
+  STATE_DIR = join5(homedir5(), ".secondlayer");
+  DEV_STATE_PATH = join5(STATE_DIR, "dev.json");
+  LOGS_DIR = join5(STATE_DIR, "logs");
 });
 
 // src/utils/format.ts
@@ -5460,9 +5488,9 @@ var init_dist = __esm(() => {
 class PCancelable {
   static fn(userFunction) {
     return (...arguments_) => {
-      return new PCancelable((resolve, reject, onCancel) => {
+      return new PCancelable((resolve2, reject, onCancel) => {
         arguments_.push(onCancel);
-        userFunction(...arguments_).then(resolve, reject);
+        userFunction(...arguments_).then(resolve2, reject);
       });
     };
   }
@@ -5471,12 +5499,12 @@ class PCancelable {
     this._isPending = true;
     this._isCanceled = false;
     this._rejectOnCancel = true;
-    this._promise = new Promise((resolve, reject) => {
+    this._promise = new Promise((resolve2, reject) => {
       this._reject = reject;
       const onResolve = (value) => {
         if (!this._isCanceled || !onCancel.shouldReject) {
           this._isPending = false;
-          resolve(value);
+          resolve2(value);
         }
       };
       const onReject = (error2) => {
@@ -5626,8 +5654,8 @@ var init_errors2 = __esm(() => {
     }
   };
   MaxRedirectsError = class MaxRedirectsError extends RequestError {
-    constructor(request) {
-      super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
+    constructor(request2) {
+      super(`Redirected ${request2.options.maxRedirects} times. Aborting.`, {}, request2);
       this.name = "MaxRedirectsError";
       this.code = "ERR_TOO_MANY_REDIRECTS";
     }
@@ -5640,22 +5668,22 @@ var init_errors2 = __esm(() => {
     }
   };
   CacheError = class CacheError extends RequestError {
-    constructor(error2, request) {
-      super(error2.message, error2, request);
+    constructor(error2, request2) {
+      super(error2.message, error2, request2);
       this.name = "CacheError";
       this.code = this.code === "ERR_GOT_REQUEST_ERROR" ? "ERR_CACHE_ACCESS" : this.code;
     }
   };
   UploadError = class UploadError extends RequestError {
-    constructor(error2, request) {
-      super(error2.message, error2, request);
+    constructor(error2, request2) {
+      super(error2.message, error2, request2);
       this.name = "UploadError";
       this.code = this.code === "ERR_GOT_REQUEST_ERROR" ? "ERR_UPLOAD" : this.code;
     }
   };
   TimeoutError = class TimeoutError extends RequestError {
-    constructor(error2, timings, request) {
-      super(error2.message, error2, request);
+    constructor(error2, timings, request2) {
+      super(error2.message, error2, request2);
       Object.defineProperty(this, "timings", {
         enumerable: true,
         configurable: true,
@@ -5674,22 +5702,22 @@ var init_errors2 = __esm(() => {
     }
   };
   ReadError = class ReadError extends RequestError {
-    constructor(error2, request) {
-      super(error2.message, error2, request);
+    constructor(error2, request2) {
+      super(error2.message, error2, request2);
       this.name = "ReadError";
       this.code = this.code === "ERR_GOT_REQUEST_ERROR" ? "ERR_READING_RESPONSE_STREAM" : this.code;
     }
   };
   RetryError = class RetryError extends RequestError {
-    constructor(request) {
-      super("Retrying", {}, request);
+    constructor(request2) {
+      super("Retrying", {}, request2);
       this.name = "RetryError";
       this.code = "ERR_RETRYING";
     }
   };
   AbortError = class AbortError extends RequestError {
-    constructor(request) {
-      super("This operation was aborted.", {}, request);
+    constructor(request2) {
+      super("This operation was aborted.", {}, request2);
       this.code = "ERR_ABORTED";
       this.name = "AbortError";
     }
@@ -5744,9 +5772,9 @@ var require_source = __commonJS((exports, module) => {
 // ../../node_modules/@szmarczak/http-timer/dist/source/index.js
 import { errorMonitor } from "events";
 import { types as types2 } from "util";
-var import_defer_to_connect, timer2 = (request) => {
-  if (request.timings) {
-    return request.timings;
+var import_defer_to_connect, timer2 = (request2) => {
+  if (request2.timings) {
+    return request2.timings;
   }
   const timings = {
     start: Date.now(),
@@ -5770,19 +5798,19 @@ var import_defer_to_connect, timer2 = (request) => {
       total: undefined
     }
   };
-  request.timings = timings;
+  request2.timings = timings;
   const handleError = (origin) => {
     origin.once(errorMonitor, () => {
       timings.error = Date.now();
       timings.phases.total = timings.error - timings.start;
     });
   };
-  handleError(request);
+  handleError(request2);
   const onAbort = () => {
     timings.abort = Date.now();
     timings.phases.total = timings.abort - timings.start;
   };
-  request.prependOnceListener("abort", onAbort);
+  request2.prependOnceListener("abort", onAbort);
   const onSocket = (socket) => {
     timings.socket = Date.now();
     timings.phases.wait = timings.socket - timings.start;
@@ -5810,27 +5838,27 @@ var import_defer_to_connect, timer2 = (request) => {
       }
     });
   };
-  if (request.socket) {
-    onSocket(request.socket);
+  if (request2.socket) {
+    onSocket(request2.socket);
   } else {
-    request.prependOnceListener("socket", onSocket);
+    request2.prependOnceListener("socket", onSocket);
   }
   const onUpload = () => {
     timings.upload = Date.now();
     timings.phases.request = timings.upload - (timings.secureConnect ?? timings.connect);
   };
-  if (request.writableFinished) {
+  if (request2.writableFinished) {
     onUpload();
   } else {
-    request.prependOnceListener("finish", onUpload);
+    request2.prependOnceListener("finish", onUpload);
   }
-  request.prependOnceListener("response", (response) => {
+  request2.prependOnceListener("response", (response) => {
     timings.response = Date.now();
     timings.phases.firstByte = timings.response - timings.upload;
     response.timings = timings;
     handleError(response);
     response.prependOnceListener("end", () => {
-      request.off("abort", onAbort);
+      request2.off("abort", onAbort);
       response.off("aborted", onAbort);
       if (timings.phases.total) {
         return;
@@ -6120,7 +6148,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     const stream2 = bufferStream(options);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const rejectPromise = (error2) => {
         if (error2 && stream2.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error2.bufferedData = stream2.getBufferedValue();
@@ -6130,7 +6158,7 @@ var require_get_stream = __commonJS((exports, module) => {
       (async () => {
         try {
           await streamPipelinePromisified(inputStream, stream2);
-          resolve();
+          resolve2();
         } catch (error2) {
           rejectPromise(error2);
         }
@@ -6308,16 +6336,16 @@ var require_http_cache_semantics = __commonJS((exports, module) => {
         revalidation
       };
     }
-    _evaluateRequestRevalidation(request, synchronous) {
+    _evaluateRequestRevalidation(request2, synchronous) {
       return {
         synchronous,
-        headers: this.revalidationHeaders(request)
+        headers: this.revalidationHeaders(request2)
       };
     }
-    _evaluateRequestMissResult(request) {
+    _evaluateRequestMissResult(request2) {
       return {
         response: undefined,
-        revalidation: this._evaluateRequestRevalidation(request, true)
+        revalidation: this._evaluateRequestRevalidation(request2, true)
       };
     }
     evaluateRequest(req) {
@@ -6546,8 +6574,8 @@ var require_http_cache_semantics = __commonJS((exports, module) => {
       }
       return headers;
     }
-    revalidatedPolicy(request, response) {
-      this._assertRequestHasHeaders(request);
+    revalidatedPolicy(request2, response) {
+      this._assertRequestHasHeaders(request2);
       if (this._useStaleIfError() && isErrorResponse(response)) {
         return {
           policy: this,
@@ -6580,7 +6608,7 @@ var require_http_cache_semantics = __commonJS((exports, module) => {
       };
       if (!matches) {
         return {
-          policy: new this.constructor(request, response, optionsCopy),
+          policy: new this.constructor(request2, response, optionsCopy),
           modified: response.status != 304,
           matches: false
         };
@@ -6595,7 +6623,7 @@ var require_http_cache_semantics = __commonJS((exports, module) => {
         headers
       });
       return {
-        policy: new this.constructor(request, newResponse, optionsCopy),
+        policy: new this.constructor(request2, newResponse, optionsCopy),
         modified: false,
         matches: true
       };
@@ -7032,11 +7060,11 @@ class CacheableRequest {
         madeRequest = true;
         let requestErrored = false;
         let requestErrorCallback = () => {};
-        const requestErrorPromise = new Promise((resolve) => {
+        const requestErrorPromise = new Promise((resolve2) => {
           requestErrorCallback = () => {
             if (!requestErrored) {
               requestErrored = true;
-              resolve();
+              resolve2();
             }
           };
         });
@@ -7046,8 +7074,8 @@ class CacheableRequest {
             const revalidatedPolicy = import_http_cache_semantics.default.fromObject(revalidate.cachePolicy).revalidatedPolicy(options_, response);
             if (!revalidatedPolicy.modified) {
               response.resume();
-              await new Promise((resolve) => {
-                response.once("end", resolve);
+              await new Promise((resolve2) => {
+                response.once("end", resolve2);
               });
               const headers = convertHeaders(revalidatedPolicy.policy.responseHeaders());
               response = new Response({ statusCode: revalidate.statusCode, headers, body: revalidate.body, url: revalidate.url });
@@ -7067,8 +7095,8 @@ class CacheableRequest {
                 const bodyPromise = import_get_stream.default.buffer(response);
                 await Promise.race([
                   requestErrorPromise,
-                  new Promise((resolve) => response.once("end", resolve)),
-                  new Promise((resolve) => response.once("close", resolve))
+                  new Promise((resolve2) => response.once("end", resolve2)),
+                  new Promise((resolve2) => response.once("close", resolve2))
                 ]);
                 const body = await bodyPromise;
                 let value = {
@@ -7399,7 +7427,7 @@ var require_get_stream2 = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     const stream3 = bufferStream(options);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const rejectPromise = (error2) => {
         if (error2 && stream3.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error2.bufferedData = stream3.getBufferedValue();
@@ -7409,7 +7437,7 @@ var require_get_stream2 = __commonJS((exports, module) => {
       (async () => {
         try {
           await streamPipelinePromisified(inputStream, stream3);
-          resolve();
+          resolve2();
         } catch (error2) {
           rejectPromise(error2);
         }
@@ -7735,11 +7763,11 @@ function unhandle() {
 
 // ../../node_modules/got/dist/source/core/timed-out.js
 import net2 from "node:net";
-function timedOut(request, delays, options) {
-  if (reentry in request) {
+function timedOut(request2, delays, options) {
+  if (reentry in request2) {
     return noop3;
   }
-  request[reentry] = true;
+  request2[reentry] = true;
   const cancelers = [];
   const { once, unhandleAll } = unhandle();
   const addTimeout = (delay, callback, event) => {
@@ -7753,7 +7781,7 @@ function timedOut(request, delays, options) {
   };
   const { host, hostname } = options;
   const timeoutHandler = (delay, event) => {
-    request.destroy(new TimeoutError2(delay, event));
+    request2.destroy(new TimeoutError2(delay, event));
   };
   const cancelTimeouts = () => {
     for (const cancel of cancelers) {
@@ -7761,15 +7789,15 @@ function timedOut(request, delays, options) {
     }
     unhandleAll();
   };
-  request.once("error", (error2) => {
+  request2.once("error", (error2) => {
     cancelTimeouts();
-    if (request.listenerCount("error") === 0) {
+    if (request2.listenerCount("error") === 0) {
       throw error2;
     }
   });
   if (delays.request !== undefined) {
     const cancelTimeout = addTimeout(delays.request, timeoutHandler, "request");
-    once(request, "response", (response) => {
+    once(request2, "response", (response) => {
       once(response, "end", cancelTimeout);
     });
   }
@@ -7778,9 +7806,9 @@ function timedOut(request, delays, options) {
     const socketTimeoutHandler = () => {
       timeoutHandler(socket, "socket");
     };
-    request.setTimeout(socket, socketTimeoutHandler);
+    request2.setTimeout(socket, socketTimeoutHandler);
     cancelers.push(() => {
-      request.removeListener("timeout", socketTimeoutHandler);
+      request2.removeListener("timeout", socketTimeoutHandler);
     });
   }
   const hasLookup = delays.lookup !== undefined;
@@ -7788,8 +7816,8 @@ function timedOut(request, delays, options) {
   const hasSecureConnect = delays.secureConnect !== undefined;
   const hasSend = delays.send !== undefined;
   if (hasLookup || hasConnect || hasSecureConnect || hasSend) {
-    once(request, "socket", (socket) => {
-      const { socketPath } = request;
+    once(request2, "socket", (socket) => {
+      const { socketPath } = request2;
       if (socket.connecting) {
         const hasPath = Boolean(socketPath ?? net2.isIP(hostname ?? host ?? "") !== 0);
         if (hasLookup && !hasPath && socket.address().address === undefined) {
@@ -7819,22 +7847,22 @@ function timedOut(request, delays, options) {
         const timeRequest = () => addTimeout(delays.send, timeoutHandler, "send");
         if (socket.connecting) {
           once(socket, "connect", () => {
-            once(request, "upload-complete", timeRequest());
+            once(request2, "upload-complete", timeRequest());
           });
         } else {
-          once(request, "upload-complete", timeRequest());
+          once(request2, "upload-complete", timeRequest());
         }
       }
     });
   }
   if (delays.response !== undefined) {
-    once(request, "upload-complete", () => {
+    once(request2, "upload-complete", () => {
       const cancelTimeout = addTimeout(delays.response, timeoutHandler, "response");
-      once(request, "response", cancelTimeout);
+      once(request2, "response", cancelTimeout);
     });
   }
   if (delays.read !== undefined) {
-    once(request, "response", (response) => {
+    once(request2, "response", (response) => {
       const cancelTimeout = addTimeout(delays.read, timeoutHandler, "read");
       once(response, "end", cancelTimeout);
     });
@@ -8595,12 +8623,12 @@ var require_agent = __commonJS((exports, module) => {
       }
     }
     getSession(origin, options, listeners) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (Array.isArray(listeners) && listeners.length > 0) {
           listeners = [...listeners];
-          resolve();
+          resolve2();
         } else {
-          listeners = [{ resolve, reject }];
+          listeners = [{ resolve: resolve2, reject }];
         }
         try {
           if (typeof origin === "string") {
@@ -8879,14 +8907,14 @@ var require_agent = __commonJS((exports, module) => {
       });
     }
     request(origin, options, headers, streamOptions) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         this.getSession(origin, options, [{
           reject,
           resolve: (session) => {
             try {
               const stream2 = session.request(headers, streamOptions);
               delayAsyncDestroy(stream2);
-              resolve(stream2);
+              resolve2(stream2);
             } catch (error2) {
               reject(error2);
             }
@@ -9607,7 +9635,7 @@ var require_client_request = __commonJS((exports, module) => {
 // ../../node_modules/resolve-alpn/index.js
 var require_resolve_alpn = __commonJS((exports, module) => {
   var tls2 = __require("tls");
-  module.exports = (options = {}, connect = tls2.connect) => new Promise((resolve, reject) => {
+  module.exports = (options = {}, connect = tls2.connect) => new Promise((resolve2, reject) => {
     let timeout = false;
     let socket;
     const callback = async () => {
@@ -9615,14 +9643,14 @@ var require_resolve_alpn = __commonJS((exports, module) => {
       socket.off("timeout", onTimeout);
       socket.off("error", reject);
       if (options.resolveSocket) {
-        resolve({ alpnProtocol: socket.alpnProtocol, socket, timeout });
+        resolve2({ alpnProtocol: socket.alpnProtocol, socket, timeout });
         if (timeout) {
           await Promise.resolve();
           socket.emit("timeout");
         }
       } else {
         socket.destroy();
-        resolve({ alpnProtocol: socket.alpnProtocol, timeout });
+        resolve2({ alpnProtocol: socket.alpnProtocol, timeout });
       }
     };
     const onTimeout = async () => {
@@ -10025,11 +10053,11 @@ var require_h2_over_h2 = __commonJS((exports, module) => {
   var { globalAgent } = require_agent();
   var Http2OverHttpX = require_h2_over_hx();
   var getAuthorizationHeaders = require_get_auth_headers();
-  var getStatusCode = (stream2) => new Promise((resolve, reject) => {
+  var getStatusCode = (stream2) => new Promise((resolve2, reject) => {
     stream2.once("error", reject);
     stream2.once("response", (headers) => {
       stream2.off("error", reject);
-      resolve(headers[":status"]);
+      resolve2(headers[":status"]);
     });
   });
 
@@ -10056,14 +10084,14 @@ var require_h2_over_h1 = __commonJS((exports, module) => {
   var https = __require("https");
   var Http2OverHttpX = require_h2_over_hx();
   var getAuthorizationHeaders = require_get_auth_headers();
-  var getStream2 = (request) => new Promise((resolve, reject) => {
+  var getStream2 = (request2) => new Promise((resolve2, reject) => {
     const onConnect = (response, socket, head) => {
       socket.unshift(head);
-      request.off("error", reject);
-      resolve([socket, response.statusCode, response.statusMessage]);
+      request2.off("error", reject);
+      resolve2([socket, response.statusCode, response.statusMessage]);
     };
-    request.once("error", reject);
-    request.once("connect", onConnect);
+    request2.once("error", reject);
+    request2.once("connect", onConnect);
   });
 
   class Http2OverHttp extends Http2OverHttpX {
@@ -10071,7 +10099,7 @@ var require_h2_over_h1 = __commonJS((exports, module) => {
       const { proxyOptions } = this;
       const { url, headers } = this.proxyOptions;
       const network = url.protocol === "https:" ? https : http;
-      const request = network.request({
+      const request2 = network.request({
         ...proxyOptions,
         hostname: url.hostname,
         port: url.port,
@@ -10083,7 +10111,7 @@ var require_h2_over_h1 = __commonJS((exports, module) => {
         },
         method: "CONNECT"
       }).end();
-      return getStream2(request);
+      return getStream2(request2);
     }
   }
   module.exports = {
@@ -10113,7 +10141,7 @@ var require_source2 = __commonJS((exports, module) => {
   } = require_h2_over_h1();
   var validateHeaderName = require_validate_header_name();
   var validateHeaderValue = require_validate_header_value();
-  var request = (url, options, callback) => new ClientRequest(url, options, callback);
+  var request2 = (url, options, callback) => new ClientRequest(url, options, callback);
   var get = (url, options, callback) => {
     const req = new ClientRequest(url, options, callback);
     req.end();
@@ -10125,7 +10153,7 @@ var require_source2 = __commonJS((exports, module) => {
     IncomingMessage,
     Agent,
     globalAgent,
-    request,
+    request: request2,
     get,
     auto,
     proxies: {
@@ -11247,11 +11275,11 @@ var init_options = __esm(() => {
     }
     getRequestFunction() {
       const url = this._internals.url;
-      const { request } = this._internals;
-      if (!request && url) {
+      const { request: request2 } = this._internals;
+      if (!request2 && url) {
         return this.getFallbackRequestFunction();
       }
-      return request;
+      return request2;
     }
     getFallbackRequestFunction() {
       const url = this._internals.url;
@@ -11685,11 +11713,11 @@ var init_core = __esm(() => {
             return;
           }
           if (backoff2) {
-            await new Promise((resolve) => {
-              const timeout = setTimeout(resolve, backoff2);
+            await new Promise((resolve2) => {
+              const timeout = setTimeout(resolve2, backoff2);
               this._stopRetry = () => {
                 clearTimeout(timeout);
-                resolve();
+                resolve2();
               };
             });
             if (this.destroyed) {
@@ -11708,12 +11736,12 @@ var init_core = __esm(() => {
             }
             this.destroy();
             this.emit("retry", this.retryCount + 1, error2, (updatedOptions) => {
-              const request = new Request(options.url, updatedOptions, options);
-              request.retryCount = this.retryCount + 1;
+              const request2 = new Request(options.url, updatedOptions, options);
+              request2.retryCount = this.retryCount + 1;
               process3.nextTick(() => {
-                request.flush();
+                request2.flush();
               });
-              return request;
+              return request2;
             });
             return;
           }
@@ -12040,38 +12068,38 @@ var init_core = __esm(() => {
         this._beforeError(error2);
       }
     }
-    _onRequest(request) {
+    _onRequest(request2) {
       const { options } = this;
       const { timeout, url } = options;
-      source_default(request);
+      source_default(request2);
       if (this.options.http2) {
-        request.setTimeout(0);
+        request2.setTimeout(0);
       }
-      this._cancelTimeouts = timedOut(request, timeout, url);
+      this._cancelTimeouts = timedOut(request2, timeout, url);
       const responseEventName = options.cache ? "cacheableResponse" : "response";
-      request.once(responseEventName, (response) => {
+      request2.once(responseEventName, (response) => {
         this._onResponse(response);
       });
-      request.once("error", (error2) => {
+      request2.once("error", (error2) => {
         this._aborted = true;
-        request.destroy();
+        request2.destroy();
         error2 = error2 instanceof TimeoutError2 ? new TimeoutError(error2, this.timings, this) : new RequestError(error2.message, error2, this);
         this._beforeError(error2);
       });
-      this._unproxyEvents = proxyEvents(request, this, proxiedRequestEvents);
-      this._request = request;
+      this._unproxyEvents = proxyEvents(request2, this, proxiedRequestEvents);
+      this._request = request2;
       this.emit("uploadProgress", this.uploadProgress);
       this._sendBody();
-      this.emit("request", request);
+      this.emit("request", request2);
     }
     async _asyncWrite(chunk) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         super.write(chunk, (error2) => {
           if (error2) {
             reject(error2);
             return;
           }
-          resolve();
+          resolve2();
         });
       });
     }
@@ -12115,8 +12143,8 @@ var init_core = __esm(() => {
               } else if (event === "abort") {
                 (async () => {
                   try {
-                    const request = await result;
-                    request.once("abort", handler2);
+                    const request2 = await result;
+                    request2.once("abort", handler2);
                   } catch {}
                 })();
               } else {
@@ -12131,12 +12159,12 @@ var init_core = __esm(() => {
       }
     }
     async _createCacheableRequest(url, options) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         Object.assign(options, urlToOptions(url));
-        let request;
+        let request2;
         const cacheRequest = cacheableStore.get(options.cache)(options, async (response) => {
           response._readableState.autoDestroy = false;
-          if (request) {
+          if (request2) {
             const fix = () => {
               if (response.req) {
                 response.complete = response.req.res.complete;
@@ -12144,14 +12172,14 @@ var init_core = __esm(() => {
             };
             response.prependOnceListener("end", fix);
             fix();
-            (await request).emit("cacheableResponse", response);
+            (await request2).emit("cacheableResponse", response);
           }
-          resolve(response);
+          resolve2(response);
         });
         cacheRequest.once("error", reject);
         cacheRequest.once("request", async (requestOrPromise) => {
-          request = requestOrPromise;
-          resolve(request);
+          request2 = requestOrPromise;
+          resolve2(request2);
         });
       });
     }
@@ -12180,26 +12208,26 @@ var init_core = __esm(() => {
         }
       }
       options.prefixUrl = "";
-      let request;
+      let request2;
       for (const hook of options.hooks.beforeRequest) {
         const result = await hook(options);
         if (!dist_default.undefined(result)) {
-          request = () => result;
+          request2 = () => result;
           break;
         }
       }
-      if (!request) {
-        request = options.getRequestFunction();
+      if (!request2) {
+        request2 = options.getRequestFunction();
       }
       const url = options.url;
       this._requestOptions = options.createNativeRequestOptions();
       if (options.cache) {
-        this._requestOptions._request = request;
+        this._requestOptions._request = request2;
         this._requestOptions.cache = options.cache;
         this._requestOptions.body = options.body;
         this._prepareCache(options.cache);
       }
-      const fn = options.cache ? this._createCacheableRequest : request;
+      const fn = options.cache ? this._createCacheableRequest : request2;
       try {
         let requestOrResponse = fn(url, this._requestOptions);
         if (dist_default.promise(requestOrResponse)) {
@@ -12311,8 +12339,8 @@ var CancelError2;
 var init_types3 = __esm(() => {
   init_errors2();
   CancelError2 = class CancelError2 extends RequestError {
-    constructor(request) {
-      super("Promise was canceled", {}, request);
+    constructor(request2) {
+      super("Promise was canceled", {}, request2);
       this.name = "CancelError";
       this.code = "ERR_CANCELED";
     }
@@ -12329,7 +12357,7 @@ function asPromise(firstRequest) {
   let globalResponse;
   let normalizedOptions;
   const emitter = new EventEmitter2;
-  const promise = new PCancelable((resolve, reject, onCancel) => {
+  const promise = new PCancelable((resolve2, reject, onCancel) => {
     onCancel(() => {
       globalRequest.destroy();
     });
@@ -12339,14 +12367,14 @@ function asPromise(firstRequest) {
     });
     const makeRequest = (retryCount) => {
       onCancel(() => {});
-      const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
-      request.retryCount = retryCount;
-      request._noPipe = true;
-      globalRequest = request;
-      request.once("response", async (response) => {
+      const request2 = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
+      request2.retryCount = retryCount;
+      request2._noPipe = true;
+      globalRequest = request2;
+      request2.once("response", async (response) => {
         const contentEncoding = (response.headers["content-encoding"] ?? "").toLowerCase();
         const isCompressed = contentEncoding === "gzip" || contentEncoding === "deflate" || contentEncoding === "br";
-        const { options } = request;
+        const { options } = request2;
         if (isCompressed && !options.decompress) {
           response.body = response.rawBody;
         } else {
@@ -12355,7 +12383,7 @@ function asPromise(firstRequest) {
           } catch (error2) {
             response.body = response.rawBody.toString();
             if (isResponseOk(response)) {
-              request._beforeError(error2);
+              request2._beforeError(error2);
               return;
             }
           }
@@ -12370,53 +12398,53 @@ function asPromise(firstRequest) {
                 options.url = updatedOptions.url;
               }
               options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
-              throw new RetryError(request);
+              throw new RetryError(request2);
             });
             if (!(dist_default.object(response) && dist_default.number(response.statusCode) && !dist_default.nullOrUndefined(response.body))) {
               throw new TypeError("The `afterResponse` hook returned an invalid value");
             }
           }
         } catch (error2) {
-          request._beforeError(error2);
+          request2._beforeError(error2);
           return;
         }
         globalResponse = response;
         if (!isResponseOk(response)) {
-          request._beforeError(new HTTPError(response));
+          request2._beforeError(new HTTPError(response));
           return;
         }
-        request.destroy();
-        resolve(request.options.resolveBodyOnly ? response.body : response);
+        request2.destroy();
+        resolve2(request2.options.resolveBodyOnly ? response.body : response);
       });
       const onError = (error2) => {
         if (promise.isCanceled) {
           return;
         }
-        const { options } = request;
+        const { options } = request2;
         if (error2 instanceof HTTPError && !options.throwHttpErrors) {
           const { response } = error2;
-          request.destroy();
-          resolve(request.options.resolveBodyOnly ? response.body : response);
+          request2.destroy();
+          resolve2(request2.options.resolveBodyOnly ? response.body : response);
           return;
         }
         reject(error2);
       };
-      request.once("error", onError);
-      const previousBody = request.options?.body;
-      request.once("retry", (newRetryCount, error2) => {
+      request2.once("error", onError);
+      const previousBody = request2.options?.body;
+      request2.once("retry", (newRetryCount, error2) => {
         firstRequest = undefined;
-        const newBody = request.options.body;
+        const newBody = request2.options.body;
         if (previousBody === newBody && dist_default.nodeStream(newBody)) {
           error2.message = "Cannot retry with consumed body stream";
           onError(error2);
           return;
         }
-        normalizedOptions = request.options;
+        normalizedOptions = request2.options;
         makeRequest(newRetryCount);
       });
-      proxyEvents(request, emitter, proxiedRequestEvents2);
+      proxyEvents(request2, emitter, proxiedRequestEvents2);
       if (dist_default.undefined(firstRequest)) {
-        request.flush();
+        request2.flush();
       }
     };
     makeRequest(0);
@@ -12469,8 +12497,8 @@ var init_as_promise = __esm(() => {
 });
 
 // ../../node_modules/got/dist/source/create.js
-var delay = async (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
+var delay = async (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
 }), isGotInstance = (value) => dist_default.function_(value), aliases, create = (defaults) => {
   defaults = {
     options: new Options(undefined, undefined, defaults.options),
@@ -12483,17 +12511,17 @@ var delay = async (ms) => new Promise((resolve) => {
     writable: false
   });
   const got = (url, options, defaultOptions2 = defaults.options) => {
-    const request = new Request(url, options, defaultOptions2);
+    const request2 = new Request(url, options, defaultOptions2);
     let promise;
     const lastHandler = (normalized) => {
-      request.options = normalized;
-      request._noPipe = !normalized.isStream;
-      request.flush();
+      request2.options = normalized;
+      request2._noPipe = !normalized.isStream;
+      request2.flush();
       if (normalized.isStream) {
-        return request;
+        return request2;
       }
       if (!promise) {
-        promise = asPromise(request);
+        promise = asPromise(request2);
       }
       return promise;
     };
@@ -12501,9 +12529,9 @@ var delay = async (ms) => new Promise((resolve) => {
     const iterateHandlers = (newOptions) => {
       const handler = defaults.handlers[iteration++] ?? lastHandler;
       const result = handler(newOptions, iterateHandlers);
-      if (dist_default.promise(result) && !request.options.isStream) {
+      if (dist_default.promise(result) && !request2.options.isStream) {
         if (!promise) {
-          promise = asPromise(request);
+          promise = asPromise(request2);
         }
         if (result !== promise) {
           const descriptors = Object.getOwnPropertyDescriptors(promise);
@@ -12518,7 +12546,7 @@ var delay = async (ms) => new Promise((resolve) => {
       }
       return result;
     };
-    return iterateHandlers(request.options);
+    return iterateHandlers(request2.options);
   };
   got.extend = (...instancesOrOptions) => {
     const options = new Options(undefined, undefined, defaults.options);
@@ -12699,9 +12727,9 @@ class StacksApiClient {
   async ensureProxy() {
     if (!this.useProxy || this.baseUrl)
       return;
-    const config = await loadConfig();
-    this.baseUrl = resolveApiUrl(config);
-    this.headers = authHeaders(config);
+    const { apiUrl, ephemeralKey } = await resolveActiveTenant();
+    this.baseUrl = apiUrl;
+    this.headers = { authorization: `Bearer ${ephemeralKey}` };
   }
   async fetchWithErrorHandling(url, resourceType, resourceId) {
     try {
@@ -12741,8 +12769,7 @@ class StacksApiClient {
 var gotWithRetry;
 var init_api = __esm(() => {
   init_source3();
-  init_api_client();
-  init_config();
+  init_resolve_tenant();
   gotWithRetry = source_default2.extend({
     timeout: { request: 30000 },
     retry: {
@@ -13151,11 +13178,11 @@ var init_manager = __esm(() => {
 });
 
 // src/services/indexer.ts
-import { dirname, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, resolve as resolve3 } from "node:path";
 async function startIndexer(options2) {
   const port = options2.port ?? 3700;
-  const rootDir = dirname(dirname(dirname(dirname(import.meta.dir))));
-  const indexerPath = resolve2(rootDir, "packages/indexer/src/index.ts");
+  const rootDir = dirname3(dirname3(dirname3(dirname3(import.meta.dir))));
+  const indexerPath = resolve3(rootDir, "packages/indexer/src/index.ts");
   await serviceManager.start(SERVICE_NAME, ["bun", "run", "--watch", indexerPath], {
     port,
     env: {
@@ -13171,10 +13198,10 @@ var init_indexer = __esm(() => {
 });
 
 // src/services/worker.ts
-import { dirname as dirname2, resolve as resolve3 } from "node:path";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
 async function startWorker(options2) {
-  const rootDir = dirname2(dirname2(dirname2(dirname2(import.meta.dir))));
-  const workerPath = resolve3(rootDir, "packages/worker/src/index.ts");
+  const rootDir = dirname4(dirname4(dirname4(dirname4(import.meta.dir))));
+  const workerPath = resolve4(rootDir, "packages/worker/src/index.ts");
   await serviceManager.start(SERVICE_NAME2, ["bun", "run", "--watch", workerPath], {
     onStdout: options2.onLog,
     onStderr: options2.onLog
@@ -13186,11 +13213,11 @@ var init_worker = __esm(() => {
 });
 
 // src/services/api.ts
-import { dirname as dirname3, resolve as resolve4 } from "node:path";
+import { dirname as dirname5, resolve as resolve5 } from "node:path";
 async function startApi(options2) {
   const port = options2.port ?? 3800;
-  const rootDir = dirname3(dirname3(dirname3(dirname3(import.meta.dir))));
-  const apiPath = resolve4(rootDir, "packages/api/src/index.ts");
+  const rootDir = dirname5(dirname5(dirname5(dirname5(import.meta.dir))));
+  const apiPath = resolve5(rootDir, "packages/api/src/index.ts");
   await serviceManager.start(SERVICE_NAME3, ["bun", "run", "--watch", apiPath], {
     port,
     env: {
@@ -13206,10 +13233,10 @@ var init_api2 = __esm(() => {
 });
 
 // src/services/subgraph-processor.ts
-import { dirname as dirname4, resolve as resolve5 } from "node:path";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 async function startSubgraphProcessor(options2) {
-  const rootDir = dirname4(dirname4(dirname4(dirname4(import.meta.dir))));
-  const servicePath = resolve5(rootDir, "packages/subgraphs/src/service.ts");
+  const rootDir = dirname6(dirname6(dirname6(dirname6(import.meta.dir))));
+  const servicePath = resolve6(rootDir, "packages/subgraphs/src/service.ts");
   await serviceManager.start(SERVICE_NAME4, ["bun", "run", "--watch", servicePath], {
     env: {
       SUBGRAPH_CONCURRENCY: String(options2.concurrency ?? 5)
@@ -13244,7 +13271,7 @@ __export(exports_dev_impl, {
   isDevAlreadyRunning: () => isDevAlreadyRunning
 });
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname5, join as join4, resolve as resolve6 } from "node:path";
+import { dirname as dirname7, join as join6, resolve as resolve7 } from "node:path";
 async function isDevAlreadyRunning() {
   if (await isDevRunning()) {
     const running = await getRunningServices();
@@ -13308,7 +13335,7 @@ async function runBackground(options2) {
   if (!databaseUrl) {
     info("Starting PostgreSQL container...");
     startedPostgres = await ensureDevPostgres(dataDir);
-    databaseUrl = DEV_DATABASE_URL3;
+    databaseUrl = DEV_DATABASE_URL2;
     console.log(green("  ✓ PostgreSQL"), dim(`localhost:5432 (data: ${dataDir}/postgres)`));
     info("Running migrations...");
     await runMigrations(databaseUrl);
@@ -13322,10 +13349,10 @@ async function runBackground(options2) {
     startedAt: new Date().toISOString()
   };
   try {
-    const packagesDir = dirname5(dirname5(dirname5(dirname5(import.meta.dir))));
+    const packagesDir = dirname7(dirname7(dirname7(dirname7(import.meta.dir))));
     const env = { DATABASE_URL: databaseUrl, DEV_MODE: "true" };
     const apiLogFile = getLogFile("api");
-    const apiProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/api/src/index.ts")], {
+    const apiProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/api/src/index.ts")], {
       env: { ...process.env, ...env, PORT: String(apiPort) },
       stdout: Bun.file(apiLogFile),
       stderr: Bun.file(apiLogFile)
@@ -13338,7 +13365,7 @@ async function runBackground(options2) {
     };
     console.log(green("  ✓ API"), dim(`http://localhost:${apiPort}`));
     const indexerLogFile = getLogFile("indexer");
-    const indexerProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/indexer/src/index.ts")], {
+    const indexerProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/indexer/src/index.ts")], {
       env: { ...process.env, ...env, PORT: String(indexerPort) },
       stdout: Bun.file(indexerLogFile),
       stderr: Bun.file(indexerLogFile)
@@ -13352,7 +13379,7 @@ async function runBackground(options2) {
     console.log(green("  ✓ Indexer"), dim(`http://localhost:${indexerPort}`));
     if (options2.worker) {
       const workerLogFile = getLogFile("worker");
-      const workerProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/worker/src/index.ts")], {
+      const workerProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/worker/src/index.ts")], {
         env: { ...process.env, ...env },
         stdout: Bun.file(workerLogFile),
         stderr: Bun.file(workerLogFile)
@@ -13370,7 +13397,7 @@ async function runBackground(options2) {
       const subgraphsProc = Bun.spawn([
         "bun",
         "run",
-        resolve6(packagesDir, "packages/subgraphs/src/service.ts")
+        resolve7(packagesDir, "packages/subgraphs/src/service.ts")
       ], {
         env: { ...process.env, ...env },
         stdout: Bun.file(subgraphsLogFile),
@@ -13470,7 +13497,7 @@ async function runForeground(options2) {
     if (!databaseUrl) {
       info("Starting PostgreSQL container...");
       devPostgresStarted = await ensureDevPostgres(dataDir);
-      databaseUrl = DEV_DATABASE_URL3;
+      databaseUrl = DEV_DATABASE_URL2;
       process.env.DATABASE_URL = databaseUrl;
       console.log(green("  ✓ PostgreSQL"), dim(`localhost:5432 (data: ${dataDir}/postgres)`));
       info("Running migrations...");
@@ -13669,7 +13696,7 @@ async function restartDev() {
   await clearDevState();
   await clearLogs();
   const config = await loadConfig();
-  const packagesDir = dirname5(dirname5(dirname5(dirname5(import.meta.dir))));
+  const packagesDir = dirname7(dirname7(dirname7(dirname7(import.meta.dir))));
   const env = state.env;
   const newState = {
     services: {},
@@ -13679,7 +13706,7 @@ async function restartDev() {
   };
   const apiPort = config.ports.api;
   const apiLogFile = getLogFile("api");
-  const apiProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/api/src/index.ts")], {
+  const apiProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/api/src/index.ts")], {
     env: { ...process.env, ...env, PORT: String(apiPort) },
     stdout: Bun.file(apiLogFile),
     stderr: Bun.file(apiLogFile)
@@ -13693,7 +13720,7 @@ async function restartDev() {
   console.log(green("  ✓ API"), dim(`http://localhost:${apiPort}`));
   const indexerPort = config.ports.indexer;
   const indexerLogFile = getLogFile("indexer");
-  const indexerProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/indexer/src/index.ts")], {
+  const indexerProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/indexer/src/index.ts")], {
     env: { ...process.env, ...env, PORT: String(indexerPort) },
     stdout: Bun.file(indexerLogFile),
     stderr: Bun.file(indexerLogFile)
@@ -13707,7 +13734,7 @@ async function restartDev() {
   console.log(green("  ✓ Indexer"), dim(`http://localhost:${indexerPort}`));
   if (state.services.worker) {
     const workerLogFile = getLogFile("worker");
-    const workerProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/worker/src/index.ts")], {
+    const workerProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/worker/src/index.ts")], {
       env: { ...process.env, ...env },
       stdout: Bun.file(workerLogFile),
       stderr: Bun.file(workerLogFile)
@@ -13722,7 +13749,7 @@ async function restartDev() {
   }
   if (state.services.subgraphs) {
     const subgraphsLogFile = getLogFile("subgraphs");
-    const subgraphsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/subgraphs/src/service.ts")], {
+    const subgraphsProc = Bun.spawn(["bun", "run", resolve7(packagesDir, "packages/subgraphs/src/service.ts")], {
       env: { ...process.env, ...env },
       stdout: Bun.file(subgraphsLogFile),
       stderr: Bun.file(subgraphsLogFile)
@@ -13850,7 +13877,7 @@ async function ensureDevPostgres(dataDir) {
   if (check.stdout.toString().trim()) {
     return false;
   }
-  const pgDataDir = join4(dataDir, "postgres");
+  const pgDataDir = join6(dataDir, "postgres");
   mkdirSync2(pgDataDir, { recursive: true });
   const stopped = await Bun.$`docker ps -aq -f name=secondlayer-dev-postgres`.quiet().nothrow();
   if (stopped.stdout.toString().trim()) {
@@ -13866,14 +13893,14 @@ async function ensureDevPostgres(dataDir) {
   throw new Error("PostgreSQL failed to start");
 }
 async function runMigrations(databaseUrl) {
-  const packagesDir = dirname5(dirname5(dirname5(dirname5(import.meta.dir))));
-  const migrateScript = resolve6(packagesDir, "packages/shared/src/db/migrate.ts");
+  const packagesDir = dirname7(dirname7(dirname7(dirname7(import.meta.dir))));
+  const migrateScript = resolve7(packagesDir, "packages/shared/src/db/migrate.ts");
   const result = await Bun.$`DATABASE_URL=${databaseUrl} bun run ${migrateScript}`.quiet().nothrow();
   if (result.exitCode !== 0) {
     throw new Error(`Migration failed: ${result.stderr.toString()}`);
   }
 }
-var DEV_DATABASE_URL3 = "postgres://postgres:postgres@localhost:5432/secondlayer_dev", serviceColors;
+var DEV_DATABASE_URL2 = "postgres://postgres:postgres@localhost:5432/secondlayer_dev", serviceColors;
 var init_dev_impl = __esm(() => {
   init_config();
   init_dev_state();
@@ -13900,7 +13927,7 @@ __export(exports_node_impl, {
   runSetupWizard: () => runSetupWizard,
   restartNode: () => restartNode
 });
-import { confirm as confirm4, input as input2, select as select2 } from "@inquirer/prompts";
+import { confirm as confirm3, input, select as select2 } from "@inquirer/prompts";
 async function runSetupWizard() {
   console.log("");
   console.log(blue("Stacks Node Setup Wizard"));
@@ -13918,7 +13945,7 @@ async function runSetupWizard() {
   }
   success("Docker is running");
   console.log("");
-  const installPath = await input2({
+  const installPath = await input({
     message: "Where is stacks-blockchain-docker installed?",
     validate: async (value) => {
       if (!value.trim())
@@ -13937,18 +13964,18 @@ async function runSetupWizard() {
     ],
     default: "mainnet"
   });
-  const autoStartIndexer = await confirm4({
+  const autoStartIndexer = await confirm3({
     message: "Auto-start indexer when node starts?",
     default: true
   });
   let indexerPort = 3700;
   if (autoStartIndexer) {
-    const customPort = await confirm4({
+    const customPort = await confirm3({
       message: "Use default indexer port (3700)?",
       default: true
     });
     if (!customPort) {
-      const portInput = await input2({
+      const portInput = await input({
         message: "Enter custom indexer port:",
         default: "3700",
         validate: (value) => {
@@ -14049,7 +14076,7 @@ async function stopNode(_pathOverride, force, _wait) {
     return;
   }
   if (!force) {
-    const proceed = await confirm4({
+    const proceed = await confirm3({
       message: "Stop the Stacks node?",
       default: false
     });
@@ -14079,7 +14106,7 @@ async function restartNode(pathOverride, force, _wait) {
   const wasRunning = await isNodeRunning();
   if (wasRunning) {
     if (!force) {
-      const proceed = await confirm4({
+      const proceed = await confirm3({
         message: "Restart the Stacks node?",
         default: false
       });
@@ -15429,8 +15456,8 @@ var require_fill_range = __commonJS((exports, module) => {
     return typeof value === "number" || typeof value === "string" && value !== "";
   };
   var isNumber = (num) => Number.isInteger(+num);
-  var zeros = (input3) => {
-    let value = `${input3}`;
+  var zeros = (input5) => {
+    let value = `${input5}`;
     let index = -1;
     if (value[0] === "-")
       value = value.slice(1);
@@ -15446,27 +15473,27 @@ var require_fill_range = __commonJS((exports, module) => {
     }
     return options2.stringify === true;
   };
-  var pad = (input3, maxLength, toNumber) => {
+  var pad = (input5, maxLength, toNumber) => {
     if (maxLength > 0) {
-      let dash = input3[0] === "-" ? "-" : "";
+      let dash = input5[0] === "-" ? "-" : "";
       if (dash)
-        input3 = input3.slice(1);
-      input3 = dash + input3.padStart(dash ? maxLength - 1 : maxLength, "0");
+        input5 = input5.slice(1);
+      input5 = dash + input5.padStart(dash ? maxLength - 1 : maxLength, "0");
     }
     if (toNumber === false) {
-      return String(input3);
+      return String(input5);
     }
-    return input3;
+    return input5;
   };
-  var toMaxLen = (input3, maxLength) => {
-    let negative = input3[0] === "-" ? "-" : "";
+  var toMaxLen = (input5, maxLength) => {
+    let negative = input5[0] === "-" ? "-" : "";
     if (negative) {
-      input3 = input3.slice(1);
+      input5 = input5.slice(1);
       maxLength--;
     }
-    while (input3.length < maxLength)
-      input3 = "0" + input3;
-    return negative ? "-" + input3 : input3;
+    while (input5.length < maxLength)
+      input5 = "0" + input5;
+    return negative ? "-" + input5 : input5;
   };
   var toSequence = (parts, options2, maxLen) => {
     parts.negatives.sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
@@ -15835,25 +15862,25 @@ var require_parse = __commonJS((exports, module) => {
     CHAR_NO_BREAK_SPACE,
     CHAR_ZERO_WIDTH_NOBREAK_SPACE
   } = require_constants();
-  var parse2 = (input3, options2 = {}) => {
-    if (typeof input3 !== "string") {
+  var parse2 = (input5, options2 = {}) => {
+    if (typeof input5 !== "string") {
       throw new TypeError("Expected a string");
     }
     const opts = options2 || {};
     const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-    if (input3.length > max) {
-      throw new SyntaxError(`Input length (${input3.length}), exceeds max characters (${max})`);
+    if (input5.length > max) {
+      throw new SyntaxError(`Input length (${input5.length}), exceeds max characters (${max})`);
     }
-    const ast = { type: "root", input: input3, nodes: [] };
+    const ast = { type: "root", input: input5, nodes: [] };
     const stack = [ast];
     let block = ast;
     let prev = ast;
     let brackets = 0;
-    const length = input3.length;
+    const length = input5.length;
     let index = 0;
     let depth = 0;
     let value;
-    const advance = () => input3[index++];
+    const advance = () => input5[index++];
     const push = (node) => {
       if (node.type === "text" && prev.type === "dot") {
         prev.type = "text";
@@ -16048,10 +16075,10 @@ var require_braces = __commonJS((exports, module) => {
   var compile = require_compile();
   var expand = require_expand();
   var parse2 = require_parse();
-  var braces = (input3, options2 = {}) => {
+  var braces = (input5, options2 = {}) => {
     let output = [];
-    if (Array.isArray(input3)) {
-      for (const pattern of input3) {
+    if (Array.isArray(input5)) {
+      for (const pattern of input5) {
         const result = braces.create(pattern, options2);
         if (Array.isArray(result)) {
           output.push(...result);
@@ -16060,31 +16087,31 @@ var require_braces = __commonJS((exports, module) => {
         }
       }
     } else {
-      output = [].concat(braces.create(input3, options2));
+      output = [].concat(braces.create(input5, options2));
     }
     if (options2 && options2.expand === true && options2.nodupes === true) {
       output = [...new Set(output)];
     }
     return output;
   };
-  braces.parse = (input3, options2 = {}) => parse2(input3, options2);
-  braces.stringify = (input3, options2 = {}) => {
-    if (typeof input3 === "string") {
-      return stringify2(braces.parse(input3, options2), options2);
+  braces.parse = (input5, options2 = {}) => parse2(input5, options2);
+  braces.stringify = (input5, options2 = {}) => {
+    if (typeof input5 === "string") {
+      return stringify2(braces.parse(input5, options2), options2);
     }
-    return stringify2(input3, options2);
+    return stringify2(input5, options2);
   };
-  braces.compile = (input3, options2 = {}) => {
-    if (typeof input3 === "string") {
-      input3 = braces.parse(input3, options2);
+  braces.compile = (input5, options2 = {}) => {
+    if (typeof input5 === "string") {
+      input5 = braces.parse(input5, options2);
     }
-    return compile(input3, options2);
+    return compile(input5, options2);
   };
-  braces.expand = (input3, options2 = {}) => {
-    if (typeof input3 === "string") {
-      input3 = braces.parse(input3, options2);
+  braces.expand = (input5, options2 = {}) => {
+    if (typeof input5 === "string") {
+      input5 = braces.parse(input5, options2);
     }
-    let result = expand(input3, options2);
+    let result = expand(input5, options2);
     if (options2.noempty === true) {
       result = result.filter(Boolean);
     }
@@ -16093,11 +16120,11 @@ var require_braces = __commonJS((exports, module) => {
     }
     return result;
   };
-  braces.create = (input3, options2 = {}) => {
-    if (input3 === "" || input3.length < 3) {
-      return [input3];
+  braces.create = (input5, options2 = {}) => {
+    if (input5 === "" || input5.length < 3) {
+      return [input5];
     }
-    return options2.expand !== true ? braces.compile(input3, options2) : braces.expand(input3, options2);
+    return options2.expand !== true ? braces.compile(input5, options2) : braces.expand(input5, options2);
   };
   module.exports = braces;
 });
@@ -16275,26 +16302,26 @@ var require_utils2 = __commonJS((exports) => {
     }
     return win32 === true || path.sep === "\\";
   };
-  exports.escapeLast = (input3, char, lastIdx) => {
-    const idx = input3.lastIndexOf(char, lastIdx);
+  exports.escapeLast = (input5, char, lastIdx) => {
+    const idx = input5.lastIndexOf(char, lastIdx);
     if (idx === -1)
-      return input3;
-    if (input3[idx - 1] === "\\")
-      return exports.escapeLast(input3, char, idx - 1);
-    return `${input3.slice(0, idx)}\\${input3.slice(idx)}`;
+      return input5;
+    if (input5[idx - 1] === "\\")
+      return exports.escapeLast(input5, char, idx - 1);
+    return `${input5.slice(0, idx)}\\${input5.slice(idx)}`;
   };
-  exports.removePrefix = (input3, state = {}) => {
-    let output = input3;
+  exports.removePrefix = (input5, state = {}) => {
+    let output = input5;
     if (output.startsWith("./")) {
       output = output.slice(2);
       state.prefix = "./";
     }
     return output;
   };
-  exports.wrapOutput = (input3, state = {}, options2 = {}) => {
+  exports.wrapOutput = (input5, state = {}, options2 = {}) => {
     const prepend = options2.contains ? "" : "^";
     const append = options2.contains ? "" : "$";
-    let output = `${prepend}(?:${input3})${append}`;
+    let output = `${prepend}(?:${input5})${append}`;
     if (state.negated === true) {
       output = `(?:^(?!${output}).*$)`;
     }
@@ -16330,14 +16357,14 @@ var require_scan = __commonJS((exports, module) => {
       token.depth = token.isGlobstar ? Infinity : 1;
     }
   };
-  var scan = (input3, options2) => {
+  var scan = (input5, options2) => {
     const opts = options2 || {};
-    const length = input3.length - 1;
+    const length = input5.length - 1;
     const scanToEnd = opts.parts === true || opts.scanToEnd === true;
     const slashes = [];
     const tokens = [];
     const parts = [];
-    let str = input3;
+    let str = input5;
     let index = -1;
     let start = 0;
     let lastIndex = 0;
@@ -16560,7 +16587,7 @@ var require_scan = __commonJS((exports, module) => {
     }
     const state = {
       prefix,
-      input: input3,
+      input: input5,
       start,
       base,
       glob,
@@ -16584,7 +16611,7 @@ var require_scan = __commonJS((exports, module) => {
       for (let idx = 0;idx < slashes.length; idx++) {
         const n = prevIndex ? prevIndex + 1 : start;
         const i = slashes[idx];
-        const value = input3.slice(n, i);
+        const value = input5.slice(n, i);
         if (opts.tokens) {
           if (idx === 0 && start !== 0) {
             tokens[idx].isPrefix = true;
@@ -16600,8 +16627,8 @@ var require_scan = __commonJS((exports, module) => {
         }
         prevIndex = i;
       }
-      if (prevIndex && prevIndex + 1 < input3.length) {
-        const value = input3.slice(prevIndex + 1);
+      if (prevIndex && prevIndex + 1 < input5.length) {
+        const value = input5.slice(prevIndex + 1);
         parts.push(value);
         if (opts.tokens) {
           tokens[tokens.length - 1].value = value;
@@ -16644,14 +16671,14 @@ var require_parse2 = __commonJS((exports, module) => {
   var syntaxError = (type, char) => {
     return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
-  var parse2 = (input3, options2) => {
-    if (typeof input3 !== "string") {
+  var parse2 = (input5, options2) => {
+    if (typeof input5 !== "string") {
       throw new TypeError("Expected a string");
     }
-    input3 = REPLACEMENTS[input3] || input3;
+    input5 = REPLACEMENTS[input5] || input5;
     const opts = { ...options2 };
     const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-    let len = input3.length;
+    let len = input5.length;
     if (len > max) {
       throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
     }
@@ -16688,7 +16715,7 @@ var require_parse2 = __commonJS((exports, module) => {
       opts.noextglob = opts.noext;
     }
     const state = {
-      input: input3,
+      input: input5,
       index: -1,
       start: 0,
       dot: opts.dot === true,
@@ -16704,17 +16731,17 @@ var require_parse2 = __commonJS((exports, module) => {
       globstar: false,
       tokens
     };
-    input3 = utils.removePrefix(input3, state);
-    len = input3.length;
+    input5 = utils.removePrefix(input5, state);
+    len = input5.length;
     const extglobs = [];
     const braces = [];
     const stack = [];
     let prev = bos;
     let value;
     const eos = () => state.index === len - 1;
-    const peek = state.peek = (n = 1) => input3[state.index + n];
-    const advance = state.advance = () => input3[++state.index] || "";
-    const remaining = () => input3.slice(state.index + 1);
+    const peek = state.peek = (n = 1) => input5[state.index + n];
+    const advance = state.advance = () => input5[++state.index] || "";
+    const remaining = () => input5.slice(state.index + 1);
     const consume = (value2 = "", num = 0) => {
       state.consumed += value2;
       state.index += num;
@@ -16804,9 +16831,9 @@ var require_parse2 = __commonJS((exports, module) => {
       push({ type: "paren", extglob: true, value, output });
       decrement("parens");
     };
-    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input3)) {
+    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input5)) {
       let backslashes = false;
-      let output = input3.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+      let output = input5.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
         if (first === "\\") {
           backslashes = true;
           return m;
@@ -16840,8 +16867,8 @@ var require_parse2 = __commonJS((exports, module) => {
           });
         }
       }
-      if (output === input3 && opts.contains === true) {
-        state.output = input3;
+      if (output === input5 && opts.contains === true) {
+        state.output = input5;
         return state;
       }
       state.output = utils.wrapOutput(output, state, options2);
@@ -17200,7 +17227,7 @@ var require_parse2 = __commonJS((exports, module) => {
           continue;
         }
         while (rest.slice(0, 3) === "/**") {
-          const after = input3[state.index + 4];
+          const after = input5[state.index + 4];
           if (after && after !== "/") {
             break;
           }
@@ -17323,14 +17350,14 @@ var require_parse2 = __commonJS((exports, module) => {
     }
     return state;
   };
-  parse2.fastpaths = (input3, options2) => {
+  parse2.fastpaths = (input5, options2) => {
     const opts = { ...options2 };
     const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-    const len = input3.length;
+    const len = input5.length;
     if (len > max) {
       throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
     }
-    input3 = REPLACEMENTS[input3] || input3;
+    input5 = REPLACEMENTS[input5] || input5;
     const win32 = utils.isWindows(options2);
     const {
       DOT_LITERAL,
@@ -17385,7 +17412,7 @@ var require_parse2 = __commonJS((exports, module) => {
         }
       }
     };
-    const output = utils.removePrefix(input3, state);
+    const output = utils.removePrefix(input5, state);
     let source = create2(output);
     if (source && opts.strictSlashes !== true) {
       source += `${SLASH_LITERAL}?`;
@@ -17405,7 +17432,7 @@ var require_picomatch = __commonJS((exports, module) => {
   var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
   var picomatch = (glob, options2, returnState = false) => {
     if (Array.isArray(glob)) {
-      const fns = glob.map((input3) => picomatch(input3, options2, returnState));
+      const fns = glob.map((input5) => picomatch(input5, options2, returnState));
       const arrayMatcher = (str) => {
         for (const isMatch of fns) {
           const state2 = isMatch(str);
@@ -17430,9 +17457,9 @@ var require_picomatch = __commonJS((exports, module) => {
       const ignoreOpts = { ...options2, ignore: null, onMatch: null, onResult: null };
       isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
     }
-    const matcher = (input3, returnObject = false) => {
-      const { isMatch, match, output } = picomatch.test(input3, regex, options2, { glob, posix });
-      const result = { glob, state, regex, posix, input: input3, output, match, isMatch };
+    const matcher = (input5, returnObject = false) => {
+      const { isMatch, match, output } = picomatch.test(input5, regex, options2, { glob, posix });
+      const result = { glob, state, regex, posix, input: input5, output, match, isMatch };
       if (typeof opts.onResult === "function") {
         opts.onResult(result);
       }
@@ -17440,7 +17467,7 @@ var require_picomatch = __commonJS((exports, module) => {
         result.isMatch = false;
         return returnObject ? result : false;
       }
-      if (isIgnored(input3)) {
+      if (isIgnored(input5)) {
         if (typeof opts.onIgnore === "function") {
           opts.onIgnore(result);
         }
@@ -17457,33 +17484,33 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     return matcher;
   };
-  picomatch.test = (input3, regex, options2, { glob, posix } = {}) => {
-    if (typeof input3 !== "string") {
+  picomatch.test = (input5, regex, options2, { glob, posix } = {}) => {
+    if (typeof input5 !== "string") {
       throw new TypeError("Expected input to be a string");
     }
-    if (input3 === "") {
+    if (input5 === "") {
       return { isMatch: false, output: "" };
     }
     const opts = options2 || {};
     const format = opts.format || (posix ? utils.toPosixSlashes : null);
-    let match = input3 === glob;
-    let output = match && format ? format(input3) : input3;
+    let match = input5 === glob;
+    let output = match && format ? format(input5) : input5;
     if (match === false) {
-      output = format ? format(input3) : input3;
+      output = format ? format(input5) : input5;
       match = output === glob;
     }
     if (match === false || opts.capture === true) {
       if (opts.matchBase === true || opts.basename === true) {
-        match = picomatch.matchBase(input3, regex, options2, posix);
+        match = picomatch.matchBase(input5, regex, options2, posix);
       } else {
         match = regex.exec(output);
       }
     }
     return { isMatch: Boolean(match), match, output };
   };
-  picomatch.matchBase = (input3, glob, options2, posix = utils.isWindows(options2)) => {
+  picomatch.matchBase = (input5, glob, options2, posix = utils.isWindows(options2)) => {
     const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options2);
-    return regex.test(path.basename(input3));
+    return regex.test(path.basename(input5));
   };
   picomatch.isMatch = (str, patterns, options2) => picomatch(patterns, options2)(str);
   picomatch.parse = (pattern, options2) => {
@@ -17491,7 +17518,7 @@ var require_picomatch = __commonJS((exports, module) => {
       return pattern.map((p) => picomatch.parse(p, options2));
     return parse2(pattern, { ...options2, fastpaths: false });
   };
-  picomatch.scan = (input3, options2) => scan(input3, options2);
+  picomatch.scan = (input5, options2) => scan(input5, options2);
   picomatch.compileRe = (state, options2, returnOutput = false, returnState = false) => {
     if (returnOutput === true) {
       return state.output;
@@ -17509,16 +17536,16 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     return regex;
   };
-  picomatch.makeRe = (input3, options2 = {}, returnOutput = false, returnState = false) => {
-    if (!input3 || typeof input3 !== "string") {
+  picomatch.makeRe = (input5, options2 = {}, returnOutput = false, returnState = false) => {
+    if (!input5 || typeof input5 !== "string") {
       throw new TypeError("Expected a non-empty string");
     }
     let parsed = { negated: false, fastpaths: true };
-    if (options2.fastpaths !== false && (input3[0] === "." || input3[0] === "*")) {
-      parsed.output = parse2.fastpaths(input3, options2);
+    if (options2.fastpaths !== false && (input5[0] === "." || input5[0] === "*")) {
+      parsed.output = parse2.fastpaths(input5, options2);
     }
     if (!parsed.output) {
-      parsed = parse2(input3, options2);
+      parsed = parse2(input5, options2);
     }
     return picomatch.compileRe(parsed, options2, returnOutput, returnState);
   };
@@ -17664,10 +17691,10 @@ var require_micromatch = __commonJS((exports, module) => {
     }
     return [].concat(patterns).every((p) => picomatch(p, options2)(str));
   };
-  micromatch.capture = (glob, input3, options2) => {
+  micromatch.capture = (glob, input5, options2) => {
     let posix = utils.isWindows(options2);
     let regex = picomatch.makeRe(String(glob), { ...options2, capture: true });
-    let match = regex.exec(posix ? utils.toPosixSlashes(input3) : input3);
+    let match = regex.exec(posix ? utils.toPosixSlashes(input5) : input5);
     if (match) {
       return match.slice(1).map((v) => v === undefined ? "" : v);
     }
@@ -18002,12 +18029,12 @@ var require_stream = __commonJS((exports) => {
 var require_string = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isEmpty = exports.isString = undefined;
-  function isString(input3) {
-    return typeof input3 === "string";
+  function isString(input5) {
+    return typeof input5 === "string";
   }
   exports.isString = isString;
-  function isEmpty(input3) {
-    return input3 === "";
+  function isEmpty(input5) {
+    return input5 === "";
   }
   exports.isEmpty = isEmpty;
 });
@@ -18037,8 +18064,8 @@ var require_tasks = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = undefined;
   var utils = require_utils3();
-  function generate(input3, settings) {
-    const patterns = processPatterns(input3, settings);
+  function generate(input5, settings) {
+    const patterns = processPatterns(input5, settings);
     const ignore = processPatterns(settings.ignore, settings);
     const positivePatterns = getPositivePatterns(patterns);
     const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
@@ -18049,8 +18076,8 @@ var require_tasks = __commonJS((exports) => {
     return staticTasks.concat(dynamicTasks);
   }
   exports.generate = generate;
-  function processPatterns(input3, settings) {
-    let patterns = input3;
+  function processPatterns(input5, settings) {
+    let patterns = input5;
     if (settings.braceExpansion) {
       patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
     }
@@ -20006,8 +20033,8 @@ var require_out4 = __commonJS((exports, module) => {
     const provider = new _Provider(settings);
     return tasks.map(provider.read, provider);
   }
-  function assertPatternsInput(input3) {
-    const source = [].concat(input3);
+  function assertPatternsInput(input5) {
+    const source = [].concat(input5);
     const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
     if (!isValidSource) {
       throw new TypeError("Patterns must be a string (non empty) or an array of strings");
@@ -21126,7 +21153,7 @@ var l, u, d, f, p, m, h = (e2, t2) => () => (t2 || e2((t2 = { exports: {} }).exp
     t3.on("end", r2);
   }
   return n2;
-}, T, E, D, O, k, A, j, M, N, P, F, I, L, R, z2, B, V, G, K = (e2, t2, n2) => {
+}, T, E, D, O, k, A, j, M, N, P, F, I, L, R, z4, B, V, G, K = (e2, t2, n2) => {
   const r2 = new G(e2, t2, n2);
   r2.spawn();
   return r2;
@@ -21555,7 +21582,7 @@ var init_main = __esm(() => {
     t2.exports._enoent = i2;
   });
   R = _(L(), 1);
-  z2 = class extends Error {
+  z4 = class extends Error {
     result;
     output;
     get exitCode() {
@@ -21638,7 +21665,7 @@ var init_main = __esm(() => {
       if (this._thrownError)
         throw this._thrownError;
       if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== undefined)
-        throw new z2(this);
+        throw new z4(this);
     }
     async _waitForOutput() {
       const e2 = this._process;
@@ -21657,7 +21684,7 @@ var init_main = __esm(() => {
         exitCode: this.exitCode
       };
       if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== undefined)
-        throw new z2(this, r2);
+        throw new z4(this, r2);
       return r2;
     }
     then(e2, t2) {
@@ -21853,7 +21880,7 @@ var init_commands = __esm(() => {
 });
 
 // ../../node_modules/@antfu/ni/dist/shared/ni.B5qNAuoI.mjs
-import path3, { join as join5, dirname as dirname6, resolve as resolve8 } from "node:path";
+import path3, { join as join7, dirname as dirname8, resolve as resolve8 } from "node:path";
 import process$1 from "node:process";
 import require$$0 from "readline";
 import require$$2 from "events";
@@ -22375,10 +22402,10 @@ function requireStyle() {
   const c2 = requireKleur();
   const figures = requireFigures();
   const styles3 = Object.freeze({
-    password: { scale: 1, render: (input3) => "*".repeat(input3.length) },
-    emoji: { scale: 2, render: (input3) => "\uD83D\uDE03".repeat(input3.length) },
-    invisible: { scale: 0, render: (input3) => "" },
-    default: { scale: 1, render: (input3) => `${input3}` }
+    password: { scale: 1, render: (input5) => "*".repeat(input5.length) },
+    emoji: { scale: 2, render: (input5) => "\uD83D\uDE03".repeat(input5.length) },
+    invisible: { scale: 0, render: (input5) => "" },
+    default: { scale: 1, render: (input5) => `${input5}` }
   });
   const render = (type) => styles3[type] || styles3.default;
   const symbols = Object.freeze({
@@ -22718,7 +22745,7 @@ ${i2 ? " " : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
 }
 function requireSelect() {
   if (hasRequiredSelect)
-    return select3;
+    return select4;
   hasRequiredSelect = 1;
   const color = requireKleur();
   const Prompt = requirePrompt();
@@ -22864,8 +22891,8 @@ function requireSelect() {
       this.out.write(this.outputText);
     }
   }
-  select3 = SelectPrompt;
-  return select3;
+  select4 = SelectPrompt;
+  return select4;
 }
 function requireToggle() {
   if (hasRequiredToggle)
@@ -24386,7 +24413,7 @@ function requirePrompts$1() {
         onSubmit: toSelected
       });
     };
-    const byTitle = (input3, choices) => Promise.resolve(choices.filter((item) => item.title.slice(0, input3.length).toLowerCase() === input3.toLowerCase()));
+    const byTitle = (input5, choices) => Promise.resolve(choices.filter((item) => item.title.slice(0, input5.length).toLowerCase() === input5.toLowerCase()));
     $.autocomplete = (args) => {
       args.suggest = args.suggest || byTitle;
       args.choices = [].concat(args.choices || []);
@@ -24868,7 +24895,7 @@ function requireLib() {
     return lib;
   hasRequiredLib = 1;
   const { isexe, sync: isexeSync } = requireCjs();
-  const { join: join6, delimiter, sep, posix: posix2 } = require$$1$2;
+  const { join: join8, delimiter, sep, posix: posix2 } = require$$1$2;
   const isWindows = process.platform === "win32";
   const rSlash = new RegExp(`[${posix2.sep}${sep === posix2.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
   const rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -24895,7 +24922,7 @@ function requireLib() {
   const getPathPart = (raw, cmd) => {
     const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
     const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-    return prefix + join6(pathPart, cmd);
+    return prefix + join8(pathPart, cmd);
   };
   const which = async (cmd, opt = {}) => {
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -24991,7 +25018,7 @@ async function detect2({ autoInstall, programmatic, cwd } = {}) {
   }
   return agent;
 }
-var ini$1, hasRequiredIni, iniExports, prompts$2, kleur, hasRequiredKleur, action, hasRequiredAction, strip, hasRequiredStrip, src, hasRequiredSrc, clear, hasRequiredClear, figures_1, hasRequiredFigures, style, hasRequiredStyle, lines, hasRequiredLines, wrap, hasRequiredWrap, entriesToDisplay, hasRequiredEntriesToDisplay, util, hasRequiredUtil, prompt, hasRequiredPrompt, text, hasRequiredText, select3, hasRequiredSelect, toggle, hasRequiredToggle, datepart, hasRequiredDatepart, meridiem, hasRequiredMeridiem, day, hasRequiredDay, hours, hasRequiredHours, milliseconds, hasRequiredMilliseconds, minutes, hasRequiredMinutes, month, hasRequiredMonth, seconds, hasRequiredSeconds, year, hasRequiredYear, dateparts, hasRequiredDateparts, date, hasRequiredDate, number, hasRequiredNumber, multiselect, hasRequiredMultiselect, autocomplete, hasRequiredAutocomplete, autocompleteMultiselect, hasRequiredAutocompleteMultiselect, confirm5, hasRequiredConfirm, elements, hasRequiredElements, hasRequiredPrompts$1, lib$1, hasRequiredLib$1, prompts$1, hasRequiredPrompts, promptsExports, prompts, isBrowser, platform, OSC = "\x1B]", BEL = "\x07", SEP = ";", link = (text2, url) => [
+var ini$1, hasRequiredIni, iniExports, prompts$2, kleur, hasRequiredKleur, action, hasRequiredAction, strip, hasRequiredStrip, src, hasRequiredSrc, clear, hasRequiredClear, figures_1, hasRequiredFigures, style, hasRequiredStyle, lines, hasRequiredLines, wrap, hasRequiredWrap, entriesToDisplay, hasRequiredEntriesToDisplay, util, hasRequiredUtil, prompt, hasRequiredPrompt, text, hasRequiredText, select4, hasRequiredSelect, toggle, hasRequiredToggle, datepart, hasRequiredDatepart, meridiem, hasRequiredMeridiem, day, hasRequiredDay, hours, hasRequiredHours, milliseconds, hasRequiredMilliseconds, minutes, hasRequiredMinutes, month, hasRequiredMonth, seconds, hasRequiredSeconds, year, hasRequiredYear, dateparts, hasRequiredDateparts, date, hasRequiredDate, number, hasRequiredNumber, multiselect, hasRequiredMultiselect, autocomplete, hasRequiredAutocomplete, autocompleteMultiselect, hasRequiredAutocompleteMultiselect, confirm5, hasRequiredConfirm, elements, hasRequiredElements, hasRequiredPrompts$1, lib$1, hasRequiredLib$1, prompts$1, hasRequiredPrompts, promptsExports, prompts, isBrowser, platform, OSC = "\x1B]", BEL = "\x07", SEP = ";", link = (text2, url) => [
   OSC,
   "8",
   SEP,
@@ -25044,7 +25071,7 @@ var init_ni_B5qNAuoI = __esm(() => {
   options2 = {};
   libExports = requireLib();
   which = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-  CLI_TEMP_DIR = join5(os4.tmpdir(), "antfu-ni");
+  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 = path3.join(home || "~/", ".nirc");
@@ -25675,12 +25702,12 @@ var init_figures = __esm(() => {
 import tty2 from "node:tty";
 var hasColors, format = (open, close) => {
   if (!hasColors) {
-    return (input3) => input3;
+    return (input5) => input5;
   }
   const openCode = `\x1B[${open}m`;
   const closeCode = `\x1B[${close}m`;
-  return (input3) => {
-    const string = input3 + "";
+  return (input5) => {
+    const string = input5 + "";
     let index = string.indexOf(closeCode);
     if (index === -1) {
       return openCode + string + closeCode;
@@ -27789,16 +27816,16 @@ var init_options2 = __esm(() => {
 var concatenateShell = (file, commandArguments, options3) => options3.shell && commandArguments.length > 0 ? [[file, ...commandArguments].join(" "), [], options3] : [file, commandArguments, options3];
 
 // ../../node_modules/strip-final-newline/index.js
-function stripFinalNewline(input3) {
-  if (typeof input3 === "string") {
-    return stripFinalNewlineString(input3);
+function stripFinalNewline(input5) {
+  if (typeof input5 === "string") {
+    return stripFinalNewlineString(input5);
   }
-  if (!(ArrayBuffer.isView(input3) && input3.BYTES_PER_ELEMENT === 1)) {
+  if (!(ArrayBuffer.isView(input5) && input5.BYTES_PER_ELEMENT === 1)) {
     throw new Error("Input must be a string or a Uint8Array");
   }
-  return stripFinalNewlineBinary(input3);
+  return stripFinalNewlineBinary(input5);
 }
-var stripFinalNewlineString = (input3) => input3.at(-1) === LF ? input3.slice(0, input3.at(-2) === CR ? -2 : -1) : input3, stripFinalNewlineBinary = (input3) => input3.at(-1) === LF_BINARY ? input3.subarray(0, input3.at(-2) === CR_BINARY ? -2 : -1) : input3, LF = `
+var stripFinalNewlineString = (input5) => input5.at(-1) === LF ? input5.slice(0, input5.at(-2) === CR ? -2 : -1) : input5, stripFinalNewlineBinary = (input5) => input5.at(-1) === LF_BINARY ? input5.subarray(0, input5.at(-2) === CR_BINARY ? -2 : -1) : input5, LF = `
 `, LF_BINARY, CR = "\r", CR_BINARY;
 var init_strip_final_newline = __esm(() => {
   LF_BINARY = LF.codePointAt(0);
@@ -28837,21 +28864,21 @@ var init_native = __esm(() => {
 });
 
 // ../../node_modules/execa/lib/stdio/input-option.js
-var handleInputOptions = ({ input: input3, inputFile }, fdNumber) => fdNumber === 0 ? [
-  ...handleInputOption(input3),
+var handleInputOptions = ({ input: input5, inputFile }, fdNumber) => fdNumber === 0 ? [
+  ...handleInputOption(input5),
   ...handleInputFileOption(inputFile)
-] : [], handleInputOption = (input3) => input3 === undefined ? [] : [{
-  type: getInputType(input3),
-  value: input3,
+] : [], handleInputOption = (input5) => input5 === undefined ? [] : [{
+  type: getInputType(input5),
+  value: input5,
   optionName: "input"
-}], getInputType = (input3) => {
-  if (isReadableStream(input3, { checkOpen: false })) {
+}], getInputType = (input5) => {
+  if (isReadableStream(input5, { checkOpen: false })) {
     return "nodeStream";
   }
-  if (typeof input3 === "string") {
+  if (typeof input5 === "string") {
     return "string";
   }
-  if (isUint8Array(input3)) {
+  if (isUint8Array(input5)) {
     return "uint8Array";
   }
   throw new Error("The `input` option must be a string, a Uint8Array or a Node.js Readable stream.");
@@ -31967,7 +31994,7 @@ var init_command2 = __esm(() => {
 var setScriptSync = (boundExeca, createNested, boundOptions) => {
   boundExeca.sync = createNested(mapScriptSync, boundOptions);
   boundExeca.s = boundExeca.sync;
-}, mapScriptAsync = ({ options: options3 }) => getScriptOptions(options3), mapScriptSync = ({ options: options3 }) => ({ ...getScriptOptions(options3), isSync: true }), getScriptOptions = (options3) => ({ options: { ...getScriptStdinOption(options3), ...options3 } }), getScriptStdinOption = ({ input: input3, inputFile, stdio }) => input3 === undefined && inputFile === undefined && stdio === undefined ? { stdin: "inherit" } : {}, deepScriptOptions;
+}, mapScriptAsync = ({ options: options3 }) => getScriptOptions(options3), mapScriptSync = ({ options: options3 }) => ({ ...getScriptOptions(options3), isSync: true }), getScriptOptions = (options3) => ({ options: { ...getScriptStdinOption(options3), ...options3 } }), getScriptStdinOption = ({ input: input5, inputFile, stdio }) => input5 === undefined && inputFile === undefined && stdio === undefined ? { stdin: "inherit" } : {}, deepScriptOptions;
 var init_script = __esm(() => {
   deepScriptOptions = { preferLocal: true };
 });
@@ -32078,20 +32105,20 @@ __export(exports_generate, {
 import path10 from "path";
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
 import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
-function isContractAddress(input3) {
+function isContractAddress(input5) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
-  return contractIdPattern.test(input3);
+  return contractIdPattern.test(input5);
 }
 async function parseInputs(inputs) {
   const files = [];
   const contractIds = [];
-  for (const input3 of inputs) {
-    if (isContractAddress(input3)) {
-      contractIds.push(input3);
+  for (const input5 of inputs) {
+    if (isContractAddress(input5)) {
+      contractIds.push(input5);
       continue;
     }
-    if (input3.includes("*") || input3.includes("?")) {
-      const matches = await import_fast_glob.default(input3, { cwd: process.cwd(), absolute: true });
+    if (input5.includes("*") || input5.includes("?")) {
+      const matches = await import_fast_glob.default(input5, { cwd: process.cwd(), absolute: true });
       for (const file of matches) {
         if (file.endsWith(".clar")) {
           files.push(file);
@@ -32099,8 +32126,8 @@ async function parseInputs(inputs) {
       }
       continue;
     }
-    if (input3.endsWith(".clar")) {
-      const absolutePath = path10.resolve(process.cwd(), input3);
+    if (input5.endsWith(".clar")) {
+      const absolutePath = path10.resolve(process.cwd(), input5);
       files.push(absolutePath);
     }
   }
@@ -32383,7 +32410,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "2.1.0",
+  version: "3.0.0",
   description: "CLI for subgraphs and blockchain indexing on Stacks",
   type: "module",
   bin: {
@@ -32424,12 +32451,12 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
-    "@secondlayer/bundler": "^0.2.0",
-    "@secondlayer/sdk": "^1.0.0",
-    "@secondlayer/shared": "^1.0.0",
-    "@secondlayer/stacks": "^0.2.2",
-    "@secondlayer/subgraphs": "^0.11.6",
-    "@secondlayer/workflows": "^1.0.1",
+    "@secondlayer/bundler": "^0.3.0",
+    "@secondlayer/sdk": "^1.0.1",
+    "@secondlayer/shared": "^2.0.0",
+    "@secondlayer/stacks": "^0.3.0",
+    "@secondlayer/subgraphs": "^0.11.8",
+    "@secondlayer/workflows": "^1.1.0",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
     esbuild: "^0.19.0",
@@ -32450,8 +32477,145 @@ var package_default = {
   }
 };
 
+// src/lib/api-client.ts
+init_http();
+init_resolve_tenant();
+import { ApiError, SecondLayer } from "@secondlayer/sdk";
+function handleApiError(err, action) {
+  if (err instanceof CliHttpError) {
+    if (err.code === "SESSION_EXPIRED") {
+      console.error("Session expired. Run: sl login");
+      process.exit(1);
+    }
+    if (err.code === "TRIAL_EXPIRED") {
+      console.error(err.message);
+      console.error("Run: sl instance resize --plan <...> and add payment");
+      process.exit(1);
+    }
+    if (err.code === "TENANT_SUSPENDED") {
+      console.error("Tenant is suspended. Run: sl instance resume");
+      process.exit(1);
+    }
+    if (err.code === "NO_TENANT_FOR_PROJECT") {
+      console.error(err.message);
+      process.exit(1);
+    }
+  }
+  if (err instanceof ApiError && err.status === 401) {
+    console.error("Authentication required. Run: sl login");
+    process.exit(1);
+  }
+  console.error(`Error: Failed to ${action}: ${err}`);
+  process.exit(1);
+}
+function withErrorHandling(fn, options) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      if (options?.onError) {
+        options.onError(err);
+      } else {
+        handleApiError(err, options?.action ?? "execute command");
+      }
+    }
+  };
+}
+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}`);
+}
+async function getTenantClient() {
+  const { apiUrl, ephemeralKey } = await resolveActiveTenant();
+  return new SecondLayer({ baseUrl: apiUrl, apiKey: ephemeralKey });
+}
+async function listSubgraphsApi() {
+  return (await getTenantClient()).subgraphs.list();
+}
+async function getSubgraphApi(name) {
+  return (await getTenantClient()).subgraphs.get(name);
+}
+async function reindexSubgraphApi(name, options) {
+  return (await getTenantClient()).subgraphs.reindex(name, options);
+}
+async function backfillSubgraphApi(name, options) {
+  return (await getTenantClient()).subgraphs.backfill(name, options);
+}
+async function stopSubgraphApi(name) {
+  return (await getTenantClient()).subgraphs.stop(name);
+}
+async function deleteSubgraphApi(name) {
+  return (await getTenantClient()).subgraphs.delete(name);
+}
+async function deploySubgraphApi(data) {
+  return (await getTenantClient()).subgraphs.deploy(data);
+}
+async function querySubgraphTable(name, table, params = {}) {
+  return (await getTenantClient()).subgraphs.queryTable(name, table, params);
+}
+async function querySubgraphTableCount(name, table, params = {}) {
+  return (await getTenantClient()).subgraphs.queryTableCount(name, table, params);
+}
+async function getSubgraphGaps(name, opts) {
+  return (await getTenantClient()).subgraphs.gaps(name, opts);
+}
+async function publishSubgraphApi(name, opts) {
+  const { apiUrl, ephemeralKey } = await resolveActiveTenant();
+  const res = await fetch(`${apiUrl}/api/subgraphs/${name}/publish`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${ephemeralKey}`
+    },
+    body: JSON.stringify(opts ?? {})
+  });
+  await assertOk(res);
+  return res.json();
+}
+async function unpublishSubgraphApi(name) {
+  const { apiUrl, ephemeralKey } = await resolveActiveTenant();
+  const res = await fetch(`${apiUrl}/api/subgraphs/${name}/unpublish`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${ephemeralKey}`
+    },
+    body: JSON.stringify({})
+  });
+  await assertOk(res);
+  return res.json();
+}
+async function getAccountProfile() {
+  return httpPlatform("/api/accounts/me");
+}
+async function updateAccountProfile(data) {
+  return httpPlatform("/api/accounts/me", { method: "PATCH", body: data });
+}
+async function getPlatformClient() {
+  const base = process.env.SL_PLATFORM_API_URL ?? "https://api.secondlayer.tools";
+  return new SecondLayer({ baseUrl: base });
+}
+async function browseMarketplace(opts = {}) {
+  return (await getPlatformClient()).marketplace.browse(opts);
+}
+async function getMarketplaceSubgraph(name) {
+  return (await getPlatformClient()).marketplace.get(name);
+}
+async function forkMarketplaceSubgraph(name, newName) {
+  return (await getPlatformClient()).marketplace.fork(name, newName);
+}
+
 // src/commands/account.ts
-init_api_client();
 init_output();
 function registerAccountCommand(program2) {
   const account = program2.command("account").description("Manage your account profile");
@@ -32497,8 +32661,8 @@ init_config();
 
 // src/lib/detect.ts
 init_docker();
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 var STACKS_CONTAINER_PATTERNS = [
   "stacks-blockchain",
   "stacks-node",
@@ -32566,8 +32730,8 @@ async function findDockerComposeRoot(startPath) {
   let current = startPath;
   while (current && current !== "/") {
     try {
-      const composeYml = Bun.file(join2(current, "docker-compose.yml"));
-      const composeYaml = Bun.file(join2(current, "docker-compose.yaml"));
+      const composeYml = Bun.file(join4(current, "docker-compose.yml"));
+      const composeYaml = Bun.file(join4(current, "docker-compose.yaml"));
       if (await composeYml.exists() || await composeYaml.exists()) {
         return current;
       }
@@ -32614,9 +32778,9 @@ var SEARCH_PATTERNS = [
   "/Volumes/stacks-node",
   "/Volumes/*/stacks-blockchain-docker",
   "/Volumes/*/stacks-node",
-  `${homedir2()}/stacks-blockchain-docker`,
-  `${homedir2()}/stacks-node`,
-  `${homedir2()}/stacks-*`,
+  `${homedir4()}/stacks-blockchain-docker`,
+  `${homedir4()}/stacks-node`,
+  `${homedir4()}/stacks-*`,
   "/opt/stacks-blockchain-docker",
   "/opt/stacks-node",
   "/opt/stacks-*"
@@ -32663,8 +32827,8 @@ async function isValidStacksNodeDir(path) {
     return true;
   }
   try {
-    const composeYml = Bun.file(join2(path, "docker-compose.yml"));
-    const composeYaml = Bun.file(join2(path, "docker-compose.yaml"));
+    const composeYml = Bun.file(join4(path, "docker-compose.yml"));
+    const composeYaml = Bun.file(join4(path, "docker-compose.yaml"));
     const hasCompose = await composeYml.exists() || await composeYaml.exists();
     if (!hasCompose) {
       return false;
@@ -32677,7 +32841,7 @@ async function isValidStacksNodeDir(path) {
   }
 }
 async function detectNetworkFromFilesystem(path) {
-  const envFile = Bun.file(join2(path, ".env"));
+  const envFile = Bun.file(join4(path, ".env"));
   if (await envFile.exists()) {
     try {
       const content = await envFile.text();
@@ -32689,12 +32853,12 @@ async function detectNetworkFromFilesystem(path) {
       }
     } catch {}
   }
-  const testnetConfig = Bun.file(join2(path, "configurations/testnet"));
-  const mainnetConfig = Bun.file(join2(path, "configurations/mainnet"));
-  const activeConfig = Bun.file(join2(path, "configurations/active"));
+  const testnetConfig = Bun.file(join4(path, "configurations/testnet"));
+  const mainnetConfig = Bun.file(join4(path, "configurations/mainnet"));
+  const activeConfig = Bun.file(join4(path, "configurations/active"));
   if (await activeConfig.exists()) {
     try {
-      const result = await Bun.$`readlink ${join2(path, "configurations/active")}`.quiet().nothrow();
+      const result = await Bun.$`readlink ${join4(path, "configurations/active")}`.quiet().nothrow();
       const link = result.stdout.toString().trim();
       if (link.includes("testnet"))
         return "testnet";
@@ -32707,7 +32871,7 @@ async function detectNetworkFromFilesystem(path) {
 }
 async function isComposeProjectRunning(path) {
   try {
-    const result = await Bun.$`docker compose -f ${join2(path, "docker-compose.yml")} ps -q`.quiet().nothrow();
+    const result = await Bun.$`docker compose -f ${join4(path, "docker-compose.yml")} ps -q`.quiet().nothrow();
     return result.exitCode === 0 && result.stdout.toString().trim().length > 0;
   } catch {
     return false;
@@ -32787,9 +32951,8 @@ function registerConfigCommand(program2) {
 async function printConfigTree(cfg) {
   const defaults = getDefaultConfig();
   printValue("network", cfg.network, isDefaultValue(cfg, "network"));
-  printValue("apiUrl", resolveApiUrl(cfg), cfg.apiUrl === undefined);
-  if (cfg.apiKey) {
-    printValue("apiKey", cfg.apiKey.slice(0, 14) + "...", false);
+  if (cfg.defaultProject) {
+    printValue("defaultProject", cfg.defaultProject, false);
   }
   const resolvedDataDir = getDataDir(cfg);
   const dataDirDisplay = cfg.dataDir === resolvedDataDir ? cfg.dataDir : `${cfg.dataDir} ${dim(`→ ${resolvedDataDir}`)}`;
@@ -32858,31 +33021,25 @@ async function validateDatabaseConnection(url) {
   }
 }
 // src/commands/status.ts
-init_api_client();
 init_config();
+init_http();
 init_output();
 function registerStatusCommand(program2) {
   program2.command("status").description("Show system status").option("--json", "Output as JSON").action(async (options) => {
     const config = await loadConfig();
     try {
-      const response = await fetch(`${resolveApiUrl(config)}/status`, {
-        headers: authHeaders(config)
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          console.error("Error: Authentication required. Run: sl auth login");
-          process.exit(1);
-        }
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const status = await response.json();
+      const status = await httpPlatform("/status");
       if (options.json) {
         console.log(JSON.stringify(status, null, 2));
         return;
       }
       printStatus(status);
-    } catch {
-      console.log("");
+    } catch (err) {
+      if (err instanceof CliHttpError && err.code === "SESSION_EXPIRED") {
+        console.error("Not logged in. Run: sl login");
+        process.exit(1);
+      }
+      console.log("");
       console.log(blue("System Status"));
       console.log(`  ${red("NOT RUNNING")}`);
       console.log("");
@@ -32890,7 +33047,7 @@ function registerStatusCommand(program2) {
         console.log(dim("  API service is not running."));
         console.log(dim("  Start with: sl local start"));
       } else {
-        console.log(dim(`  Can't reach ${config.network} API at ${resolveApiUrl(config)}`));
+        console.log(dim("  Can't reach the platform API."));
         console.log(dim("  Check your connection or try again."));
       }
       console.log("");
@@ -32952,234 +33109,18 @@ function printStatus(status) {
   }
   console.log(dim(`Last updated: ${status.timestamp}`));
 }
-// src/commands/sync.ts
+// src/commands/db.ts
 init_config();
+init_dev_state();
 init_output();
 import { confirm } from "@inquirer/prompts";
-import { getDb } from "@secondlayer/shared/db";
+import { getDb, sql } from "@secondlayer/shared/db";
 import {
   countMissingBlocks,
   findGaps
 } from "@secondlayer/shared/db/queries/integrity";
 import { StacksNodeClient } from "@secondlayer/shared/node";
-import { HiroClient } from "@secondlayer/shared/node/hiro-client";
-import { LocalClient } from "@secondlayer/shared/node/local-client";
 var DEV_DATABASE_URL = "postgres://postgres:postgres@localhost:5432/secondlayer_dev";
-function registerSyncCommand(program2) {
-  program2.command("sync").description("Fetch missing blocks and index them").option("--from <block>", "Start block height").option("--to <block>", "End block height").option("--gaps", "Auto-detect and fill all gaps").option("--concurrency <n>", "Parallel fetch limit (default: 1 for hiro, 5 for node)").option("--delay <ms>", "Delay between batches in ms (default: 500 for hiro, 0 for node)").option("--source <source>", "Data source: auto, local, hiro, node", "auto").option("-y, --yes", "Skip confirmation prompt").action(async function() {
-    const opts = this.opts();
-    const config = await loadConfig();
-    const indexerUrl = process.env.INDEXER_URL || `http://localhost:${config.ports.indexer}`;
-    let concurrency = opts.concurrency ? Number.parseInt(opts.concurrency) : 0;
-    try {
-      const nodeClient = new StacksNodeClient;
-      const hiroClient = new HiroClient;
-      const localClient = new LocalClient;
-      let useHiro = opts.source === "hiro";
-      let useNode = opts.source === "node";
-      let useLocal = opts.source === "local";
-      if (opts.source === "auto" || !opts.source) {
-        if (!process.env.DATABASE_URL) {
-          process.env.DATABASE_URL = DEV_DATABASE_URL;
-        }
-        const db = getDb();
-        const localTip = await localClient.getChainTip(db);
-        if (localTip > 0) {
-          useLocal = true;
-          info(`Using local DB for backfill (tip: block ${localTip})`);
-        } else {
-          const nodeHealthy = await nodeClient.isHealthy();
-          if (nodeHealthy) {
-            const testBlock = await nodeClient.getBlock(1).catch(() => null);
-            if (testBlock) {
-              useNode = true;
-              info("Using local Stacks node for backfill");
-            } else {
-              useHiro = true;
-              info("Node can't serve block data, using Hiro public API");
-            }
-          } else {
-            useHiro = true;
-            info("Node not reachable, using Hiro public API");
-          }
-        }
-      }
-      if (concurrency === 0) {
-        concurrency = useLocal ? 10 : useHiro ? 1 : 5;
-      }
-      if (useLocal) {
-        if (!process.env.DATABASE_URL) {
-          process.env.DATABASE_URL = DEV_DATABASE_URL;
-        }
-        info("Source: local DB");
-      } else if (useHiro) {
-        const hiroHealthy = await hiroClient.isHealthy();
-        if (!hiroHealthy) {
-          error(`Cannot reach Hiro API at ${hiroClient.getApiUrl()}`);
-          console.log(dim(`
-Set HIRO_API_URL or check your internet connection.`));
-          process.exit(1);
-        }
-        info(`Source: Hiro API (${hiroClient.getApiUrl()})`);
-      } else if (useNode) {
-        const nodeInfo = await nodeClient.getInfo();
-        info(`Source: local node (tip: block ${nodeInfo.stacks_tip_height})`);
-      }
-      let ranges = [];
-      if (opts.gaps) {
-        if (!process.env.DATABASE_URL) {
-          process.env.DATABASE_URL = DEV_DATABASE_URL;
-        }
-        const db = getDb();
-        const gaps = await findGaps(db);
-        const missing = await countMissingBlocks(db);
-        if (gaps.length === 0) {
-          success("No gaps detected — block data is contiguous");
-          process.exit(0);
-        }
-        info(`Found ${gaps.length} gaps, ${missing} missing blocks`);
-        ranges = gaps.map((g) => ({
-          start: g.gapStart,
-          end: g.gapEnd
-        }));
-      } else if (opts.from && opts.to) {
-        const from = Number.parseInt(opts.from);
-        const to = Number.parseInt(opts.to);
-        if (isNaN(from) || from < 0) {
-          error("--from must be a non-negative number");
-          process.exit(1);
-        }
-        if (isNaN(to) || to < 0) {
-          error("--to must be a non-negative number");
-          process.exit(1);
-        }
-        if (from > to) {
-          error("--from must be <= --to");
-          process.exit(1);
-        }
-        ranges = [{ start: from, end: to }];
-      } else {
-        error("Must specify --from and --to, or --gaps");
-        console.log(dim(`
-Examples:`));
-        console.log(dim("  sl sync --from 1000 --to 2000"));
-        console.log(dim("  sl sync --gaps"));
-        console.log(dim("  sl sync --gaps --source hiro"));
-        process.exit(1);
-      }
-      const totalBlocks = ranges.reduce((sum, r) => sum + (r.end - r.start + 1), 0);
-      if (!opts.yes) {
-        console.log("");
-        const sourceLabel = useLocal ? "local DB" : useHiro ? "Hiro API" : "local node";
-        console.log(`This will fetch ${yellow(totalBlocks.toString())} blocks from ${sourceLabel}.`);
-        if (useHiro) {
-          console.log(dim("Note: Hiro API fetches are slower due to per-tx event lookups."));
-        }
-        const confirmed = await confirm({
-          message: "Continue?",
-          default: true
-        });
-        if (!confirmed) {
-          info("Cancelled");
-          process.exit(0);
-        }
-      }
-      const batchDelay = opts.delay ? Number.parseInt(opts.delay) : useHiro ? 500 : 0;
-      if (useHiro && batchDelay > 0) {
-        info(`Pacing: ${batchDelay}ms delay between batches (concurrency: ${concurrency})`);
-      }
-      let fetched = 0;
-      let errors = 0;
-      let consecutiveErrors = 0;
-      const startTime = Date.now();
-      for (const range of ranges) {
-        const heights = [];
-        for (let h = range.start;h <= range.end; h++) {
-          heights.push(h);
-        }
-        for (let i = 0;i < heights.length; i += concurrency) {
-          const batch = heights.slice(i, i + concurrency);
-          const results = await Promise.allSettled(batch.map(async (height) => {
-            let block;
-            if (useLocal) {
-              const db = getDb();
-              block = await localClient.getBlockForReplay(db, height);
-            } else if (useHiro) {
-              block = await hiroClient.getBlockForIndexer(height);
-            } else {
-              block = await nodeClient.getBlock(height);
-            }
-            if (!block) {
-              throw new Error(`Block ${height} not found`);
-            }
-            const res = await fetch(`${indexerUrl}/new_block`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                "X-Source": "backfill"
-              },
-              body: JSON.stringify(block)
-            });
-            if (!res.ok) {
-              throw new Error(`Indexer rejected block ${height}: ${res.status}`);
-            }
-            return height;
-          }));
-          for (const result of results) {
-            if (result.status === "fulfilled") {
-              fetched++;
-              consecutiveErrors = 0;
-            } else {
-              errors++;
-              consecutiveErrors++;
-              console.log(red(`
-  ✗ ${result.reason}`));
-            }
-          }
-          if (consecutiveErrors >= 5) {
-            const cooldown = Math.min(consecutiveErrors * 2000, 30000);
-            process.stdout.write(`
-  ${yellow(`Backing off ${cooldown / 1000}s after ${consecutiveErrors} consecutive errors...`)}`);
-            await new Promise((r) => setTimeout(r, cooldown));
-          }
-          const elapsed = (Date.now() - startTime) / 1000;
-          const rate = fetched / elapsed;
-          const remaining = totalBlocks - fetched - errors;
-          const eta = rate > 0 ? Math.round(remaining / rate) : 0;
-          const etaStr = eta > 3600 ? `${Math.floor(eta / 3600)}h ${Math.floor(eta % 3600 / 60)}m` : eta > 60 ? `${Math.floor(eta / 60)}m ${eta % 60}s` : `${eta}s`;
-          const pct = Math.round((fetched + errors) / totalBlocks * 100);
-          process.stdout.write(`\r  ${green(`${fetched}`)} fetched, ${errors > 0 ? red(`${errors} errors`) : "0 errors"} (${pct}%) ${dim(`${rate.toFixed(1)} blk/s — ETA ${etaStr}`)}   `);
-          if (batchDelay > 0) {
-            await new Promise((r) => setTimeout(r, batchDelay));
-          }
-        }
-      }
-      console.log("");
-      console.log("");
-      if (errors === 0) {
-        success(`Backfill complete: ${fetched} blocks indexed`);
-      } else {
-        warn(`Backfill complete: ${fetched} indexed, ${errors} errors`);
-      }
-      process.exit(0);
-    } catch (err) {
-      error(`Backfill failed: ${err}`);
-      process.exit(1);
-    }
-  });
-}
-// src/commands/db.ts
-init_config();
-init_dev_state();
-init_output();
-import { confirm as confirm2 } from "@inquirer/prompts";
-import { getDb as getDb2, sql } from "@secondlayer/shared/db";
-import {
-  countMissingBlocks as countMissingBlocks2,
-  findGaps as findGaps2
-} from "@secondlayer/shared/db/queries/integrity";
-import { StacksNodeClient as StacksNodeClient2 } from "@secondlayer/shared/node";
-var DEV_DATABASE_URL2 = "postgres://postgres:postgres@localhost:5432/secondlayer_dev";
 function registerDbCommand(program2) {
   const dbCmd = program2.command("db").description("Inspect indexer database tables").hook("preAction", async () => {
     await requireLocalNetwork();
@@ -33213,9 +33154,9 @@ function registerDbCommand(program2) {
 }
 function ensureDb() {
   if (!process.env.DATABASE_URL) {
-    process.env.DATABASE_URL = DEV_DATABASE_URL2;
+    process.env.DATABASE_URL = DEV_DATABASE_URL;
   }
-  return getDb2();
+  return getDb();
 }
 async function showOverview(_limit) {
   try {
@@ -33339,8 +33280,8 @@ async function showEvents(limit, json) {
 async function showGaps(limit, json) {
   try {
     const db = ensureDb();
-    const gaps = await findGaps2(db, limit);
-    const missing = await countMissingBlocks2(db);
+    const gaps = await findGaps(db, limit);
+    const missing = await countMissingBlocks(db);
     if (json) {
       console.log(JSON.stringify({ gaps, totalMissingBlocks: missing }, null, 2));
       process.exit(0);
@@ -33383,7 +33324,7 @@ async function resetDatabase(skipConfirm) {
     console.log(dim("Note: Subgraph configurations will be preserved."));
     console.log("");
     if (!skipConfirm) {
-      const confirmed = await confirm2({
+      const confirmed = await confirm({
         message: "Are you sure you want to reset the database?",
         default: false
       });
@@ -33420,7 +33361,7 @@ async function resyncDatabase(skipConfirm, backfill) {
     console.log(dim("Note: Subgraph configurations will be preserved."));
     console.log("");
     if (!skipConfirm) {
-      const confirmed = await confirm2({
+      const confirmed = await confirm({
         message: "Are you sure you want to resync?",
         default: false
       });
@@ -33458,7 +33399,7 @@ async function resyncDatabase(skipConfirm, backfill) {
     if (backfill) {
       console.log("");
       info("Starting backfill from node...");
-      const nodeClient = new StacksNodeClient2;
+      const nodeClient = new StacksNodeClient;
       const healthy = await nodeClient.isHealthy();
       if (!healthy) {
         warn(`Cannot reach Stacks node at ${nodeClient.getRpcUrl()}`);
@@ -33522,9 +33463,9 @@ async function resyncDatabase(skipConfirm, backfill) {
   }
 }
 // src/commands/subgraphs.ts
-import { existsSync, mkdirSync, watch } from "node:fs";
-import { resolve } from "node:path";
-import { confirm as confirm3 } from "@inquirer/prompts";
+import { existsSync as existsSync2, mkdirSync, watch } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/generators/subgraph-scaffold.ts
 init_format();
@@ -33725,7 +33666,6 @@ function subgraphTypeToTS(type) {
 }
 
 // src/commands/subgraphs.ts
-init_api_client();
 init_config();
 init_fs();
 init_output();
@@ -33789,13 +33729,13 @@ init_api();
 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)) {
+    const dir = resolve2("subgraphs");
+    const filePath = resolve2(dir, `${name}.ts`);
+    if (existsSync2(filePath)) {
       error(`File already exists: ${filePath}`);
       process.exit(1);
     }
-    if (!existsSync(dir)) {
+    if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     const content = generateSubgraphTemplate(name);
@@ -33805,8 +33745,8 @@ function registerSubgraphsCommand(program2) {
   });
   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)) {
+    const absPath = resolve2(file);
+    if (!existsSync2(absPath)) {
       error(`File not found: ${absPath}`);
       process.exit(1);
     }
@@ -33820,9 +33760,9 @@ function registerSubgraphsCommand(program2) {
         const def = mod.default ?? mod;
         const { validateSubgraphDefinition } = await import("@secondlayer/subgraphs/validate");
         const { deploySchema } = await import("@secondlayer/subgraphs");
-        const { getDb: getDb3 } = await import("@secondlayer/shared/db");
+        const { getDb: getDb2 } = await import("@secondlayer/shared/db");
         validateSubgraphDefinition(def);
-        const db = getDb3();
+        const db = getDb2();
         const result = await deploySchema(db, def, absPath, {
           forceReindex: false
         });
@@ -33866,7 +33806,7 @@ Stopped watching.`);
   });
   subgraphs.command("deploy <file>").description("Deploy a subgraph definition file").option("--version <semver>", "Explicit version (default: auto-increment patch)").option("--force", "Skip confirmation prompt for reindex operations").action(async (file, options2) => {
     try {
-      const absPath = resolve(file);
+      const absPath = resolve2(file);
       const config = await loadConfig();
       info(`Loading subgraph from ${absPath}`);
       const mod = await import(absPath);
@@ -33875,8 +33815,8 @@ Stopped watching.`);
       validateSubgraphDefinition(def);
       if (config.network !== "local") {
         info(`Bundling for remote deploy (${config.network})...`);
-        const { readFile: readFile2 } = await import("node:fs/promises");
-        const source = await readFile2(absPath, "utf8");
+        const { readFile: readFile4 } = await import("node:fs/promises");
+        const source = await readFile4(absPath, "utf8");
         const { bundleSubgraphCode } = await import("@secondlayer/bundler");
         const bundled = await bundleSubgraphCode(source);
         const handlerCode = bundled.handlerCode;
@@ -33906,7 +33846,7 @@ Stopped watching.`);
               info(`  + columns: ${t}.${cols.join(", ")}`);
             }
           }
-          const confirmed = options2.force || await confirm3({
+          const confirmed = options2.force || await confirm2({
             message: "⚠  This will drop all data and reindex from scratch. Continue?"
           });
           if (!confirmed) {
@@ -33927,8 +33867,8 @@ Stopped watching.`);
         }
       } else {
         const { deploySchema } = await import("@secondlayer/subgraphs");
-        const { getDb: getDb3, closeDb } = await import("@secondlayer/shared/db");
-        const db = getDb3();
+        const { getDb: getDb2, closeDb } = await import("@secondlayer/shared/db");
+        const db = getDb2();
         const result = await deploySchema(db, def, absPath, {
           version: options2.version
         });
@@ -34148,8 +34088,8 @@ ${rows.length} row(s)`));
   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: confirm4 } = await import("@inquirer/prompts");
-        const ok = await confirm4({
+        const { confirm: confirm3 } = await import("@inquirer/prompts");
+        const ok = await confirm3({
           message: `Delete subgraph "${name}" and all its data? This cannot be undone.`
         });
         if (!ok) {
@@ -34200,7 +34140,7 @@ ${rows.length} row(s)`));
         error("--output <path> is required");
         process.exit(1);
       }
-      const outPath = resolve(options2.output);
+      const outPath = resolve2(options2.output);
       const network = inferNetwork(contractAddress) ?? "mainnet";
       const apiKey = options2.apiKey ?? process.env.HIRO_API_KEY;
       info(`Fetching ABI for ${contractAddress}...`);
@@ -34212,8 +34152,8 @@ ${rows.length} row(s)`));
         contractId: contractAddress,
         functions: abi.functions
       });
-      const dir = resolve(outPath, "..");
-      if (!existsSync(dir))
+      const dir = resolve2(outPath, "..");
+      if (!existsSync2(dir))
         mkdirSync(dir, { recursive: true });
       await writeTextFile(outPath, content);
       success(`Created ${outPath}`);
@@ -34229,13 +34169,13 @@ ${rows.length} row(s)`));
         error("--output <path> is required");
         process.exit(1);
       }
-      const outPath = resolve(options2.output);
+      const outPath = resolve2(options2.output);
       info(`Fetching subgraph metadata for "${subgraphName}"...`);
       const subgraphDetail = await getSubgraphApi(subgraphName);
       info("Generating typed client...");
       const content = await generateSubgraphConsumer(subgraphName, subgraphDetail);
-      const dir = resolve(outPath, "..");
-      if (!existsSync(dir))
+      const dir = resolve2(outPath, "..");
+      if (!existsSync2(dir))
         mkdirSync(dir, { recursive: true });
       await writeTextFile(outPath, content);
       success(`Created ${outPath}`);
@@ -34424,7 +34364,6 @@ async function stackStop(options2) {
   console.log("");
 }
 // src/commands/doctor.ts
-init_api_client();
 init_config();
 
 // src/lib/health.ts
@@ -34567,6 +34506,7 @@ async function checkHealth() {
 }
 
 // src/commands/doctor.ts
+init_http();
 init_network();
 init_output();
 function registerDoctorCommand(program2) {
@@ -34581,40 +34521,36 @@ function registerDoctorCommand(program2) {
 }
 async function runHostedDoctor(jsonOutput) {
   const config = await loadConfig();
-  const apiUrl = resolveApiUrl(config);
+  const apiUrl = process.env.SL_PLATFORM_API_URL ?? "https://api.secondlayer.tools";
   const issues = [];
   const results = { network: config.network, apiUrl };
   let apiHealthy = false;
   let statusData = null;
   try {
-    const res = await fetch(`${apiUrl}/status`, {
-      headers: authHeaders(config)
-    });
-    apiHealthy = res.ok;
-    if (res.ok) {
-      statusData = await res.json();
-    } else if (res.status === 401) {
-      issues.push("Authentication failed. Run: sl auth login");
+    statusData = await httpPlatform("/status");
+    apiHealthy = true;
+  } catch (err) {
+    if (err instanceof CliHttpError) {
+      if (err.code === "SESSION_EXPIRED") {
+        issues.push("Not authenticated. Run: sl login");
+      } else {
+        issues.push(`API error: ${err.code}`);
+      }
     } else {
-      issues.push(`API returned HTTP ${res.status}`);
+      issues.push(`Cannot reach API at ${apiUrl}`);
     }
-  } catch {
-    issues.push(`Cannot reach API at ${apiUrl}`);
   }
   results.apiHealthy = apiHealthy;
   let authOk = false;
   let account = null;
   try {
-    const res = await fetch(`${apiUrl}/api/accounts/me`, {
-      headers: authHeaders(config)
-    });
-    if (res.ok) {
-      authOk = true;
-      account = await res.json();
-    } else if (res.status === 401) {
-      issues.push("Not authenticated. Run: sl auth login");
+    account = await getAccountProfile();
+    authOk = true;
+  } catch (err) {
+    if (err instanceof CliHttpError && err.code === "SESSION_EXPIRED") {
+      issues.push("Not authenticated. Run: sl login");
     }
-  } catch {}
+  }
   results.authOk = authOk;
   results.account = account;
   if (jsonOutput) {
@@ -34777,261 +34713,6 @@ async function runLocalDoctor(jsonOutput) {
   }
   console.log("");
 }
-// src/commands/auth.ts
-init_api_client();
-init_config();
-init_output();
-import { hostname } from "node:os";
-import { input } from "@inquirer/prompts";
-function registerAuthCommand(program2) {
-  const auth = program2.command("auth").description("Manage authentication and API keys");
-  auth.command("login").description("Login with email via magic link").action(async () => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    if (!apiUrl) {
-      error("No API URL configured. Set network with: sl config set network testnet");
-      process.exit(1);
-    }
-    const email = await input({
-      message: "Email:",
-      validate: (v) => v.includes("@") || "Enter a valid email"
-    });
-    try {
-      const mlRes = await fetch(`${apiUrl}/api/auth/magic-link`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ email })
-      });
-      await assertOk(mlRes);
-      console.log(dim("Check your email for a 6-digit login code."));
-      const code = await input({
-        message: "Code:",
-        validate: (v) => /^\d{6}$/.test(v.trim()) || "Enter the 6-digit code from your email"
-      });
-      const verifyRes = await fetch(`${apiUrl}/api/auth/verify`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ code: code.trim(), email })
-      });
-      await assertOk(verifyRes);
-      const result = await verifyRes.json();
-      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(`Key: ${prefix}...`));
-      console.log(dim(`Network: ${config.network}`));
-      console.log(dim(`API: ${apiUrl}`));
-    } catch (err) {
-      error(`Login failed: ${err}`);
-      process.exit(1);
-    }
-  });
-  auth.command("logout").description("Revoke API key and remove from config").action(async () => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    if (!config.apiKey) {
-      error("Not logged in.");
-      process.exit(1);
-    }
-    try {
-      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.apiKey;
-    await saveConfig(config);
-    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 pairs = [
-      ["Network", config.network],
-      ["API", apiUrl || "(not configured)"],
-      [
-        "API Key",
-        config.apiKey ? `${config.apiKey.slice(0, 14)}...` : "(none)"
-      ]
-    ];
-    if (config.apiKey && apiUrl) {
-      try {
-        const res = await fetch(`${apiUrl}/api/accounts/me`, {
-          headers: authHeaders(config)
-        });
-        if (res.ok) {
-          const data = await res.json();
-          pairs.push(["Email", data.email]);
-          pairs.push(["Plan", data.plan]);
-        }
-      } catch {}
-    }
-    console.log(formatKeyValue(pairs));
-  });
-  const keys = auth.command("keys").description("Manage API keys");
-  keys.command("list").description("List API keys for this account").action(async () => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    const headers = authHeaders(config);
-    try {
-      const res = await fetch(`${apiUrl}/api/keys`, { headers });
-      if (!res.ok)
-        throw new Error(`HTTP ${res.status}`);
-      const { keys: keyList } = await res.json();
-      if (keyList.length === 0) {
-        console.log(dim("No API keys."));
-        return;
-      }
-      for (const k of keyList) {
-        const used = k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleDateString() : "never";
-        console.log(`  ${k.prefix}...  ${k.name ?? "(unnamed)"}  ${k.status}  last used: ${used}`);
-      }
-    } catch (err) {
-      error(`Failed to list keys: ${err}`);
-      process.exit(1);
-    }
-  });
-  keys.command("create").description("Create a new API key").option("--name <name>", "Name for the API key").action(async (options2) => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    const headers = {
-      ...authHeaders(config),
-      "Content-Type": "application/json"
-    };
-    try {
-      const res = await fetch(`${apiUrl}/api/keys`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ name: options2.name })
-      });
-      await assertOk(res);
-      const { key, prefix } = await res.json();
-      success(`Created API key: ${prefix}...`);
-      console.log();
-      console.log(`  ${key}`);
-      console.log();
-      console.log(dim("Save this key — it won't be shown again."));
-    } catch (err) {
-      error(`Failed to create key: ${err}`);
-      process.exit(1);
-    }
-  });
-  keys.command("revoke <id>").description("Revoke an API key by ID or prefix").action(async (idOrPrefix) => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    const headers = authHeaders(config);
-    try {
-      let keyId = idOrPrefix;
-      if (!idOrPrefix.includes("-")) {
-        const listRes = await fetch(`${apiUrl}/api/keys`, { headers });
-        if (!listRes.ok)
-          throw new Error(`HTTP ${listRes.status}`);
-        const { keys: keyList } = await listRes.json();
-        const match = keyList.find((k) => k.prefix.startsWith(idOrPrefix) || k.prefix === idOrPrefix);
-        if (!match) {
-          error(`No key found matching "${idOrPrefix}"`);
-          process.exit(1);
-        }
-        keyId = match.id;
-      }
-      const res = await fetch(`${apiUrl}/api/keys/${keyId}`, {
-        method: "DELETE",
-        headers
-      });
-      await assertOk(res);
-      success(`Revoked key ${idOrPrefix}`);
-    } catch (err) {
-      error(`Failed to revoke key: ${err}`);
-      process.exit(1);
-    }
-  });
-  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", defaultKeyName).action(async (options2) => {
-    await rotateKey(options2);
-  });
-}
-async function rotateKey(options2) {
-  const config = await loadConfig();
-  const apiUrl = resolveApiUrl(config);
-  const headers = authHeaders(config);
-  if (!config.apiKey) {
-    error("Not logged in. Run `sl auth login` first.");
-    process.exit(1);
-  }
-  try {
-    if (config.apiKey) {
-      const listRes = await fetch(`${apiUrl}/api/keys`, { headers });
-      if (listRes.ok) {
-        const { keys } = await listRes.json();
-        const currentPrefix = config.apiKey.slice(0, 14);
-        const current = keys.find((k) => currentPrefix.startsWith(k.prefix));
-        if (current) {
-          await fetch(`${apiUrl}/api/keys/${current.id}`, {
-            method: "DELETE",
-            headers
-          });
-          console.log(dim(`Revoked old key: ${current.prefix}...`));
-        }
-      }
-    }
-    const createRes = await fetch(`${apiUrl}/api/keys`, {
-      method: "POST",
-      headers: { ...headers, "Content-Type": "application/json" },
-      body: JSON.stringify({ name: options2.name })
-    });
-    await assertOk(createRes);
-    const { key, prefix } = await createRes.json();
-    config.apiKey = key;
-    await saveConfig(config);
-    success(`Rotated to new key ${prefix}...`);
-  } catch (err) {
-    error(`Rotation failed: ${err}`);
-    process.exit(1);
-  }
-}
 // src/commands/local.ts
 init_config();
 init_dev_state();
@@ -35301,7 +34982,6 @@ function formatLogLine3(service, line) {
   return `${prefix} ${line}`;
 }
 // src/commands/marketplace.ts
-init_api_client();
 init_output();
 function registerMarketplaceCommand(program2) {
   const marketplace = program2.command("marketplace").alias("mp").description("Browse the public subgraph marketplace");
@@ -35344,7 +35024,10 @@ ${result.meta.total} subgraph(s) total`));
       console.log(formatKeyValue([
         ["Name", detail.name],
         ["Description", detail.description ?? dim("—")],
-        ["Creator", detail.creator?.displayName ?? detail.creator?.slug ?? dim("—")],
+        [
+          "Creator",
+          detail.creator?.displayName ?? detail.creator?.slug ?? dim("—")
+        ],
         ["Status", detail.status],
         ["Version", detail.version],
         ["Tags", (detail.tags ?? []).join(", ") || dim("—")],
@@ -35382,290 +35065,464 @@ Endpoints:`));
   });
 }
 // src/commands/whoami.ts
-init_api_client();
 init_config();
+init_http();
 init_output();
+init_project_file();
+init_session();
 function registerWhoamiCommand(program2) {
-  program2.command("whoami").description("Show current authenticated account").action(async () => {
-    const config = await loadConfig();
-    const apiUrl = resolveApiUrl(config);
-    if (!config.apiKey) {
-      error("Not authenticated. Run: sl auth login");
-      process.exit(1);
+  program2.command("whoami").description("Show current authenticated account + active project + tenant").action(async () => {
+    const session = await readSession();
+    if (!session) {
+      error("Not logged in. Run: sl login");
+      process.exit(0);
     }
+    const rows = [];
+    rows.push(["Email", session.email]);
     try {
-      const res = await fetch(`${apiUrl}/api/accounts/me`, {
-        headers: authHeaders(config)
-      });
-      if (res.status === 401) {
-        error("Not authenticated. Run: sl auth login");
+      const account = await httpPlatform("/api/accounts/me");
+      rows.push(["Plan", account.plan]);
+    } catch (err) {
+      if (err instanceof CliHttpError && err.code === "SESSION_EXPIRED") {
+        error("Session expired. Run: sl login");
         process.exit(1);
       }
-      if (!res.ok) {
-        throw new Error(`HTTP ${res.status}`);
-      }
-      const data = await res.json();
-      console.log(formatKeyValue([
-        ["Email", data.email],
-        ["Plan", data.plan],
-        ["Network", config.network],
-        ["API", dim(apiUrl)]
-      ]));
-    } catch (err) {
-      error(`Failed to fetch account: ${err}`);
-      process.exit(1);
+      throw err;
     }
+    const config = await loadConfig();
+    const active = await readActiveProject(process.cwd(), config.defaultProject);
+    if (active) {
+      rows.push(["Project", active.slug]);
+      rows.push(["Project source", dim(active.resolvedFrom)]);
+    } else {
+      rows.push(["Project", dim("(none — run `sl project create <name>`)")]);
+    }
+    try {
+      const tenant = await httpPlatform("/api/tenants/me");
+      if (tenant.tenant) {
+        const trialDays = Math.max(0, Math.ceil((new Date(tenant.tenant.trialEndsAt).getTime() - Date.now()) / (24 * 60 * 60 * 1000)));
+        rows.push(["Instance", tenant.tenant.apiUrl]);
+        rows.push(["Status", tenant.tenant.status]);
+        rows.push([
+          "Trial",
+          `${trialDays} day${trialDays === 1 ? "" : "s"} left`
+        ]);
+      } else {
+        rows.push([
+          "Instance",
+          dim("(none — run `sl instance create --plan launch`)")
+        ]);
+      }
+    } catch {}
+    console.log(formatKeyValue(rows));
   });
 }
-// src/commands/workflows.ts
-init_config();
+// src/commands/login.ts
+init_http();
 init_output();
-import { existsSync as existsSync2 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
-import { SecondLayer as SecondLayer2 } from "@secondlayer/sdk";
-function formatValidationError(err) {
-  if (err != null && typeof err === "object" && "issues" in err && Array.isArray(err.issues)) {
-    error("Workflow validation failed:");
-    for (const issue of err.issues) {
-      const path = issue.path?.length ? issue.path.join(".") : "(root)";
-      error(`  ${path}: ${issue.message}`);
-    }
-  } else {
-    error(`Failed to validate workflow: ${err}`);
-  }
-}
-function getClient2() {
-  const apiKey = process.env.SECONDLAYER_API_KEY;
-  if (!apiKey) {
-    error("SECONDLAYER_API_KEY required. Run: sl auth login");
-    process.exit(1);
-  }
-  return new SecondLayer2({ apiKey });
-}
-function registerWorkflowsCommand(program2) {
-  const workflows = program2.command("workflows").description("Manage workflows");
-  workflows.command("deploy <file>").description("Validate and deploy a workflow definition file").action(async (file) => {
+init_session();
+import { input as input2 } from "@inquirer/prompts";
+function registerLoginCommand(program2) {
+  program2.command("login").description("Log in to Secondlayer (magic-link email)").action(async () => {
+    const email = await input2({
+      message: "Email",
+      validate: (v) => /^.+@.+\..+$/.test(v) ? true : "Invalid email"
+    });
     try {
-      const absPath = resolve7(file);
-      if (!existsSync2(absPath)) {
-        error(`File not found: ${absPath}`);
-        process.exit(1);
+      const res = await httpPlatformAnon("/api/auth/magic-link", {
+        method: "POST",
+        body: { email }
+      });
+      info("Check your inbox for a 6-digit code.");
+      if (res.code) {
+        info(dim(`(DEV_MODE code: ${res.code})`));
       }
-      info(`Loading workflow from ${absPath}`);
-      const mod = await import(absPath);
-      const def = mod.default ?? mod;
-      const { validateWorkflowDefinition } = await import("@secondlayer/workflows/validate");
-      const result = validateWorkflowDefinition(def);
-      const config = await loadConfig();
-      if (config.network !== "local") {
-        info(`Bundling for remote deploy (${config.network})...`);
-        const { readFile: readFile2 } = await import("node:fs/promises");
-        const source = await readFile2(absPath, "utf8");
-        const { bundleWorkflowCode } = await import("@secondlayer/bundler");
-        const bundled = await bundleWorkflowCode(source);
-        const deployResult = await getClient2().workflows.deploy({
-          name: bundled.name,
-          trigger: bundled.trigger,
-          handlerCode: bundled.handlerCode,
-          sourceCode: bundled.sourceCode,
-          retries: bundled.retries,
-          timeout: bundled.timeout
-        });
-        success(`Workflow "${def.name}" ${deployResult.action} → v${deployResult.version} (remote)`);
+    } catch (err) {
+      if (err instanceof CliHttpError) {
+        error(err.message);
       } else {
-        success(`Workflow "${result.name}" is valid`);
-        info(`Trigger: ${result.trigger.type}`);
-        if (result.retries) {
-          info(`Retries: maxAttempts=${result.retries.maxAttempts ?? "default"}`);
-        }
-        if (result.timeout) {
-          info(`Timeout: ${result.timeout}ms`);
-        }
+        error(err instanceof Error ? err.message : String(err));
       }
-    } catch (err) {
-      formatValidationError(err);
       process.exit(1);
     }
-  });
-  workflows.command("validate <file>").description("Validate a workflow definition without deploying").action(async (file) => {
+    const code = await input2({
+      message: "Enter the 6-digit code",
+      validate: (v) => /^\d{6}$/.test(v) ? true : "Expected 6 digits"
+    });
     try {
-      const absPath = resolve7(file);
-      if (!existsSync2(absPath)) {
-        error(`File not found: ${absPath}`);
-        process.exit(1);
-      }
-      const mod = await import(absPath);
-      const def = mod.default ?? mod;
-      const { validateWorkflowDefinition } = await import("@secondlayer/workflows/validate");
-      const result = validateWorkflowDefinition(def);
-      success(`Workflow "${result.name}" is valid`);
-      info(`Trigger: ${result.trigger.type}`);
-      if (result.retries) {
-        info(`Retries: maxAttempts=${result.retries.maxAttempts ?? "default"}, backoffMs=${result.retries.backoffMs ?? 1000}, multiplier=${result.retries.backoffMultiplier ?? 2}`);
-      }
-      if (result.timeout) {
-        info(`Timeout: ${result.timeout}ms`);
-      }
+      const verified = await httpPlatformAnon("/api/auth/verify", {
+        method: "POST",
+        body: { email, code }
+      });
+      const expiresAt = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString();
+      await writeSession({
+        token: verified.sessionToken,
+        email: verified.account.email,
+        accountId: verified.account.id,
+        expiresAt
+      });
+      success(`Logged in as ${verified.account.email}`);
+      info(dim("Run 'sl whoami' to see your account status."));
     } catch (err) {
-      formatValidationError(err);
+      if (err instanceof CliHttpError) {
+        error(err.message);
+      } else {
+        error(err instanceof Error ? err.message : String(err));
+      }
       process.exit(1);
     }
   });
-  workflows.command("list").alias("ls").description("List all workflows").option("--json", "Output as JSON").action(async (options2) => {
+}
+// src/commands/logout.ts
+init_http();
+init_output();
+init_session();
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Log out and revoke the local session").action(async () => {
+    const session = await readSession();
+    if (!session) {
+      info("Not logged in.");
+      return;
+    }
     try {
-      const { workflows: items } = await getClient2().workflows.list();
-      if (options2.json) {
-        console.log(JSON.stringify(items, null, 2));
-        return;
-      }
-      if (items.length === 0) {
-        console.log("No workflows deployed");
-        return;
+      await httpPlatform("/api/auth/logout", { method: "POST" });
+    } catch (err) {
+      if (err instanceof CliHttpError) {
+        warn(`Server logout failed (${err.code}) — clearing local session anyway`);
       }
-      const rows = items.map((w) => {
-        const statusColor = w.status === "active" ? green : yellow;
-        return [w.name, statusColor(w.status), w.triggerType, w.createdAt];
+    }
+    await clearSession();
+    success("Logged out.");
+  });
+}
+// src/commands/instance.ts
+init_config();
+init_http();
+init_output();
+init_project_file();
+init_resolve_tenant();
+import { confirm as confirm4, input as input3, select as select3 } from "@inquirer/prompts";
+function registerInstanceCommand(program2) {
+  const instance = program2.command("instance").description("Manage your dedicated Secondlayer instance");
+  instance.command("create").description("Provision a new dedicated instance for the active project").option("--plan <plan>", "Plan: launch | grow | scale", "launch").action(async (opts) => {
+    guardOssMode();
+    const activeSlug = await requireActiveProject();
+    const plan = opts.plan;
+    if (!["launch", "grow", "scale"].includes(plan)) {
+      error(`Invalid plan: ${plan} (expected launch, grow, or scale)`);
+      process.exit(1);
+    }
+    try {
+      const res = await httpPlatform(`/api/projects/${encodeURIComponent(activeSlug)}/instance`, {
+        method: "POST",
+        body: { plan }
       });
-      console.log(formatTable(["Name", "Status", "Trigger", "Created"], rows));
-      console.log(dim(`
-${items.length} workflow(s) total`));
+      success(`Instance provisioned: ${res.tenant.slug}`);
+      printKeyReveal(res.tenant, res.credentials);
     } catch (err) {
-      error(`Failed to list workflows: ${err}`);
-      process.exit(1);
+      handleInstanceError(err, "provision instance");
     }
   });
-  workflows.command("get <name>").description("Get workflow details").option("--json", "Output as JSON").action(async (name, options2) => {
-    try {
-      const detail = await getClient2().workflows.get(name);
-      if (options2.json) {
-        console.log(JSON.stringify(detail, null, 2));
+  instance.command("info").description("Show the active project's instance").action(async () => {
+    guardOssMode();
+    await renderInstanceInfo();
+  });
+  instance.command("resize").description("Change your instance plan (brief downtime)").option("--plan <plan>", "Target plan: launch | grow | scale").option("--yes", "Skip confirm").action(async (opts) => {
+    guardOssMode();
+    let target = opts.plan;
+    if (!target) {
+      const answer = await select3({
+        message: "Target plan",
+        choices: [
+          {
+            value: "launch",
+            name: "Launch — $99/mo (1 vCPU · 2 GB · 10 GB)"
+          },
+          { value: "grow", name: "Grow — $249/mo (2 vCPU · 4 GB · 50 GB)" },
+          {
+            value: "scale",
+            name: "Scale — $599/mo (4 vCPU · 8 GB · 200 GB)"
+          }
+        ]
+      });
+      target = answer;
+    }
+    if (!opts.yes) {
+      const ok = await confirm4({
+        message: `Resize to ${target}? ~30s downtime while containers recreate. Data preserved.`,
+        default: false
+      });
+      if (!ok) {
+        info("Cancelled.");
         return;
       }
-      console.log(formatKeyValue([
-        ["Name", detail.name],
-        ["Status", detail.status],
-        ["Trigger", detail.triggerType],
-        ["Total Runs", String(detail.totalRuns)],
-        ["Last Run", detail.lastRunAt ?? "never"],
-        ["Timeout", detail.timeout ? `${detail.timeout}ms` : "default"],
-        ["Created", detail.createdAt],
-        ["Updated", detail.updatedAt]
-      ]));
+    }
+    try {
+      await httpPlatform("/api/tenants/me/resize", {
+        method: "POST",
+        body: { plan: target }
+      });
+      success(`Resized to ${target}.`);
     } catch (err) {
-      error(`Failed to get workflow: ${err}`);
-      process.exit(1);
+      handleInstanceError(err, "resize");
     }
   });
-  workflows.command("trigger <name>").description("Trigger a workflow run").option("--input <json>", "Input JSON string").action(async (name, options2) => {
+  instance.command("suspend").description("Stop your instance (data preserved)").action(async () => {
+    guardOssMode();
     try {
-      const input3 = options2.input ? JSON.parse(options2.input) : undefined;
-      const result = await getClient2().workflows.trigger(name, input3);
-      success(`Triggered workflow "${name}"`);
-      info(`Run ID: ${result.runId}`);
+      await httpPlatform("/api/tenants/me/suspend", { method: "POST" });
+      success("Instance suspended.");
     } catch (err) {
-      error(`Failed to trigger workflow: ${err}`);
-      process.exit(1);
+      handleInstanceError(err, "suspend");
     }
   });
-  workflows.command("runs <name>").description("List runs for a workflow").option("--status <status>", "Filter by status").option("--limit <n>", "Max runs to return", "20").option("--json", "Output as JSON").action(async (name, options2) => {
+  instance.command("resume").description("Start a suspended instance").action(async () => {
+    guardOssMode();
     try {
-      const { runs } = await getClient2().workflows.listRuns(name, {
-        status: options2.status,
-        limit: options2.limit ? Number.parseInt(options2.limit, 10) : undefined
+      await httpPlatform("/api/tenants/me/resume", { method: "POST" });
+      success("Instance resumed.");
+    } catch (err) {
+      handleInstanceError(err, "resume");
+    }
+  });
+  instance.command("delete").description("Permanently delete your instance + all data").option("--yes", "Skip typed-slug confirm").action(async (opts) => {
+    guardOssMode();
+    const info_ = await httpPlatform("/api/tenants/me").catch(() => null);
+    if (!info_?.tenant) {
+      warn("No instance to delete.");
+      return;
+    }
+    const slug = info_.tenant.slug;
+    if (!opts.yes) {
+      const typed = await input3({
+        message: `Type the slug "${slug}" to confirm permanent deletion`,
+        validate: (v) => v === slug ? true : "Slug must match exactly"
       });
-      if (options2.json) {
-        console.log(JSON.stringify(runs, null, 2));
-        return;
-      }
-      if (runs.length === 0) {
-        console.log("No runs found");
+      if (typed !== slug)
         return;
-      }
-      const rows = runs.map((r) => {
-        const statusColor = r.status === "completed" ? green : r.status === "failed" ? (s) => `\x1B[31m${s}\x1B[0m` : yellow;
-        return [
-          r.id.slice(0, 8),
-          statusColor(r.status),
-          `${r.duration}ms`,
-          String(r.aiTokensUsed),
-          r.triggeredAt
-        ];
-      });
-      console.log(formatTable(["ID", "Status", "Duration", "AI Tokens", "Triggered"], rows));
-      console.log(dim(`
-${runs.length} run(s)`));
+    }
+    try {
+      await httpPlatform("/api/tenants/me", { method: "DELETE" });
+      success("Instance deleted.");
     } catch (err) {
-      error(`Failed to list runs: ${err}`);
-      process.exit(1);
+      handleInstanceError(err, "delete");
     }
   });
-  workflows.command("pause <name>").description("Pause a workflow").action(async (name) => {
+  const keys = instance.command("keys").description("Rotate long-lived keys (service, anon)");
+  keys.command("rotate").description("Rotate one or both keys").option("--service", "Rotate the service key").option("--anon", "Rotate the anon key").option("--both", "Rotate both keys (nuclear)").action(async (opts) => {
+    guardOssMode();
+    let type;
+    if (opts.both || opts.service && opts.anon)
+      type = "both";
+    else if (opts.service)
+      type = "service";
+    else if (opts.anon)
+      type = "anon";
+    else {
+      const answer = await select3({
+        message: "Which key(s) to rotate?",
+        choices: [
+          {
+            value: "service",
+            name: "Service key (full access, server-side)"
+          },
+          { value: "anon", name: "Anon key (read-only, client-safe)" },
+          {
+            value: "both",
+            name: "Both (nuclear — offboarding/leak response)"
+          }
+        ]
+      });
+      type = answer;
+    }
     try {
-      await getClient2().workflows.pause(name);
-      success(`Paused workflow "${name}"`);
+      const res = await httpPlatform("/api/tenants/me/keys/rotate", {
+        method: "POST",
+        body: { type }
+      });
+      success(`${type === "both" ? "Keys" : `${type} key`} rotated.`);
+      const rows = [];
+      if (res.rotated.serviceKey)
+        rows.push(["New service key", res.rotated.serviceKey]);
+      if (res.rotated.anonKey)
+        rows.push(["New anon key", res.rotated.anonKey]);
+      console.log("");
+      console.log(warn_box("⚠  Shown once. Save these now — we can't retrieve them later."));
+      console.log("");
+      console.log(formatKeyValue(rows));
+      console.log("");
     } catch (err) {
-      error(`Failed to pause workflow: ${err}`);
+      handleInstanceError(err, "rotate keys");
+    }
+  });
+}
+function guardOssMode() {
+  if (isOssMode()) {
+    error("`sl instance` commands are for hosted deployments. For OSS use `sl local` / `sl stack` or your own provisioning.");
+    process.exit(1);
+  }
+}
+async function requireActiveProject() {
+  const config = await loadConfig();
+  const active = await readActiveProject(process.cwd(), config.defaultProject);
+  if (!active) {
+    error("No active project — run `sl project create <name>` or `sl project use <slug>` first.");
+    process.exit(1);
+  }
+  return active.slug;
+}
+async function renderInstanceInfo() {
+  try {
+    const res = await httpPlatform("/api/tenants/me");
+    if (!res.tenant) {
+      info("No instance for the active project. Run `sl instance create --plan launch`.");
+      return;
+    }
+    const t = res.tenant;
+    const trialDays = Math.max(0, Math.ceil((new Date(t.trialEndsAt).getTime() - Date.now()) / (24 * 60 * 60 * 1000)));
+    console.log(formatKeyValue([
+      ["URL", t.apiUrl],
+      ["Plan", t.plan],
+      ["Status", t.status],
+      ["Trial", `${trialDays} day${trialDays === 1 ? "" : "s"} left`],
+      ["Created", new Date(t.createdAt).toLocaleString()]
+    ]));
+  } catch (err) {
+    handleInstanceError(err, "fetch instance");
+  }
+}
+function printKeyReveal(tenant, creds) {
+  console.log("");
+  console.log(blue("━".repeat(60)));
+  console.log(blue("  Save your keys — shown once. Can't retrieve later."));
+  console.log(blue("━".repeat(60)));
+  console.log("");
+  console.log(formatKeyValue([
+    ["URL", creds.apiUrl],
+    ["Plan", tenant.plan],
+    ["Service key", green(creds.serviceKey)],
+    ["Anon key", green(creds.anonKey)]
+  ]));
+  console.log("");
+  console.log(dim("Run `sl subgraphs deploy <file>` to deploy your first subgraph."));
+  console.log("");
+}
+function warn_box(message) {
+  return `${"━".repeat(message.length + 4)}
+  ${message}  
+${"━".repeat(message.length + 4)}`;
+}
+function handleInstanceError(err, action) {
+  if (err instanceof CliHttpError) {
+    if (err.code === "SESSION_EXPIRED") {
+      error("Session expired. Run: sl login");
+      process.exit(1);
+    }
+    if (err.code === "TRIAL_EXPIRED") {
+      error(err.message);
+      error("Add a payment method at the dashboard to keep your instance running.");
+      process.exit(1);
+    }
+    if (err.code === "TENANT_SUSPENDED") {
+      error("Instance is suspended. Run: sl instance resume");
+      process.exit(1);
+    }
+    if (err.code === "INSTANCE_EXISTS") {
+      error("This project already has an instance. Run `sl instance info` to see it.");
       process.exit(1);
     }
+    error(err.message);
+    process.exit(1);
+  }
+  error(`Failed to ${action}: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}
+// src/commands/project.ts
+init_config();
+init_http();
+init_output();
+init_project_file();
+import { input as input4 } from "@inquirer/prompts";
+function registerProjectCommand(program2) {
+  const project = program2.command("project").description("Manage Secondlayer projects");
+  project.command("create [name]").description("Create a new project").action(async (nameArg) => {
+    const name = nameArg ?? await input4({
+      message: "Project name",
+      validate: (v) => v.length >= 2 ? true : "Name must be at least 2 characters"
+    });
+    try {
+      const res = await httpPlatform("/api/projects", { method: "POST", body: { name } });
+      success(`Created project ${res.project.name} (${res.project.slug})`);
+      const path = await writeActiveProject(res.project.slug, process.cwd());
+      info(dim(`Bound to this directory → ${path}`));
+      info(dim(`Next: sl instance create --plan launch`));
+    } catch (err) {
+      handleProjectError(err);
+    }
   });
-  workflows.command("resume <name>").description("Resume a paused workflow").action(async (name) => {
+  project.command("list").description("List projects in your account").action(async () => {
     try {
-      await getClient2().workflows.resume(name);
-      success(`Resumed workflow "${name}"`);
+      const res = await httpPlatform("/api/projects");
+      if (res.projects.length === 0) {
+        info("No projects yet — run `sl project create <name>` to start.");
+        return;
+      }
+      const active = await readActiveProject(process.cwd(), (await loadConfig()).defaultProject);
+      const rows = res.projects.map((p) => [
+        p.slug === active?.slug ? `* ${p.slug}` : `  ${p.slug}`,
+        p.name,
+        p.network,
+        new Date(p.createdAt).toLocaleDateString()
+      ]);
+      console.log(formatTable(["", "Name", "Network", "Created"], rows));
+      if (active) {
+        console.log(dim(`Active: ${active.slug} (from ${active.resolvedFrom})`));
+      }
     } catch (err) {
-      error(`Failed to resume workflow: ${err}`);
-      process.exit(1);
+      handleProjectError(err);
     }
   });
-  workflows.command("templates [id]").description("List workflow templates, or print a template's source to stdout").option("--json", "Output as JSON (list mode only)").action(async (id, options2) => {
-    const { templates, getTemplateById } = await import("@secondlayer/workflows/templates");
-    if (id) {
-      const template = getTemplateById(id);
-      if (!template) {
-        error(`Template not found: ${id}`);
-        info(`Available: ${templates.map((t) => t.id).join(", ")}`);
+  project.command("use <slug>").description("Bind this directory to a project (writes ./.secondlayer/project)").action(async (slug) => {
+    try {
+      await httpPlatform(`/api/projects/${encodeURIComponent(slug)}`);
+    } catch (err) {
+      if (err instanceof CliHttpError && err.status === 404) {
+        error(`Project "${slug}" not found — run 'sl project list' to see available projects`);
         process.exit(1);
       }
-      process.stdout.write(template.code);
-      return;
+      handleProjectError(err);
     }
-    if (options2.json) {
-      console.log(JSON.stringify(templates.map(({ code: _code, ...rest }) => rest), null, 2));
+    const path = await writeActiveProject(slug, process.cwd());
+    success(`Bound to project "${slug}"`);
+    info(dim(`Written to ${path}`));
+  });
+  project.command("current").description("Show the active project for this directory").action(async () => {
+    const config = await loadConfig();
+    const active = await readActiveProject(process.cwd(), config.defaultProject);
+    if (!active) {
+      info("No active project.");
+      info(dim("Run 'sl project create <name>' or 'sl project use <slug>'."));
       return;
     }
-    const rows = templates.map((t) => [
-      t.id,
-      t.category,
-      t.trigger,
-      t.description
-    ]);
-    console.log(formatTable(["Id", "Category", "Trigger", "Description"], rows));
-    console.log(dim(`
-${templates.length} template(s). Pipe source with: sl workflows templates <id> > workflows/<name>.ts`));
+    console.log(active.slug);
+    console.log(dim(`(from ${active.resolvedFrom})`));
   });
-  workflows.command("delete <name>").description("Delete a workflow").option("-y, --yes", "Skip confirmation").action(async (name, options2) => {
-    try {
-      if (!options2.yes) {
-        const { confirm: confirm5 } = await import("@inquirer/prompts");
-        const ok = await confirm5({
-          message: `Delete workflow "${name}"? This cannot be undone.`
-        });
-        if (!ok) {
-          info("Cancelled");
-          return;
-        }
-      }
-      await getClient2().workflows.delete(name);
-      success(`Deleted workflow "${name}"`);
-    } catch (err) {
-      error(`Failed to delete workflow: ${err}`);
+}
+function handleProjectError(err) {
+  if (err instanceof CliHttpError) {
+    if (err.code === "SESSION_EXPIRED") {
+      error("Session expired. Run: sl login");
       process.exit(1);
     }
-  });
+    error(err.message);
+    process.exit(1);
+  }
+  error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
 }
 // src/cli.ts
 var { version } = package_default;
-program.name("secondlayer").alias("sl").description("SecondLayer CLI — subgraphs, workflows, and real-time indexing for Stacks").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
+program.name("secondlayer").alias("sl").description("SecondLayer CLI — dedicated Stacks indexing + real-time subgraphs").version(version).option("--network <network>", "Override network (local, testnet, mainnet)");
 program.hook("preAction", (thisCommand) => {
   const net3 = thisCommand.opts().network;
   if (net3)
@@ -35673,10 +35530,11 @@ program.hook("preAction", (thisCommand) => {
 });
 program.addHelpText("after", `
 Quickstart:
-  $ sl auth login                  # Authenticate
-  $ sl subgraphs new my-subgraph   # Scaffold a subgraph
-  $ sl workflows new my-workflow   # Scaffold a workflow
-  $ sl status                      # Check system health
+  $ sl login                        # Authenticate (magic-link email)
+  $ sl project create my-app        # Scaffold a project (tenant + data)
+  $ sl project use my-app           # Bind this directory to the project
+  $ sl instance create --plan launch  # Provision a dedicated instance
+  $ sl subgraphs deploy ./x.ts      # Deploy a subgraph — targets your instance
 `);
 program.command("generate [files...]").aliases(["gen", "codegen"]).description("Generate TypeScript interfaces from Clarity contracts").option("-c, --config <path>", "Path to config file").option("-o, --out <path>", "Output file path (required when using direct files)").option("-k, --api-key <key>", "Hiro API key (or set HIRO_API_KEY env var)").option("-w, --watch", "Watch for changes").action(async (files, options3) => {
   const { generate: generate2 } = await Promise.resolve().then(() => (init_generate(), exports_generate));
@@ -35686,20 +35544,21 @@ program.command("init").description("Initialize a new secondlayer.config.ts file
   const { init: init3 } = await Promise.resolve().then(() => (init_init(), exports_init));
   await init3();
 });
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerWhoamiCommand(program);
+registerProjectCommand(program);
+registerInstanceCommand(program);
 registerSubgraphsCommand(program);
-registerWorkflowsCommand(program);
 registerMarketplaceCommand(program);
 registerStatusCommand(program);
-registerLocalCommand(program);
-registerAccountCommand(program);
 registerStackCommand(program);
 registerDbCommand(program);
-registerSyncCommand(program);
 registerDoctorCommand(program);
 registerConfigCommand(program);
-registerAuthCommand(program);
-registerWhoamiCommand(program);
+registerLocalCommand(program);
+registerAccountCommand(program);
 program.parse();
 
-//# debugId=68B9BDC7A5E4D6A864756E2164756E21
+//# debugId=E8F09B3E58038C8F64756E2164756E21
 //# sourceMappingURL=cli.js.map