@secondlayer/cli 22.3.4 → 23.1.0

package/dist/cli.js

@@ -33,19 +33,6 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
 var __esm = (fn, res, err) => () => {
   if (fn)
     try {
@@ -2144,7 +2131,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 // src/lib/api-url.ts
 import { isHostedApiUrl } from "@secondlayer/sdk";
 function resolveApiUrl() {
-  return (process.env.SECONDLAYER_API_URL ?? process.env.SL_PLATFORM_API_URL ?? LOCAL_API_URL).replace(/\/+$/, "");
+  return (process.env.SECONDLAYER_API_URL ?? LOCAL_API_URL).replace(/\/+$/, "");
 }
 function resolveArchiveOpsUrl() {
   return (process.env.SL_CREDITS_API_URL ?? ARCHIVE_OPS_API_URL).replace(/\/+$/, "");
@@ -29197,75 +29184,12 @@ async function sha256File(path) {
 var init_fs = () => {};
 
 // src/lib/config.ts
-var exports_config = {};
-__export(exports_config, {
-  clearConfig: () => clearConfig,
-  getConfigPath: () => getConfigPath,
-  getDataDir: () => getDataDir,
-  getDefaultConfig: () => getDefaultConfig,
-  isDefaultValue: () => isDefaultValue,
-  loadConfig: () => loadConfig2,
-  requireLocalNetwork: () => requireLocalNetwork,
-  resetConfig: () => resetConfig,
-  setConfigValue: () => setConfigValue
-});
 import { homedir as homedir2 } from "node:os";
 import { join as join6 } from "node:path";
 import { z as z3 } from "zod";
 async function ensureConfigDir() {
   await ensureDir(CONFIG_DIR);
 }
-function resolvePath(path) {
-  if (path.startsWith("~/")) {
-    return join6(homedir2(), path.slice(2));
-  }
-  return path;
-}
-function getDataDir(config) {
-  const dataDir = config?.dataDir ?? DEFAULT_CONFIG.dataDir;
-  return resolvePath(dataDir);
-}
-function migrateConfig(raw) {
-  if (!raw || typeof raw !== "object") {
-    return { ...DEFAULT_CONFIG };
-  }
-  const old = raw;
-  const migrated = { ...DEFAULT_CONFIG };
-  if (typeof old.network === "string" && ["local", "testnet", "mainnet"].includes(old.network)) {
-    migrated.network = old.network;
-  }
-  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 || "",
-      network: old.nodeNetwork || "mainnet"
-    };
-    if (!migrated.node.installPath) {
-      migrated.node = undefined;
-    }
-  }
-  if (old.node && typeof old.node === "object") {
-    migrated.node = old.node;
-  }
-  if (old.ports && typeof old.ports === "object") {
-    migrated.ports = { ...DEFAULT_CONFIG.ports, ...old.ports };
-  }
-  if (old.database && typeof old.database === "object") {
-    migrated.database = {
-      ...DEFAULT_CONFIG.database,
-      ...old.database
-    };
-  }
-  if (typeof old.indexerPort === "number") {
-    migrated.ports.indexer = old.indexerPort;
-  }
-  return migrated;
-}
 async function loadConfig2() {
   let config;
   if (!await fileExists(CONFIG_PATH)) {
@@ -29273,8 +29197,7 @@ async function loadConfig2() {
   } else {
     try {
       const raw = await readJsonFile(CONFIG_PATH);
-      const migrated = migrateConfig(raw);
-      config = ConfigSchema.parse(migrated);
+      config = ConfigSchema.parse(raw);
     } catch (error) {
       console.error("Warning: Invalid config file, using defaults");
       config = { ...DEFAULT_CONFIG };
@@ -29295,27 +29218,6 @@ function applyEnvOverrides(config) {
       console.error(`Warning: STACKS_NETWORK=${net} is not mainnet, testnet, or devnet; using ${result.network}`);
     }
   }
-  if (process.env.SL_DATA_DIR) {
-    result.dataDir = process.env.SL_DATA_DIR;
-  }
-  if (process.env.SL_API_PORT) {
-    const port = Number.parseInt(process.env.SL_API_PORT, 10);
-    if (!Number.isNaN(port) && port > 0 && port <= 65535) {
-      result.ports = { ...result.ports, api: port };
-    }
-  }
-  if (process.env.SL_INDEXER_PORT) {
-    const port = Number.parseInt(process.env.SL_INDEXER_PORT, 10);
-    if (!Number.isNaN(port) && port > 0 && port <= 65535) {
-      result.ports = { ...result.ports, indexer: port };
-    }
-  }
-  if (process.env.STACKS_NODE_RPC_URL) {
-    result.nodeRpcUrl = process.env.STACKS_NODE_RPC_URL;
-  }
-  if (process.env.DATABASE_URL) {
-    result.database = { type: "external", url: process.env.DATABASE_URL };
-  }
   return result;
 }
 async function saveConfig(config) {
@@ -29325,45 +29227,11 @@ async function saveConfig(config) {
 `);
 }
 async function setConfigValue(key, value) {
-  const config = await loadConfig2();
-  const keys = key.split(".");
-  let current = config;
-  for (let i = 0;i < keys.length - 1; i++) {
-    const k = keys[i];
-    if (current[k] === undefined) {
-      current[k] = {};
-    }
-    current = current[k];
-  }
-  const finalKey = keys[keys.length - 1];
-  const parsedValue = parseValue(value);
-  current[finalKey] = parsedValue;
-  await saveConfig(config);
-}
-function parseValue(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  const num = Number(value);
-  if (!Number.isNaN(num) && value.trim() !== "") {
-    return num;
-  }
-  return value;
-}
-function getConfigValue(config, key) {
-  const keys = key.split(".");
-  let current = config;
-  for (const k of keys) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
-    }
-    current = current[k];
+  if (!(key in ConfigSchema.shape)) {
+    throw new Error(`Invalid config key: ${key}`);
   }
-  return current;
+  const config = await loadConfig2();
+  await saveConfig({ ...config, [key]: value });
 }
 async function resetConfig() {
   await saveConfig({ ...DEFAULT_CONFIG });
@@ -29392,44 +29260,16 @@ async function requireLocalNetwork() {
   }
   return config;
 }
-function isDefaultValue(config, key) {
-  const currentValue = getConfigValue(config, key);
-  const defaultValue = getConfigValue(DEFAULT_CONFIG, key);
-  return JSON.stringify(currentValue) === JSON.stringify(defaultValue);
-}
-var PortsSchema, NodeSchema, DatabaseSchema, NetworkSchema, ConfigSchema, CONFIG_DIR, CONFIG_PATH, DEFAULT_CONFIG;
+var NetworkSchema, ConfigSchema, CONFIG_DIR, CONFIG_PATH, DEFAULT_CONFIG;
 var init_config2 = __esm(() => {
   init_fs();
-  PortsSchema = z3.object({
-    api: z3.number().int().min(1).max(65535).default(3800),
-    indexer: z3.number().int().min(1).max(65535).default(3700)
-  });
-  NodeSchema = z3.object({
-    installPath: z3.string().min(1),
-    network: z3.enum(["mainnet", "testnet"]).default("mainnet")
-  });
-  DatabaseSchema = z3.object({
-    type: z3.enum(["docker", "external"]).default("docker"),
-    url: z3.string().url().optional()
-  });
   NetworkSchema = z3.enum(["local", "testnet", "mainnet"]);
   ConfigSchema = z3.object({
-    network: NetworkSchema.default("mainnet"),
-    nodeRpcUrl: z3.string().url().optional(),
-    dataDir: z3.string().default("~/.secondlayer/data"),
-    node: NodeSchema.optional(),
-    ports: PortsSchema.default({ api: 3800, indexer: 3700 }),
-    database: DatabaseSchema.default({ type: "docker" }),
-    defaultProject: z3.string().optional()
+    network: NetworkSchema.default("mainnet")
   });
   CONFIG_DIR = join6(homedir2(), ".secondlayer");
   CONFIG_PATH = join6(CONFIG_DIR, "config.json");
-  DEFAULT_CONFIG = {
-    network: "mainnet",
-    dataDir: "~/.secondlayer/data",
-    ports: { api: 3800, indexer: 3700 },
-    database: { type: "docker" }
-  };
+  DEFAULT_CONFIG = { network: "mainnet" };
 });
 
 // src/lib/filter-params.ts
@@ -31667,7 +31507,7 @@ function client() {
     apiKey: resolveDataPlaneKey()
   });
 }
-function fail(action, err) {
+function fail2(action, err) {
   const message = err instanceof Error ? err.message : String(err);
   error(`Failed to ${action}: ${message}`);
   if (/\b403\b/.test(message) || /forbidden/i.test(message)) {
@@ -31758,7 +31598,7 @@ function registerIndexCommand(program) {
         recipient: o.recipient
       }), o.json);
     } catch (err) {
-      fail("list ft transfers", err);
+      fail2("list ft transfers", err);
     }
   });
   orderFlag(rangeFlags(index.command("nft-transfers"))).description("List decoded SIP-009 non-fungible-token transfers").option("--sender <principal>", "Filter by sender").option("--recipient <principal>", "Filter by recipient").option("--asset-identifier <id>", "Filter by asset identifier").action(async (o) => {
@@ -31771,7 +31611,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail("list nft transfers", err);
+      fail2("list nft transfers", err);
     }
   });
   orderFlag(rangeFlags(index.command("events"))).description("List decoded events by type (stx_*, ft/nft mint/burn, print, …)").option("--event-type <type>", `decoded event type (${VALID_INDEX_TYPES.join(", ")})`).option("--types <type>", "alias for --event-type, ONE value (the Streams spelling)").option("--sender <principal>", "Filter by sender").option("--recipient <principal>", "Filter by recipient").option("--asset-identifier <id>", "Filter by asset identifier").action(async (o) => {
@@ -31785,7 +31625,7 @@ function registerIndexCommand(program) {
         assetIdentifier: o.assetIdentifier
       }), o.json);
     } catch (err) {
-      fail("list events", err);
+      fail2("list events", err);
     }
   });
   rangeFlags(index.command("contract-calls")).description("List decoded contract calls (function, args, result)").option("--function-name <name>", "Filter by called function").option("--sender <principal>", "Filter by caller").action(async (o) => {
@@ -31796,21 +31636,21 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail("list contract calls", err);
+      fail2("list contract calls", err);
     }
   });
   heightFlags(index.command("canonical")).description("List the canonical Stacks block sequence (height + hash)").action(async (o) => {
     try {
       emit(await client().canonical.list(heightParams(o)), o.json);
     } catch (err) {
-      fail("list canonical blocks", err);
+      fail2("list canonical blocks", err);
     }
   });
   const blocks = heightFlags(index.command("blocks")).description("List decoded blocks (run `blocks get <ref>` for one block)").action(async (o) => {
     try {
       emit(await client().blocks.list(heightParams(o)), o.json);
     } catch (err) {
-      fail("list blocks", err);
+      fail2("list blocks", err);
     }
   });
   blocks.command("get <ref>").description("Get a single block by height or block hash").option("--json", "Print as JSON").action(async (ref, o) => {
@@ -31818,7 +31658,7 @@ function registerIndexCommand(program) {
       const block = await client().blocks.get(/^\d+$/.test(ref) ? Number.parseInt(ref, 10) : ref);
       emitOne(block, `block ${ref}`, o.json);
     } catch (err) {
-      fail("get block", err);
+      fail2("get block", err);
     }
   });
   const transactions = rangeFlags(index.command("transactions")).description("List decoded transactions (run `transactions get <txId>` for one)").option("--type <type>", "Filter by transaction type").option("--sender <principal>", "Filter by sender").action(async (o) => {
@@ -31829,14 +31669,14 @@ function registerIndexCommand(program) {
         sender: o.sender
       }), o.json);
     } catch (err) {
-      fail("list transactions", err);
+      fail2("list transactions", err);
     }
   });
   transactions.command("get <txId>").description("Get a single transaction by tx_id").option("--json", "Print as JSON").action(async (txId, o) => {
     try {
       emitOne(await client().transactions.get(txId), `tx ${txId}`, o.json);
     } catch (err) {
-      fail("get transaction", err);
+      fail2("get transaction", err);
     }
   });
   heightFlags(index.command("stacking")).description("List decoded PoX-4 stacking actions").option("--function-name <name>", "Filter by PoX function name").option("--stacker <principal>", "Filter by stacker").option("--caller <principal>", "Filter by caller").action(async (o) => {
@@ -31848,7 +31688,7 @@ function registerIndexCommand(program) {
         caller: o.caller
       }), o.json);
     } catch (err) {
-      fail("list stacking actions", err);
+      fail2("list stacking actions", err);
     }
   });
   const mempool = index.command("mempool").description("List pending mempool transactions (run `mempool get <txId>` for one)").option("--contract-id <id>", "Filter to pending calls to a contract").option("--function-name <name>", "Filter to pending calls to a function").option("--sender <principal>", "Filter by sender").option("--type <type>", "Filter by transaction type").option("--cursor <cursor>", "Resume token from a previous next_cursor").option("--limit <n>", "Rows per page").option("--json", "Print the full envelope as JSON").action(async (o) => {
@@ -31862,14 +31702,14 @@ function registerIndexCommand(program) {
         limit: o.limit ? Number.parseInt(o.limit, 10) : undefined
       }), o.json);
     } catch (err) {
-      fail("list mempool", err);
+      fail2("list mempool", err);
     }
   });
   mempool.command("get <txId>").description("Get a single pending transaction by tx_id (404 once mined)").option("--json", "Print as JSON").action(async (txId, o) => {
     try {
       emitOne(await client().mempool.get(txId), `pending tx ${txId}`, o.json);
     } catch (err) {
-      fail("get mempool tx", err);
+      fail2("get mempool tx", err);
     }
   });
   const runes = index.command("runes").description("List etched runes (Bitcoin; run `runes get <rune>` for one)").option("--search <prefix>", "Name prefix, spacers and case ignored").option("--sort <order>", "number (etch order) or mints (busiest first)").option("--cursor <cursor>", "Resume token from a previous next_cursor").option("--limit <n>", "Rows per page").option("--json", "Print the full envelope as JSON").action(async (o) => {
@@ -31881,7 +31721,7 @@ function registerIndexCommand(program) {
         limit: o.limit ? Number.parseInt(o.limit, 10) : undefined
       }), o.json);
     } catch (err) {
-      fail("list runes", err);
+      fail2("list runes", err);
     }
   });
   runes.command("get <rune>").description("Get one rune by id (840000:3) or name, any spacing or case").option("--json", "Print as JSON").action(async (rune, _o, cmd) => {
@@ -31889,7 +31729,7 @@ function registerIndexCommand(program) {
     try {
       emitOne(await client().runes.get(rune), `rune ${rune}`, o.json);
     } catch (err) {
-      fail("get rune", err);
+      fail2("get rune", err);
     }
   });
   runes.command("balances").description("Current rune balances by address or outpoint (Bitcoin)").option("--address <address>", "Bitcoin address").option("--outpoint <txid:vout>", "Unspent output").option("--rune <ref>", "Narrow to one rune (id or name)").option("--cursor <cursor>", "Resume token from a previous next_cursor").option("--limit <n>", "Rows per page").option("--json", "Print the full envelope as JSON").action(async (_o, cmd) => {
@@ -31902,7 +31742,7 @@ function registerIndexCommand(program) {
         limit: o.limit ? Number.parseInt(o.limit, 10) : undefined
       }), o.json);
     } catch (err) {
-      fail("list rune balances", err);
+      fail2("list rune balances", err);
     }
   });
   runes.command("activity").description("List rune etches, mints, transfers and burns (Bitcoin)").option("--rune <ref>", "Filter by rune (id or name)").option("--address <address>", "Filter by Bitcoin address").option("--kind <kinds>", `Comma list of ${RUNE_KINDS.join(", ")}`).option("--txid <txid>", "Filter by Bitcoin transaction id").option("--from-height <n>", "Start Bitcoin block height (inclusive)").option("--to-height <n>", "End Bitcoin block height (inclusive)").option("--cursor <cursor>", "Resume token from a previous next_cursor").option("--limit <n>", "Rows per page").option("--json", "Print the full envelope as JSON").action(async (_o, cmd) => {
@@ -31916,7 +31756,7 @@ function registerIndexCommand(program) {
         txid: o.txid
       }), o.json);
     } catch (err) {
-      fail("list rune activity", err);
+      fail2("list rune activity", err);
     }
   });
 }
@@ -31955,1995 +31795,9 @@ var init_index_api = __esm(() => {
   RUNE_KINDS = ["etch", "mint", "transfer", "burn"];
 });
 
-// ../../node_modules/postgres/src/query.js
-function cachedError(xs) {
-  if (originCache.has(xs))
-    return originCache.get(xs);
-  const x = Error.stackTraceLimit;
-  Error.stackTraceLimit = 4;
-  originCache.set(xs, new Error);
-  Error.stackTraceLimit = x;
-  return originCache.get(xs);
-}
-var originCache, originStackCache, originError, CLOSE, Query;
-var init_query = __esm(() => {
-  originCache = new Map;
-  originStackCache = new Map;
-  originError = Symbol("OriginError");
-  CLOSE = {};
-  Query = class Query extends Promise {
-    constructor(strings, args, handler, canceller, options = {}) {
-      let resolve, reject;
-      super((a, b) => {
-        resolve = a;
-        reject = b;
-      });
-      this.tagged = Array.isArray(strings.raw);
-      this.strings = strings;
-      this.args = args;
-      this.handler = handler;
-      this.canceller = canceller;
-      this.options = options;
-      this.state = null;
-      this.statement = null;
-      this.resolve = (x) => (this.active = false, resolve(x));
-      this.reject = (x) => (this.active = false, reject(x));
-      this.active = false;
-      this.cancelled = null;
-      this.executed = false;
-      this.signature = "";
-      this[originError] = this.handler.debug ? new Error : this.tagged && cachedError(this.strings);
-    }
-    get origin() {
-      return (this.handler.debug ? this[originError].stack : this.tagged && originStackCache.has(this.strings) ? originStackCache.get(this.strings) : originStackCache.set(this.strings, this[originError].stack).get(this.strings)) || "";
-    }
-    static get [Symbol.species]() {
-      return Promise;
-    }
-    cancel() {
-      return this.canceller && (this.canceller(this), this.canceller = null);
-    }
-    simple() {
-      this.options.simple = true;
-      this.options.prepare = false;
-      return this;
-    }
-    async readable() {
-      this.simple();
-      this.streaming = true;
-      return this;
-    }
-    async writable() {
-      this.simple();
-      this.streaming = true;
-      return this;
-    }
-    cursor(rows = 1, fn) {
-      this.options.simple = false;
-      if (typeof rows === "function") {
-        fn = rows;
-        rows = 1;
-      }
-      this.cursorRows = rows;
-      if (typeof fn === "function")
-        return this.cursorFn = fn, this;
-      let prev;
-      return {
-        [Symbol.asyncIterator]: () => ({
-          next: () => {
-            if (this.executed && !this.active)
-              return { done: true };
-            prev && prev();
-            const promise = new Promise((resolve, reject) => {
-              this.cursorFn = (value) => {
-                resolve({ value, done: false });
-                return new Promise((r) => prev = r);
-              };
-              this.resolve = () => (this.active = false, resolve({ done: true }));
-              this.reject = (x) => (this.active = false, reject(x));
-            });
-            this.execute();
-            return promise;
-          },
-          return() {
-            prev && prev(CLOSE);
-            return { done: true };
-          }
-        })
-      };
-    }
-    describe() {
-      this.options.simple = false;
-      this.onlyDescribe = this.options.prepare = true;
-      return this;
-    }
-    stream() {
-      throw new Error(".stream has been renamed to .forEach");
-    }
-    forEach(fn) {
-      this.forEachFn = fn;
-      this.handle();
-      return this;
-    }
-    raw() {
-      this.isRaw = true;
-      return this;
-    }
-    values() {
-      this.isRaw = "values";
-      return this;
-    }
-    async handle() {
-      !this.executed && (this.executed = true) && await 1 && this.handler(this);
-    }
-    execute() {
-      this.handle();
-      return this;
-    }
-    then() {
-      this.handle();
-      return super.then.apply(this, arguments);
-    }
-    catch() {
-      this.handle();
-      return super.catch.apply(this, arguments);
-    }
-    finally() {
-      this.handle();
-      return super.finally.apply(this, arguments);
-    }
-  };
-});
-
-// ../../node_modules/postgres/src/errors.js
-function connection(x, options, socket) {
-  const { host, port } = socket || options;
-  const error = Object.assign(new Error("write " + x + " " + (options.path || host + ":" + port)), {
-    code: x,
-    errno: x,
-    address: options.path || host
-  }, options.path ? {} : { port });
-  Error.captureStackTrace(error, connection);
-  return error;
-}
-function postgres(x) {
-  const error = new PostgresError(x);
-  Error.captureStackTrace(error, postgres);
-  return error;
-}
-function generic(code, message) {
-  const error = Object.assign(new Error(code + ": " + message), { code });
-  Error.captureStackTrace(error, generic);
-  return error;
-}
-function notSupported(x) {
-  const error = Object.assign(new Error(x + " (B) is not supported"), {
-    code: "MESSAGE_NOT_SUPPORTED",
-    name: x
-  });
-  Error.captureStackTrace(error, notSupported);
-  return error;
-}
-var PostgresError, Errors;
-var init_errors2 = __esm(() => {
-  PostgresError = class PostgresError extends Error {
-    constructor(x) {
-      super(x.message);
-      this.name = this.constructor.name;
-      Object.assign(this, x);
-    }
-  };
-  Errors = {
-    connection,
-    postgres,
-    generic,
-    notSupported
-  };
-});
-
-// ../../node_modules/postgres/src/types.js
-class NotTagged {
-  then() {
-    notTagged();
-  }
-  catch() {
-    notTagged();
-  }
-  finally() {
-    notTagged();
-  }
-}
-function handleValue(x, parameters, types, options) {
-  let value = x instanceof Parameter ? x.value : x;
-  if (value === undefined) {
-    x instanceof Parameter ? x.value = options.transform.undefined : value = x = options.transform.undefined;
-    if (value === undefined)
-      throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
-  }
-  return "$" + types.push(x instanceof Parameter ? (parameters.push(x.value), x.array ? x.array[x.type || inferType(x.value)] || x.type || firstIsString(x.value) : x.type) : (parameters.push(x), inferType(x)));
-}
-function stringify(q, string, value, parameters, types, options) {
-  for (let i = 1;i < q.strings.length; i++) {
-    string += stringifyValue(string, value, parameters, types, options) + q.strings[i];
-    value = q.args[i];
-  }
-  return string;
-}
-function stringifyValue(string, value, parameters, types, o) {
-  return value instanceof Builder ? value.build(string, parameters, types, o) : value instanceof Query ? fragment(value, parameters, types, o) : value instanceof Identifier ? value.value : value && value[0] instanceof Query ? value.reduce((acc, x) => acc + " " + fragment(x, parameters, types, o), "") : handleValue(value, parameters, types, o);
-}
-function fragment(q, parameters, types, options) {
-  q.fragment = true;
-  return stringify(q, q.strings[0], q.args[0], parameters, types, options);
-}
-function valuesBuilder(first, parameters, types, columns, options) {
-  return first.map((row) => "(" + columns.map((column) => stringifyValue("values", row[column], parameters, types, options)).join(",") + ")").join(",");
-}
-function values(first, rest, parameters, types, options) {
-  const multi = Array.isArray(first[0]);
-  const columns = rest.length ? rest.flat() : Object.keys(multi ? first[0] : first);
-  return valuesBuilder(multi ? first : [first], parameters, types, columns, options);
-}
-function select2(first, rest, parameters, types, options) {
-  typeof first === "string" && (first = [first].concat(rest));
-  if (Array.isArray(first))
-    return escapeIdentifiers(first, options);
-  let value;
-  const columns = rest.length ? rest.flat() : Object.keys(first);
-  return columns.map((x) => {
-    value = first[x];
-    return (value instanceof Query ? fragment(value, parameters, types, options) : value instanceof Identifier ? value.value : handleValue(value, parameters, types, options)) + " as " + escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x);
-  }).join(",");
-}
-function notTagged() {
-  throw Errors.generic("NOT_TAGGED_CALL", "Query not called as a tagged template literal");
-}
-function firstIsString(x) {
-  if (Array.isArray(x))
-    return firstIsString(x[0]);
-  return typeof x === "string" ? 1009 : 0;
-}
-function typeHandlers(types) {
-  return Object.keys(types).reduce((acc, k) => {
-    types[k].from && [].concat(types[k].from).forEach((x) => acc.parsers[x] = types[k].parse);
-    if (types[k].serialize) {
-      acc.serializers[types[k].to] = types[k].serialize;
-      types[k].from && [].concat(types[k].from).forEach((x) => acc.serializers[x] = types[k].serialize);
-    }
-    return acc;
-  }, { parsers: {}, serializers: {} });
-}
-function escapeIdentifiers(xs, { transform: { column } }) {
-  return xs.map((x) => escapeIdentifier(column.to ? column.to(x) : x)).join(",");
-}
-function arrayEscape(x) {
-  return x.replace(escapeBackslash, "\\\\").replace(escapeQuote, "\\\"");
-}
-function arrayParserLoop(s, x, parser, typarray) {
-  const xs = [];
-  const delimiter = typarray === 1020 ? ";" : ",";
-  for (;s.i < x.length; s.i++) {
-    s.char = x[s.i];
-    if (s.quoted) {
-      if (s.char === "\\") {
-        s.str += x[++s.i];
-      } else if (s.char === '"') {
-        xs.push(parser ? parser(s.str) : s.str);
-        s.str = "";
-        s.quoted = x[s.i + 1] === '"';
-        s.last = s.i + 2;
-      } else {
-        s.str += s.char;
-      }
-    } else if (s.char === '"') {
-      s.quoted = true;
-    } else if (s.char === "{") {
-      s.last = ++s.i;
-      xs.push(arrayParserLoop(s, x, parser, typarray));
-    } else if (s.char === "}") {
-      s.quoted = false;
-      s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
-      s.last = s.i + 1;
-      break;
-    } else if (s.char === delimiter && s.p !== "}" && s.p !== '"') {
-      xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i));
-      s.last = s.i + 1;
-    }
-    s.p = s.char;
-  }
-  s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i + 1)) : x.slice(s.last, s.i + 1));
-  return xs;
-}
-function createJsonTransform(fn) {
-  return function jsonTransform(x, column) {
-    return typeof x === "object" && x !== null && (column.type === 114 || column.type === 3802) ? Array.isArray(x) ? x.map((x) => jsonTransform(x, column)) : Object.entries(x).reduce((acc, [k, v]) => Object.assign(acc, { [fn(k)]: jsonTransform(v, column) }), {}) : x;
-  };
-}
-var types5, Identifier, Parameter, Builder, defaultHandlers, builders, serializers, parsers, mergeUserTypes = function(types) {
-  const user = typeHandlers(types || {});
-  return {
-    serializers: Object.assign({}, serializers, user.serializers),
-    parsers: Object.assign({}, parsers, user.parsers)
-  };
-}, escapeIdentifier = function escape(str) {
-  return '"' + str.replace(/"/g, '""').replace(/\./g, '"."') + '"';
-}, inferType = function inferType(x) {
-  return x instanceof Parameter ? x.type : x instanceof Date ? 1184 : x instanceof Uint8Array ? 17 : x === true || x === false ? 16 : typeof x === "bigint" ? 20 : Array.isArray(x) ? inferType(x[0]) : 0;
-}, escapeBackslash, escapeQuote, arraySerializer = function arraySerializer(xs, serializer, options, typarray) {
-  if (Array.isArray(xs) === false)
-    return xs;
-  if (!xs.length)
-    return "{}";
-  const first = xs[0];
-  const delimiter = typarray === 1020 ? ";" : ",";
-  if (Array.isArray(first) && !first.type)
-    return "{" + xs.map((x) => arraySerializer(x, serializer, options, typarray)).join(delimiter) + "}";
-  return "{" + xs.map((x) => {
-    if (x === undefined) {
-      x = options.transform.undefined;
-      if (x === undefined)
-        throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
-    }
-    return x === null ? "null" : '"' + arrayEscape(serializer ? serializer(x.type ? x.value : x) : "" + x) + '"';
-  }).join(delimiter) + "}";
-}, arrayParserState, arrayParser = function arrayParser(x, parser, typarray) {
-  arrayParserState.i = arrayParserState.last = 0;
-  return arrayParserLoop(arrayParserState, x, parser, typarray);
-}, toCamel = (x) => {
-  let str = x[0];
-  for (let i = 1;i < x.length; i++)
-    str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
-  return str;
-}, toPascal = (x) => {
-  let str = x[0].toUpperCase();
-  for (let i = 1;i < x.length; i++)
-    str += x[i] === "_" ? x[++i].toUpperCase() : x[i];
-  return str;
-}, toKebab = (x) => x.replace(/_/g, "-"), fromCamel = (x) => x.replace(/([A-Z])/g, "_$1").toLowerCase(), fromPascal = (x) => (x.slice(0, 1) + x.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase(), fromKebab = (x) => x.replace(/-/g, "_"), camel, pascal, kebab;
-var init_types4 = __esm(() => {
-  init_query();
-  init_errors2();
-  types5 = {
-    string: {
-      to: 25,
-      from: null,
-      serialize: (x) => "" + x
-    },
-    number: {
-      to: 0,
-      from: [21, 23, 26, 700, 701],
-      serialize: (x) => "" + x,
-      parse: (x) => +x
-    },
-    json: {
-      to: 114,
-      from: [114, 3802],
-      serialize: (x) => JSON.stringify(x),
-      parse: (x) => JSON.parse(x)
-    },
-    boolean: {
-      to: 16,
-      from: 16,
-      serialize: (x) => x === true ? "t" : "f",
-      parse: (x) => x === "t"
-    },
-    date: {
-      to: 1184,
-      from: [1082, 1114, 1184],
-      serialize: (x) => (x instanceof Date ? x : new Date(x)).toISOString(),
-      parse: (x) => new Date(x)
-    },
-    bytea: {
-      to: 17,
-      from: 17,
-      serialize: (x) => "\\x" + Buffer.from(x).toString("hex"),
-      parse: (x) => Buffer.from(x.slice(2), "hex")
-    }
-  };
-  Identifier = class Identifier extends NotTagged {
-    constructor(value) {
-      super();
-      this.value = escapeIdentifier(value);
-    }
-  };
-  Parameter = class Parameter extends NotTagged {
-    constructor(value, type, array) {
-      super();
-      this.value = value;
-      this.type = type;
-      this.array = array;
-    }
-  };
-  Builder = class Builder extends NotTagged {
-    constructor(first, rest) {
-      super();
-      this.first = first;
-      this.rest = rest;
-    }
-    build(before, parameters, types, options) {
-      const keyword = builders.map(([x, fn]) => ({ fn, i: before.search(x) })).sort((a, b) => a.i - b.i).pop();
-      return keyword.i === -1 ? escapeIdentifiers(this.first, options) : keyword.fn(this.first, this.rest, parameters, types, options);
-    }
-  };
-  defaultHandlers = typeHandlers(types5);
-  builders = Object.entries({
-    values,
-    in: (...xs) => {
-      const x = values(...xs);
-      return x === "()" ? "(null)" : x;
-    },
-    select: select2,
-    as: select2,
-    returning: select2,
-    "\\(": select2,
-    update(first, rest, parameters, types, options) {
-      return (rest.length ? rest.flat() : Object.keys(first)).map((x) => escapeIdentifier(options.transform.column.to ? options.transform.column.to(x) : x) + "=" + stringifyValue("values", first[x], parameters, types, options));
-    },
-    insert(first, rest, parameters, types, options) {
-      const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first);
-      return "(" + escapeIdentifiers(columns, options) + ")values" + valuesBuilder(Array.isArray(first) ? first : [first], parameters, types, columns, options);
-    }
-  }).map(([x, fn]) => [new RegExp("((?:^|[\\s(])" + x + "(?:$|[\\s(]))(?![\\s\\S]*\\1)", "i"), fn]);
-  serializers = defaultHandlers.serializers;
-  parsers = defaultHandlers.parsers;
-  escapeBackslash = /\\/g;
-  escapeQuote = /"/g;
-  arrayParserState = {
-    i: 0,
-    char: null,
-    str: "",
-    quoted: false,
-    last: 0
-  };
-  toCamel.column = { from: toCamel };
-  toCamel.value = { from: createJsonTransform(toCamel) };
-  fromCamel.column = { to: fromCamel };
-  camel = { ...toCamel };
-  camel.column.to = fromCamel;
-  toPascal.column = { from: toPascal };
-  toPascal.value = { from: createJsonTransform(toPascal) };
-  fromPascal.column = { to: fromPascal };
-  pascal = { ...toPascal };
-  pascal.column.to = fromPascal;
-  toKebab.column = { from: toKebab };
-  toKebab.value = { from: createJsonTransform(toKebab) };
-  fromKebab.column = { to: fromKebab };
-  kebab = { ...toKebab };
-  kebab.column.to = fromKebab;
-});
-
-// ../../node_modules/postgres/src/result.js
-var Result;
-var init_result2 = __esm(() => {
-  Result = class Result extends Array {
-    constructor() {
-      super();
-      Object.defineProperties(this, {
-        count: { value: null, writable: true },
-        state: { value: null, writable: true },
-        command: { value: null, writable: true },
-        columns: { value: null, writable: true },
-        statement: { value: null, writable: true }
-      });
-    }
-    static get [Symbol.species]() {
-      return Array;
-    }
-  };
-});
-
-// ../../node_modules/postgres/src/queue.js
-function Queue(initial = []) {
-  let xs = initial.slice();
-  let index = 0;
-  return {
-    get length() {
-      return xs.length - index;
-    },
-    remove: (x) => {
-      const index = xs.indexOf(x);
-      return index === -1 ? null : (xs.splice(index, 1), x);
-    },
-    push: (x) => (xs.push(x), x),
-    shift: () => {
-      const out = xs[index++];
-      if (index === xs.length) {
-        index = 0;
-        xs = [];
-      } else {
-        xs[index - 1] = undefined;
-      }
-      return out;
-    }
-  };
-}
-var queue_default;
-var init_queue = __esm(() => {
-  queue_default = Queue;
-});
-
-// ../../node_modules/postgres/src/bytes.js
-function fit(x) {
-  if (buffer.length - b2.i < x) {
-    const prev = buffer, length = prev.length;
-    buffer = Buffer.allocUnsafe(length + (length >> 1) + x);
-    prev.copy(buffer);
-  }
-}
-function reset3() {
-  b2.i = 0;
-  return b2;
-}
-var size = 256, buffer, messages, b2, bytes_default;
-var init_bytes = __esm(() => {
-  buffer = Buffer.allocUnsafe(size);
-  messages = "BCcDdEFfHPpQSX".split("").reduce((acc, x) => {
-    const v = x.charCodeAt(0);
-    acc[x] = () => {
-      buffer[0] = v;
-      b2.i = 5;
-      return b2;
-    };
-    return acc;
-  }, {});
-  b2 = Object.assign(reset3, messages, {
-    N: String.fromCharCode(0),
-    i: 0,
-    inc(x) {
-      b2.i += x;
-      return b2;
-    },
-    str(x) {
-      const length = Buffer.byteLength(x);
-      fit(length);
-      b2.i += buffer.write(x, b2.i, length, "utf8");
-      return b2;
-    },
-    i16(x) {
-      fit(2);
-      buffer.writeUInt16BE(x, b2.i);
-      b2.i += 2;
-      return b2;
-    },
-    i32(x, i) {
-      if (i || i === 0) {
-        buffer.writeUInt32BE(x, i);
-        return b2;
-      }
-      fit(4);
-      buffer.writeUInt32BE(x, b2.i);
-      b2.i += 4;
-      return b2;
-    },
-    z(x) {
-      fit(x);
-      buffer.fill(0, b2.i, b2.i + x);
-      b2.i += x;
-      return b2;
-    },
-    raw(x) {
-      buffer = Buffer.concat([buffer.subarray(0, b2.i), x]);
-      b2.i = buffer.length;
-      return b2;
-    },
-    end(at = 1) {
-      buffer.writeUInt32BE(b2.i - at, at);
-      const out = buffer.subarray(0, b2.i);
-      b2.i = 0;
-      buffer = Buffer.allocUnsafe(size);
-      return out;
-    }
-  });
-  bytes_default = b2;
-});
-
-// ../../node_modules/postgres/src/connection.js
-import net2 from "net";
-import tls from "tls";
-import crypto2 from "crypto";
-import Stream from "stream";
-import { performance } from "perf_hooks";
-function Connection(options, queues = {}, { onopen = noop5, onend = noop5, onclose = noop5 } = {}) {
-  const {
-    sslnegotiation,
-    ssl,
-    max,
-    user,
-    host,
-    port,
-    database,
-    parsers,
-    transform,
-    onnotice,
-    onnotify,
-    onparameter,
-    max_pipeline,
-    keep_alive,
-    backoff,
-    target_session_attrs
-  } = options;
-  const sent = queue_default(), id = uid++, backend = { pid: null, secret: null }, idleTimer = timer2(end, options.idle_timeout), lifeTimer = timer2(end, options.max_lifetime), connectTimer = timer2(connectTimedOut, options.connect_timeout);
-  let socket = null, cancelMessage, errorResponse = null, result = new Result, incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedTime = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
-  const connection = {
-    queue: queues.closed,
-    idleTimer,
-    connect(query) {
-      initial = query;
-      reconnect();
-    },
-    terminate,
-    execute,
-    cancel,
-    end,
-    count: 0,
-    id
-  };
-  queues.closed && queues.closed.push(connection);
-  return connection;
-  async function createSocket() {
-    let x;
-    try {
-      x = options.socket ? await Promise.resolve(options.socket(options)) : new net2.Socket;
-    } catch (e) {
-      error(e);
-      return;
-    }
-    x.on("error", error);
-    x.on("close", closed);
-    x.on("drain", drain);
-    return x;
-  }
-  async function cancel({ pid, secret }, resolve, 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);
-    } catch (error) {
-      reject(error);
-    }
-  }
-  function execute(q) {
-    if (terminated)
-      return queryError(q, Errors.connection("CONNECTION_DESTROYED", options));
-    if (stream)
-      return queryError(q, Errors.generic("COPY_IN_PROGRESS", "You cannot execute queries during copy"));
-    if (q.cancelled)
-      return;
-    try {
-      q.state = backend;
-      query ? sent.push(q) : (query = q, query.active = true);
-      build(q);
-      return write(toBuffer(q)) && !q.describeFirst && !q.cursorFn && sent.length < max_pipeline && (!q.options.onexecute || q.options.onexecute(connection));
-    } catch (error) {
-      sent.length === 0 && write(Sync);
-      errored(error);
-      return true;
-    }
-  }
-  function toBuffer(q) {
-    if (q.parameters.length >= 65534)
-      throw Errors.generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
-    return q.options.simple ? bytes_default().Q().str(q.statement.string + bytes_default.N).end() : q.describeFirst ? Buffer.concat([describe(q), Flush]) : q.prepare ? q.prepared ? prepared(q) : Buffer.concat([describe(q), prepared(q)]) : unnamed(q);
-  }
-  function describe(q) {
-    return Buffer.concat([
-      Parse(q.statement.string, q.parameters, q.statement.types, q.statement.name),
-      Describe("S", q.statement.name)
-    ]);
-  }
-  function prepared(q) {
-    return Buffer.concat([
-      Bind(q.parameters, q.statement.types, q.statement.name, q.cursorName),
-      q.cursorFn ? Execute("", q.cursorRows) : ExecuteUnnamed
-    ]);
-  }
-  function unnamed(q) {
-    return Buffer.concat([
-      Parse(q.statement.string, q.parameters, q.statement.types),
-      DescribeUnnamed,
-      prepared(q)
-    ]);
-  }
-  function build(q) {
-    const parameters = [], types = [];
-    const string = stringify(q, q.strings[0], q.args[0], parameters, types, options);
-    !q.tagged && q.args.forEach((x) => handleValue(x, parameters, types, options));
-    q.prepare = options.prepare && ("prepare" in q.options ? q.options.prepare : true);
-    q.string = string;
-    q.signature = q.prepare && types + string;
-    q.onlyDescribe && delete statements[q.signature];
-    q.parameters = q.parameters || parameters;
-    q.prepared = q.prepare && q.signature in statements;
-    q.describeFirst = q.onlyDescribe || parameters.length && !q.prepared;
-    q.statement = q.prepared ? statements[q.signature] : { string, types, name: q.prepare ? statementId + statementCount++ : "" };
-    typeof options.debug === "function" && options.debug(id, string, parameters, types);
-  }
-  function write(x, fn) {
-    chunk = chunk ? Buffer.concat([chunk, x]) : Buffer.from(x);
-    if (fn || chunk.length >= 1024)
-      return nextWrite(fn);
-    nextWriteTimer === null && (nextWriteTimer = setImmediate(nextWrite));
-    return true;
-  }
-  function nextWrite(fn) {
-    const x = socket.write(chunk, fn);
-    nextWriteTimer !== null && clearImmediate(nextWriteTimer);
-    chunk = nextWriteTimer = null;
-    return x;
-  }
-  function connectTimedOut() {
-    errored(Errors.connection("CONNECT_TIMEOUT", options, socket));
-    socket.destroy();
-  }
-  async function secure() {
-    if (sslnegotiation !== "direct") {
-      write(SSLRequest);
-      const canSSL = await new Promise((r) => socket.once("data", (x) => r(x[0] === 83)));
-      if (!canSSL && ssl === "prefer")
-        return connected();
-    }
-    const options = {
-      socket,
-      servername: net2.isIP(socket.host) ? undefined : socket.host
-    };
-    if (sslnegotiation === "direct")
-      options.ALPNProtocols = ["postgresql"];
-    if (ssl === "require" || ssl === "allow" || ssl === "prefer")
-      options.rejectUnauthorized = false;
-    else if (typeof ssl === "object")
-      Object.assign(options, ssl);
-    socket.removeAllListeners();
-    socket = tls.connect(options);
-    socket.on("secureConnect", connected);
-    socket.on("error", error);
-    socket.on("close", closed);
-    socket.on("drain", drain);
-  }
-  function drain() {
-    !query && onopen(connection);
-  }
-  function data(x) {
-    if (incomings) {
-      incomings.push(x);
-      remaining -= x.length;
-      if (remaining > 0)
-        return;
-    }
-    incoming = incomings ? Buffer.concat(incomings, length - remaining) : incoming.length === 0 ? x : Buffer.concat([incoming, x], incoming.length + x.length);
-    while (incoming.length > 4) {
-      length = incoming.readUInt32BE(1);
-      if (length >= incoming.length) {
-        remaining = length - incoming.length;
-        incomings = [incoming];
-        break;
-      }
-      try {
-        handle(incoming.subarray(0, length + 1));
-      } catch (e) {
-        query && (query.cursorFn || query.describeFirst) && write(Sync);
-        errored(e);
-      }
-      incoming = incoming.subarray(length + 1);
-      remaining = 0;
-      incomings = null;
-    }
-  }
-  async function connect() {
-    terminated = false;
-    backendParameters = {};
-    socket || (socket = await createSocket());
-    if (!socket)
-      return;
-    connectTimer.start();
-    if (options.socket)
-      return ssl ? secure() : connected();
-    socket.on("connect", ssl ? secure : connected);
-    if (options.path)
-      return socket.connect(options.path);
-    socket.ssl = ssl;
-    socket.connect(port[hostIndex], host[hostIndex]);
-    socket.host = host[hostIndex];
-    socket.port = port[hostIndex];
-    hostIndex = (hostIndex + 1) % port.length;
-  }
-  function reconnect() {
-    setTimeout(connect, closedTime ? Math.max(0, closedTime + delay - performance.now()) : 0);
-  }
-  function connected() {
-    try {
-      statements = {};
-      needsTypes = options.fetch_types;
-      statementId = Math.random().toString(36).slice(2);
-      statementCount = 1;
-      lifeTimer.start();
-      socket.on("data", data);
-      keep_alive && socket.setKeepAlive && socket.setKeepAlive(true, 1000 * keep_alive);
-      const s = StartupMessage();
-      write(s);
-    } catch (err) {
-      error(err);
-    }
-  }
-  function error(err) {
-    if (connection.queue === queues.connecting && options.host[retries + 1])
-      return;
-    errored(err);
-    while (sent.length)
-      queryError(sent.shift(), err);
-  }
-  function errored(err) {
-    stream && (stream.destroy(err), stream = null);
-    query && queryError(query, err);
-    initial && (queryError(initial, err), initial = null);
-  }
-  function queryError(query, err) {
-    if (query.reserve)
-      return query.reject(err);
-    if (!err || typeof err !== "object")
-      err = new Error(err);
-    "query" in err || "parameters" in err || Object.defineProperties(err, {
-      stack: { value: err.stack + query.origin.replace(/.*\n/, `
-`), enumerable: options.debug },
-      query: { value: query.string, enumerable: options.debug },
-      parameters: { value: query.parameters, enumerable: options.debug },
-      args: { value: query.args, enumerable: options.debug },
-      types: { value: query.statement && query.statement.types, enumerable: options.debug }
-    });
-    query.reject(err);
-  }
-  function end() {
-    return ending || (!connection.reserved && onend(connection), !connection.reserved && !initial && !query && sent.length === 0 ? (terminate(), new Promise((r) => socket && socket.readyState !== "closed" ? socket.once("close", r) : r())) : ending = new Promise((r) => ended = r));
-  }
-  function terminate() {
-    terminated = true;
-    if (stream || query || initial || sent.length)
-      error(Errors.connection("CONNECTION_DESTROYED", options));
-    clearImmediate(nextWriteTimer);
-    if (socket) {
-      socket.removeListener("data", data);
-      socket.removeListener("connect", connected);
-      socket.readyState === "open" && socket.end(bytes_default().X().end());
-    }
-    ended && (ended(), ending = ended = null);
-  }
-  async function closed(hadError) {
-    incoming = Buffer.alloc(0);
-    remaining = 0;
-    incomings = null;
-    clearImmediate(nextWriteTimer);
-    socket.removeListener("data", data);
-    socket.removeListener("connect", connected);
-    idleTimer.cancel();
-    lifeTimer.cancel();
-    connectTimer.cancel();
-    socket.removeAllListeners();
-    socket = null;
-    if (initial)
-      return reconnect();
-    !hadError && (query || sent.length) && error(Errors.connection("CONNECTION_CLOSED", options, socket));
-    closedTime = performance.now();
-    hadError && options.shared.retries++;
-    delay = (typeof backoff === "function" ? backoff(options.shared.retries) : backoff) * 1000;
-    onclose(connection, Errors.connection("CONNECTION_CLOSED", options, socket));
-  }
-  function handle(xs, x = xs[0]) {
-    (x === 68 ? DataRow : x === 100 ? CopyData : x === 65 ? NotificationResponse : x === 83 ? ParameterStatus : x === 90 ? ReadyForQuery : x === 67 ? CommandComplete : x === 50 ? BindComplete : x === 49 ? ParseComplete : x === 116 ? ParameterDescription : x === 84 ? RowDescription : x === 82 ? Authentication : x === 110 ? NoData : x === 75 ? BackendKeyData : x === 69 ? ErrorResponse : x === 115 ? PortalSuspended : x === 51 ? CloseComplete : x === 71 ? CopyInResponse : x === 78 ? NoticeResponse : x === 72 ? CopyOutResponse : x === 99 ? CopyDone : x === 73 ? EmptyQueryResponse : x === 86 ? FunctionCallResponse : x === 118 ? NegotiateProtocolVersion : x === 87 ? CopyBothResponse : UnknownMessage)(xs);
-  }
-  function DataRow(x) {
-    let index = 7;
-    let length;
-    let column;
-    let value;
-    const row = query.isRaw ? new Array(query.statement.columns.length) : {};
-    for (let i = 0;i < query.statement.columns.length; i++) {
-      column = query.statement.columns[i];
-      length = x.readInt32BE(index);
-      index += 4;
-      value = length === -1 ? null : query.isRaw === true ? x.subarray(index, index += length) : column.parser === undefined ? x.toString("utf8", index, index += length) : column.parser.array === true ? column.parser(x.toString("utf8", index + 1, index += length)) : column.parser(x.toString("utf8", index, index += length));
-      query.isRaw ? row[i] = query.isRaw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
-    }
-    query.forEachFn ? query.forEachFn(transform.row.from ? transform.row.from(row) : row, result) : result[rows++] = transform.row.from ? transform.row.from(row) : row;
-  }
-  function ParameterStatus(x) {
-    const [k, v] = x.toString("utf8", 5, x.length - 1).split(bytes_default.N);
-    backendParameters[k] = v;
-    if (options.parameters[k] !== v) {
-      options.parameters[k] = v;
-      onparameter && onparameter(k, v);
-    }
-  }
-  function ReadyForQuery(x) {
-    if (query) {
-      if (errorResponse) {
-        query.retried ? errored(query.retried) : query.prepared && retryRoutines.has(errorResponse.routine) ? retry(query, errorResponse) : errored(errorResponse);
-      } else {
-        query.resolve(results || result);
-      }
-    } else if (errorResponse) {
-      errored(errorResponse);
-    }
-    query = results = errorResponse = null;
-    result = new Result;
-    connectTimer.cancel();
-    if (initial) {
-      if (target_session_attrs) {
-        if (!backendParameters.in_hot_standby || !backendParameters.default_transaction_read_only)
-          return fetchState();
-        else if (tryNext(target_session_attrs, backendParameters))
-          return terminate();
-      }
-      if (needsTypes) {
-        initial.reserve && (initial = null);
-        return fetchArrayTypes();
-      }
-      initial && !initial.reserve && execute(initial);
-      options.shared.retries = retries = 0;
-      initial = null;
-      return;
-    }
-    while (sent.length && (query = sent.shift()) && (query.active = true, query.cancelled))
-      Connection(options).cancel(query.state, query.cancelled.resolve, query.cancelled.reject);
-    if (query)
-      return;
-    connection.reserved ? !connection.reserved.release && x[5] === 73 ? ending ? terminate() : (connection.reserved = null, onopen(connection)) : connection.reserved() : ending ? terminate() : onopen(connection);
-  }
-  function CommandComplete(x) {
-    rows = 0;
-    for (let i = x.length - 1;i > 0; i--) {
-      if (x[i] === 32 && x[i + 1] < 58 && result.count === null)
-        result.count = +x.toString("utf8", i + 1, x.length - 1);
-      if (x[i - 1] >= 65) {
-        result.command = x.toString("utf8", 5, i);
-        result.state = backend;
-        break;
-      }
-    }
-    final && (final(), final = null);
-    if (result.command === "BEGIN" && max !== 1 && !connection.reserved)
-      return errored(Errors.generic("UNSAFE_TRANSACTION", "Only use sql.begin, sql.reserved or max: 1"));
-    if (query.options.simple)
-      return BindComplete();
-    if (query.cursorFn) {
-      result.count && query.cursorFn(result);
-      write(Sync);
-    }
-  }
-  function ParseComplete() {
-    query.parsing = false;
-  }
-  function BindComplete() {
-    !result.statement && (result.statement = query.statement);
-    result.columns = query.statement.columns;
-  }
-  function ParameterDescription(x) {
-    const length = x.readUInt16BE(5);
-    for (let i = 0;i < length; ++i)
-      !query.statement.types[i] && (query.statement.types[i] = x.readUInt32BE(7 + i * 4));
-    query.prepare && (statements[query.signature] = query.statement);
-    query.describeFirst && !query.onlyDescribe && (write(prepared(query)), query.describeFirst = false);
-  }
-  function RowDescription(x) {
-    if (result.command) {
-      results = results || [result];
-      results.push(result = new Result);
-      result.count = null;
-      query.statement.columns = null;
-    }
-    const length = x.readUInt16BE(5);
-    let index = 7;
-    let start;
-    query.statement.columns = Array(length);
-    for (let i = 0;i < length; ++i) {
-      start = index;
-      while (x[index++] !== 0)
-        ;
-      const table = x.readUInt32BE(index);
-      const number = x.readUInt16BE(index + 4);
-      const type = x.readUInt32BE(index + 6);
-      query.statement.columns[i] = {
-        name: transform.column.from ? transform.column.from(x.toString("utf8", start, index - 1)) : x.toString("utf8", start, index - 1),
-        parser: parsers[type],
-        table,
-        number,
-        type
-      };
-      index += 18;
-    }
-    result.statement = query.statement;
-    if (query.onlyDescribe)
-      return query.resolve(query.statement), write(Sync);
-  }
-  async function Authentication(x, type = x.readUInt32BE(5)) {
-    (type === 3 ? AuthenticationCleartextPassword : type === 5 ? AuthenticationMD5Password : type === 10 ? SASL : type === 11 ? SASLContinue : type === 12 ? SASLFinal : type !== 0 ? UnknownAuth : noop5)(x, type);
-  }
-  async function AuthenticationCleartextPassword() {
-    const payload = await Pass();
-    write(bytes_default().p().str(payload).z(1).end());
-  }
-  async function AuthenticationMD5Password(x) {
-    const payload = "md5" + await md5(Buffer.concat([
-      Buffer.from(await md5(await Pass() + user)),
-      x.subarray(9)
-    ]));
-    write(bytes_default().p().str(payload).z(1).end());
-  }
-  async function SASL() {
-    nonce = (await crypto2.randomBytes(18)).toString("base64");
-    bytes_default().p().str("SCRAM-SHA-256" + bytes_default.N);
-    const i = bytes_default.i;
-    write(bytes_default.inc(4).str("n,,n=*,r=" + nonce).i32(bytes_default.i - i - 4, i).end());
-  }
-  async function SASLContinue(x) {
-    const res = x.toString("utf8", 9).split(",").reduce((acc, x) => (acc[x[0]] = x.slice(2), acc), {});
-    const saltedPassword = await crypto2.pbkdf2Sync(await Pass(), Buffer.from(res.s, "base64"), parseInt(res.i), 32, "sha256");
-    const clientKey = await hmac(saltedPassword, "Client Key");
-    const auth = "n=*,r=" + nonce + "," + "r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
-    serverSignature = (await hmac(await hmac(saltedPassword, "Server Key"), auth)).toString("base64");
-    const payload = "c=biws,r=" + res.r + ",p=" + xor(clientKey, Buffer.from(await hmac(await sha256(clientKey), auth))).toString("base64");
-    write(bytes_default().p().str(payload).end());
-  }
-  function SASLFinal(x) {
-    if (x.toString("utf8", 9).split(bytes_default.N, 1)[0].slice(2) === serverSignature)
-      return;
-    errored(Errors.generic("SASL_SIGNATURE_MISMATCH", "The server did not return the correct signature"));
-    socket.destroy();
-  }
-  function Pass() {
-    return Promise.resolve(typeof options.pass === "function" ? options.pass() : options.pass);
-  }
-  function NoData() {
-    result.statement = query.statement;
-    result.statement.columns = [];
-    if (query.onlyDescribe)
-      return query.resolve(query.statement), write(Sync);
-  }
-  function BackendKeyData(x) {
-    backend.pid = x.readUInt32BE(5);
-    backend.secret = x.readUInt32BE(9);
-  }
-  async function fetchArrayTypes() {
-    needsTypes = false;
-    const types = await new Query([`
-      select b.oid, b.typarray
-      from pg_catalog.pg_type a
-      left join pg_catalog.pg_type b on b.oid = a.typelem
-      where a.typcategory = 'A'
-      group by b.oid, b.typarray
-      order by b.oid
-    `], [], execute);
-    types.forEach(({ oid, typarray }) => addArrayType(oid, typarray));
-  }
-  function addArrayType(oid, typarray) {
-    if (!!options.parsers[typarray] && !!options.serializers[typarray])
-      return;
-    const parser = options.parsers[oid];
-    options.shared.typeArrayMap[oid] = typarray;
-    options.parsers[typarray] = (xs) => arrayParser(xs, parser, typarray);
-    options.parsers[typarray].array = true;
-    options.serializers[typarray] = (xs) => arraySerializer(xs, options.serializers[oid], options, typarray);
-  }
-  function tryNext(x, xs) {
-    return x === "read-write" && xs.default_transaction_read_only === "on" || x === "read-only" && xs.default_transaction_read_only === "off" || x === "primary" && xs.in_hot_standby === "on" || x === "standby" && xs.in_hot_standby === "off" || x === "prefer-standby" && xs.in_hot_standby === "off" && options.host[retries];
-  }
-  function fetchState() {
-    const query = new Query([`
-      show transaction_read_only;
-      select pg_catalog.pg_is_in_recovery()
-    `], [], execute, null, { simple: true });
-    query.resolve = ([[a], [b]]) => {
-      backendParameters.default_transaction_read_only = a.transaction_read_only;
-      backendParameters.in_hot_standby = b.pg_is_in_recovery ? "on" : "off";
-    };
-    query.execute();
-  }
-  function ErrorResponse(x) {
-    if (query) {
-      (query.cursorFn || query.describeFirst) && write(Sync);
-      errorResponse = Errors.postgres(parseError(x));
-    } else {
-      errored(Errors.postgres(parseError(x)));
-    }
-  }
-  function retry(q, error) {
-    delete statements[q.signature];
-    q.retried = error;
-    execute(q);
-  }
-  function NotificationResponse(x) {
-    if (!onnotify)
-      return;
-    let index = 9;
-    while (x[index++] !== 0)
-      ;
-    onnotify(x.toString("utf8", 9, index - 1), x.toString("utf8", index, x.length - 1));
-  }
-  async function PortalSuspended() {
-    try {
-      const x = await Promise.resolve(query.cursorFn(result));
-      rows = 0;
-      x === CLOSE ? write(Close(query.portal)) : (result = new Result, write(Execute("", query.cursorRows)));
-    } catch (err) {
-      write(Sync);
-      query.reject(err);
-    }
-  }
-  function CloseComplete() {
-    result.count && query.cursorFn(result);
-    query.resolve(result);
-  }
-  function CopyInResponse() {
-    stream = new Stream.Writable({
-      autoDestroy: true,
-      write(chunk, encoding, callback) {
-        socket.write(bytes_default().d().raw(chunk).end(), callback);
-      },
-      destroy(error, callback) {
-        callback(error);
-        socket.write(bytes_default().f().str(error + bytes_default.N).end());
-        stream = null;
-      },
-      final(callback) {
-        socket.write(bytes_default().c().end());
-        final = callback;
-        stream = null;
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyOutResponse() {
-    stream = new Stream.Readable({
-      read() {
-        socket.resume();
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyBothResponse() {
-    stream = new Stream.Duplex({
-      autoDestroy: true,
-      read() {
-        socket.resume();
-      },
-      write(chunk, encoding, callback) {
-        socket.write(bytes_default().d().raw(chunk).end(), callback);
-      },
-      destroy(error, callback) {
-        callback(error);
-        socket.write(bytes_default().f().str(error + bytes_default.N).end());
-        stream = null;
-      },
-      final(callback) {
-        socket.write(bytes_default().c().end());
-        final = callback;
-      }
-    });
-    query.resolve(stream);
-  }
-  function CopyData(x) {
-    stream && (stream.push(x.subarray(5)) || socket.pause());
-  }
-  function CopyDone() {
-    stream && stream.push(null);
-    stream = null;
-  }
-  function NoticeResponse(x) {
-    onnotice ? onnotice(parseError(x)) : console.log(parseError(x));
-  }
-  function EmptyQueryResponse() {}
-  function FunctionCallResponse() {
-    errored(Errors.notSupported("FunctionCallResponse"));
-  }
-  function NegotiateProtocolVersion() {
-    errored(Errors.notSupported("NegotiateProtocolVersion"));
-  }
-  function UnknownMessage(x) {
-    console.error("Postgres.js : Unknown Message:", x[0]);
-  }
-  function UnknownAuth(x, type) {
-    console.error("Postgres.js : Unknown Auth:", type);
-  }
-  function Bind(parameters, types, statement = "", portal = "") {
-    let prev, type;
-    bytes_default().B().str(portal + bytes_default.N).str(statement + bytes_default.N).i16(0).i16(parameters.length);
-    parameters.forEach((x, i) => {
-      if (x === null)
-        return bytes_default.i32(4294967295);
-      type = types[i];
-      parameters[i] = x = type in options.serializers ? options.serializers[type](x) : "" + x;
-      prev = bytes_default.i;
-      bytes_default.inc(4).str(x).i32(bytes_default.i - prev - 4, prev);
-    });
-    bytes_default.i16(0);
-    return bytes_default.end();
-  }
-  function Parse(str, parameters, types, name = "") {
-    bytes_default().P().str(name + bytes_default.N).str(str + bytes_default.N).i16(parameters.length);
-    parameters.forEach((x, i) => bytes_default.i32(types[i] || 0));
-    return bytes_default.end();
-  }
-  function Describe(x, name = "") {
-    return bytes_default().D().str(x).str(name + bytes_default.N).end();
-  }
-  function Execute(portal = "", rows = 0) {
-    return Buffer.concat([
-      bytes_default().E().str(portal + bytes_default.N).i32(rows).end(),
-      Flush
-    ]);
-  }
-  function Close(portal = "") {
-    return Buffer.concat([
-      bytes_default().C().str("P").str(portal + bytes_default.N).end(),
-      bytes_default().S().end()
-    ]);
-  }
-  function StartupMessage() {
-    return cancelMessage || bytes_default().inc(4).i16(3).z(2).str(Object.entries(Object.assign({
-      user,
-      database,
-      client_encoding: "UTF8"
-    }, options.connection)).filter(([, v]) => v).map(([k, v]) => k + bytes_default.N + v).join(bytes_default.N)).z(2).end(0);
-  }
-}
-function parseError(x) {
-  const error = {};
-  let start = 5;
-  for (let i = 5;i < x.length - 1; i++) {
-    if (x[i] === 0) {
-      error[errorFields[x[start]]] = x.toString("utf8", start + 1, i);
-      start = i + 1;
-    }
-  }
-  return error;
-}
-function md5(x) {
-  return crypto2.createHash("md5").update(x).digest("hex");
-}
-function hmac(key, x) {
-  return crypto2.createHmac("sha256", key).update(x).digest();
-}
-function sha256(x) {
-  return crypto2.createHash("sha256").update(x).digest();
-}
-function xor(a, b) {
-  const length = Math.max(a.length, b.length);
-  const buffer = Buffer.allocUnsafe(length);
-  for (let i = 0;i < length; i++)
-    buffer[i] = a[i] ^ b[i];
-  return buffer;
-}
-function timer2(fn, seconds) {
-  seconds = typeof seconds === "function" ? seconds() : seconds;
-  if (!seconds)
-    return { cancel: noop5, start: noop5 };
-  let timer;
-  return {
-    cancel() {
-      timer && (clearTimeout(timer), timer = null);
-    },
-    start() {
-      timer && clearTimeout(timer);
-      timer = setTimeout(done, seconds * 1000, arguments);
-    }
-  };
-  function done(args) {
-    fn.apply(null, args);
-    timer = null;
-  }
-}
-var connection_default, uid = 1, Sync, Flush, SSLRequest, ExecuteUnnamed, DescribeUnnamed, noop5 = () => {}, retryRoutines, errorFields;
-var init_connection = __esm(() => {
-  init_types4();
-  init_errors2();
-  init_result2();
-  init_queue();
-  init_query();
-  init_bytes();
-  connection_default = Connection;
-  Sync = bytes_default().S().end();
-  Flush = bytes_default().H().end();
-  SSLRequest = bytes_default().i32(8).i32(80877103).end(8);
-  ExecuteUnnamed = Buffer.concat([bytes_default().E().str(bytes_default.N).i32(0).end(), Sync]);
-  DescribeUnnamed = bytes_default().D().str("S").str(bytes_default.N).end();
-  retryRoutines = new Set([
-    "FetchPreparedStatement",
-    "RevalidateCachedQuery",
-    "transformAssignedExpr"
-  ]);
-  errorFields = {
-    83: "severity_local",
-    86: "severity",
-    67: "code",
-    77: "message",
-    68: "detail",
-    72: "hint",
-    80: "position",
-    112: "internal_position",
-    113: "internal_query",
-    87: "where",
-    115: "schema_name",
-    116: "table_name",
-    99: "column_name",
-    100: "data type_name",
-    110: "constraint_name",
-    70: "file",
-    76: "line",
-    82: "routine"
-  };
-});
-
-// ../../node_modules/postgres/src/subscribe.js
-function Subscribe(postgres, options) {
-  const subscribers = new Map, slot = "postgresjs_" + Math.random().toString(36).slice(2), state = {};
-  let connection, stream, ended = false;
-  const sql = subscribe.sql = postgres({
-    ...options,
-    transform: { column: {}, value: {}, row: {} },
-    max: 1,
-    fetch_types: false,
-    idle_timeout: null,
-    max_lifetime: null,
-    connection: {
-      ...options.connection,
-      replication: "database"
-    },
-    onclose: async function() {
-      if (ended)
-        return;
-      stream = null;
-      state.pid = state.secret = undefined;
-      connected(await init(sql, slot, options.publications));
-      subscribers.forEach((event) => event.forEach(({ onsubscribe }) => onsubscribe()));
-    },
-    no_subscribe: true
-  });
-  const { end, close } = sql;
-  sql.end = async () => {
-    ended = true;
-    stream && await new Promise((r) => (stream.once("close", r), stream.end()));
-    return end();
-  };
-  sql.close = async () => {
-    stream && await new Promise((r) => (stream.once("close", r), stream.end()));
-    return close();
-  };
-  return subscribe;
-  async function subscribe(event, fn, onsubscribe = noop6, onerror = noop6) {
-    event = parseEvent(event);
-    if (!connection)
-      connection = init(sql, slot, options.publications);
-    const subscriber = { fn, onsubscribe };
-    const fns = subscribers.has(event) ? subscribers.get(event).add(subscriber) : subscribers.set(event, new Set([subscriber])).get(event);
-    const unsubscribe = () => {
-      fns.delete(subscriber);
-      fns.size === 0 && subscribers.delete(event);
-    };
-    return connection.then((x) => {
-      connected(x);
-      onsubscribe();
-      stream && stream.on("error", onerror);
-      return { unsubscribe, state, sql };
-    });
-  }
-  function connected(x) {
-    stream = x.stream;
-    state.pid = x.state.pid;
-    state.secret = x.state.secret;
-  }
-  async function init(sql, slot, publications) {
-    if (!publications)
-      throw new Error("Missing publication names");
-    const xs = await sql.unsafe(`CREATE_REPLICATION_SLOT ${slot} TEMPORARY LOGICAL pgoutput NOEXPORT_SNAPSHOT`);
-    const [x] = xs;
-    const stream = await sql.unsafe(`START_REPLICATION SLOT ${slot} LOGICAL ${x.consistent_point} (proto_version '1', publication_names '${publications}')`).writable();
-    const state = {
-      lsn: Buffer.concat(x.consistent_point.split("/").map((x) => Buffer.from(("00000000" + x).slice(-8), "hex")))
-    };
-    stream.on("data", data);
-    stream.on("error", error);
-    stream.on("close", sql.close);
-    return { stream, state: xs.state };
-    function error(e) {
-      console.error("Unexpected error during logical streaming - reconnecting", e);
-    }
-    function data(x) {
-      if (x[0] === 119) {
-        parse(x.subarray(25), state, sql.options.parsers, handle, options.transform);
-      } else if (x[0] === 107 && x[17]) {
-        state.lsn = x.subarray(1, 9);
-        pong();
-      }
-    }
-    function handle(a, b) {
-      const path = b.relation.schema + "." + b.relation.table;
-      call("*", a, b);
-      call("*:" + path, a, b);
-      b.relation.keys.length && call("*:" + path + "=" + b.relation.keys.map((x) => a[x.name]), a, b);
-      call(b.command, a, b);
-      call(b.command + ":" + path, a, b);
-      b.relation.keys.length && call(b.command + ":" + path + "=" + b.relation.keys.map((x) => a[x.name]), a, b);
-    }
-    function pong() {
-      const x = Buffer.alloc(34);
-      x[0] = 114;
-      x.fill(state.lsn, 1);
-      x.writeBigInt64BE(BigInt(Date.now() - Date.UTC(2000, 0, 1)) * BigInt(1000), 25);
-      stream.write(x);
-    }
-  }
-  function call(x, a, b) {
-    subscribers.has(x) && subscribers.get(x).forEach(({ fn }) => fn(a, b, x));
-  }
-}
-function Time(x) {
-  return new Date(Date.UTC(2000, 0, 1) + Number(x / BigInt(1000)));
-}
-function parse(x, state, parsers, handle, transform) {
-  const char = (acc, [k, v]) => (acc[k.charCodeAt(0)] = v, acc);
-  Object.entries({
-    R: (x) => {
-      let i = 1;
-      const r = state[x.readUInt32BE(i)] = {
-        schema: x.toString("utf8", i += 4, i = x.indexOf(0, i)) || "pg_catalog",
-        table: x.toString("utf8", i + 1, i = x.indexOf(0, i + 1)),
-        columns: Array(x.readUInt16BE(i += 2)),
-        keys: []
-      };
-      i += 2;
-      let columnIndex = 0, column;
-      while (i < x.length) {
-        column = r.columns[columnIndex++] = {
-          key: x[i++],
-          name: transform.column.from ? transform.column.from(x.toString("utf8", i, i = x.indexOf(0, i))) : x.toString("utf8", i, i = x.indexOf(0, i)),
-          type: x.readUInt32BE(i += 1),
-          parser: parsers[x.readUInt32BE(i)],
-          atttypmod: x.readUInt32BE(i += 4)
-        };
-        column.key && r.keys.push(column);
-        i += 4;
-      }
-    },
-    Y: () => {},
-    O: () => {},
-    B: (x) => {
-      state.date = Time(x.readBigInt64BE(9));
-      state.lsn = x.subarray(1, 9);
-    },
-    I: (x) => {
-      let i = 1;
-      const relation = state[x.readUInt32BE(i)];
-      const { row } = tuples(x, relation.columns, i += 7, transform);
-      handle(row, {
-        command: "insert",
-        relation
-      });
-    },
-    D: (x) => {
-      let i = 1;
-      const relation = state[x.readUInt32BE(i)];
-      i += 4;
-      const key = x[i] === 75;
-      handle(key || x[i] === 79 ? tuples(x, relation.columns, i += 3, transform).row : null, {
-        command: "delete",
-        relation,
-        key
-      });
-    },
-    U: (x) => {
-      let i = 1;
-      const relation = state[x.readUInt32BE(i)];
-      i += 4;
-      const key = x[i] === 75;
-      const xs = key || x[i] === 79 ? tuples(x, relation.columns, i += 3, transform) : null;
-      xs && (i = xs.i);
-      const { row } = tuples(x, relation.columns, i + 3, transform);
-      handle(row, {
-        command: "update",
-        relation,
-        key,
-        old: xs && xs.row
-      });
-    },
-    T: () => {},
-    C: () => {}
-  }).reduce(char, {})[x[0]](x);
-}
-function tuples(x, columns, xi, transform) {
-  let type, column, value;
-  const row = transform.raw ? new Array(columns.length) : {};
-  for (let i = 0;i < columns.length; i++) {
-    type = x[xi++];
-    column = columns[i];
-    value = type === 110 ? null : type === 117 ? undefined : column.parser === undefined ? x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)) : column.parser.array === true ? column.parser(x.toString("utf8", xi + 5, xi += 4 + x.readUInt32BE(xi))) : column.parser(x.toString("utf8", xi + 4, xi += 4 + x.readUInt32BE(xi)));
-    transform.raw ? row[i] = transform.raw === true ? value : transform.value.from ? transform.value.from(value, column) : value : row[column.name] = transform.value.from ? transform.value.from(value, column) : value;
-  }
-  return { i: xi, row: transform.row.from ? transform.row.from(row) : row };
-}
-function parseEvent(x) {
-  const xs = x.match(/^(\*|insert|update|delete)?:?([^.]+?\.?[^=]+)?=?(.+)?/i) || [];
-  if (!xs)
-    throw new Error("Malformed subscribe pattern: " + x);
-  const [, command, path, key] = xs;
-  return (command || "*") + (path ? ":" + (path.indexOf(".") === -1 ? "public." + path : path) : "") + (key ? "=" + key : "");
-}
-var noop6 = () => {};
-
-// ../../node_modules/postgres/src/large.js
-import Stream2 from "stream";
-function largeObject(sql, oid, mode = 131072 | 262144) {
-  return new Promise(async (resolve, reject) => {
-    await sql.begin(async (sql) => {
-      let finish;
-      !oid && ([{ oid }] = await sql`select lo_creat(-1) as oid`);
-      const [{ fd }] = await sql`select lo_open(${oid}, ${mode}) as fd`;
-      const lo = {
-        writable,
-        readable,
-        close: () => sql`select lo_close(${fd})`.then(finish),
-        tell: () => sql`select lo_tell64(${fd})`,
-        read: (x) => sql`select loread(${fd}, ${x}) as data`,
-        write: (x) => sql`select lowrite(${fd}, ${x})`,
-        truncate: (x) => sql`select lo_truncate64(${fd}, ${x})`,
-        seek: (x, whence = 0) => sql`select lo_lseek64(${fd}, ${x}, ${whence})`,
-        size: () => sql`
-          select
-            lo_lseek64(${fd}, location, 0) as position,
-            seek.size
-          from (
-            select
-              lo_lseek64($1, 0, 2) as size,
-              tell.location
-            from (select lo_tell64($1) as location) tell
-          ) seek
-        `
-      };
-      resolve(lo);
-      return new Promise(async (r) => finish = r);
-      async function readable({
-        highWaterMark = 2048 * 8,
-        start = 0,
-        end = Infinity
-      } = {}) {
-        let max = end - start;
-        start && await lo.seek(start);
-        return new Stream2.Readable({
-          highWaterMark,
-          async read(size) {
-            const l = size > max ? size - max : size;
-            max -= size;
-            const [{ data }] = await lo.read(l);
-            this.push(data);
-            if (data.length < size)
-              this.push(null);
-          }
-        });
-      }
-      async function writable({
-        highWaterMark = 2048 * 8,
-        start = 0
-      } = {}) {
-        start && await lo.seek(start);
-        return new Stream2.Writable({
-          highWaterMark,
-          write(chunk, encoding, callback) {
-            lo.write(chunk).then(() => callback(), callback);
-          }
-        });
-      }
-    }).catch(reject);
-  });
-}
-var init_large = () => {};
-
-// ../../node_modules/postgres/src/index.js
-import os4 from "os";
-import fs7 from "fs";
-function Postgres(a, b) {
-  const options = parseOptions(a, b), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
-  let ending = false;
-  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open, busy, full };
-  const connections = [...Array(options.max)].map(() => connection_default(options, queues, { onopen, onend, onclose }));
-  const sql = Sql(handler);
-  Object.assign(sql, {
-    get parameters() {
-      return options.parameters;
-    },
-    largeObject: largeObject.bind(null, sql),
-    subscribe,
-    CLOSE,
-    END: CLOSE,
-    PostgresError,
-    options,
-    reserve,
-    listen,
-    begin,
-    close,
-    end
-  });
-  return sql;
-  function Sql(handler) {
-    handler.debug = options.debug;
-    Object.entries(options.types).reduce((acc, [name, type]) => {
-      acc[name] = (x) => new Parameter(x, type.to);
-      return acc;
-    }, typed);
-    Object.assign(sql, {
-      types: typed,
-      typed,
-      unsafe,
-      notify,
-      array,
-      json,
-      file
-    });
-    return sql;
-    function typed(value, type) {
-      return new Parameter(value, type);
-    }
-    function sql(strings, ...args) {
-      const query = strings && Array.isArray(strings.raw) ? new Query(strings, args, handler, cancel) : typeof strings === "string" && !args.length ? new Identifier(options.transform.column.to ? options.transform.column.to(strings) : strings) : new Builder(strings, args);
-      return query;
-    }
-    function unsafe(string, args = [], options = {}) {
-      arguments.length === 2 && !Array.isArray(args) && (options = args, args = []);
-      const query = new Query([string], args, handler, cancel, {
-        prepare: false,
-        ...options,
-        simple: "simple" in options ? options.simple : args.length === 0
-      });
-      return query;
-    }
-    function file(path, args = [], options = {}) {
-      arguments.length === 2 && !Array.isArray(args) && (options = args, args = []);
-      const query = new Query([], args, (query) => {
-        fs7.readFile(path, "utf8", (err, string) => {
-          if (err)
-            return query.reject(err);
-          query.strings = [string];
-          handler(query);
-        });
-      }, cancel, {
-        ...options,
-        simple: "simple" in options ? options.simple : args.length === 0
-      });
-      return query;
-    }
-  }
-  async function listen(name, fn, onlisten) {
-    const listener = { fn, onlisten };
-    const sql = listen.sql || (listen.sql = Postgres({
-      ...options,
-      max: 1,
-      idle_timeout: null,
-      max_lifetime: null,
-      fetch_types: false,
-      onclose() {
-        Object.entries(listen.channels).forEach(([name, { listeners }]) => {
-          delete listen.channels[name];
-          Promise.all(listeners.map((l) => listen(name, l.fn, l.onlisten).catch(() => {})));
-        });
-      },
-      onnotify(c, x) {
-        c in listen.channels && listen.channels[c].listeners.forEach((l) => l.fn(x));
-      }
-    }));
-    const channels = listen.channels || (listen.channels = {}), exists = name in channels;
-    if (exists) {
-      channels[name].listeners.push(listener);
-      const result = await channels[name].result;
-      listener.onlisten && listener.onlisten();
-      return { state: result.state, unlisten };
-    }
-    channels[name] = { result: sql`listen ${sql.unsafe('"' + name.replace(/"/g, '""') + '"')}`, listeners: [listener] };
-    const result = await channels[name].result;
-    listener.onlisten && listener.onlisten();
-    return { state: result.state, unlisten };
-    async function unlisten() {
-      if (name in channels === false)
-        return;
-      channels[name].listeners = channels[name].listeners.filter((x) => x !== listener);
-      if (channels[name].listeners.length)
-        return;
-      delete channels[name];
-      return sql`unlisten ${sql.unsafe('"' + name.replace(/"/g, '""') + '"')}`;
-    }
-  }
-  async function notify(channel, payload) {
-    return await sql`select pg_notify(${channel}, ${"" + payload})`;
-  }
-  async function reserve() {
-    const queue = queue_default();
-    const c = open.length ? open.shift() : await new Promise((resolve, reject) => {
-      const query = { reserve: resolve, reject };
-      queries.push(query);
-      closed.length && connect(closed.shift(), query);
-    });
-    move(c, reserved);
-    c.reserved = () => queue.length ? c.execute(queue.shift()) : move(c, reserved);
-    c.reserved.release = true;
-    const sql = Sql(handler);
-    sql.release = () => {
-      c.reserved = null;
-      onopen(c);
-    };
-    return sql;
-    function handler(q) {
-      c.queue === full ? queue.push(q) : c.execute(q) || move(c, full);
-    }
-  }
-  async function begin(options, fn) {
-    !fn && (fn = options, options = "");
-    const queries = queue_default();
-    let savepoints = 0, connection, prepare = null;
-    try {
-      await sql.unsafe("begin " + options.replace(/[^a-z ]/ig, ""), [], { onexecute }).execute();
-      return await Promise.race([
-        scope(connection, fn),
-        new Promise((_, reject) => connection.onclose = reject)
-      ]);
-    } catch (error) {
-      throw error;
-    }
-    async function scope(c, fn, name) {
-      const sql = Sql(handler);
-      sql.savepoint = savepoint;
-      sql.prepare = (x) => prepare = x.replace(/[^a-z0-9$-_. ]/gi);
-      let uncaughtError, result;
-      name && await sql`savepoint ${sql(name)}`;
-      try {
-        result = await new Promise((resolve, reject) => {
-          const x = fn(sql);
-          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve, reject);
-        });
-        if (uncaughtError)
-          throw uncaughtError;
-      } catch (e) {
-        await (name ? sql`rollback to ${sql(name)}` : sql`rollback`);
-        throw e instanceof PostgresError && e.code === "25P02" && uncaughtError || e;
-      }
-      if (!name) {
-        prepare ? await sql`prepare transaction '${sql.unsafe(prepare)}'` : await sql`commit`;
-      }
-      return result;
-      function savepoint(name, fn) {
-        if (name && Array.isArray(name.raw))
-          return savepoint((sql) => sql.apply(sql, arguments));
-        arguments.length === 1 && (fn = name, name = null);
-        return scope(c, fn, "s" + savepoints++ + (name ? "_" + name : ""));
-      }
-      function handler(q) {
-        q.catch((e) => uncaughtError || (uncaughtError = e));
-        c.queue === full ? queries.push(q) : c.execute(q) || move(c, full);
-      }
-    }
-    function onexecute(c) {
-      connection = c;
-      move(c, reserved);
-      c.reserved = () => queries.length ? c.execute(queries.shift()) : move(c, reserved);
-    }
-  }
-  function move(c, queue) {
-    c.queue.remove(c);
-    queue.push(c);
-    c.queue = queue;
-    queue === open ? c.idleTimer.start() : c.idleTimer.cancel();
-    return c;
-  }
-  function json(x) {
-    return new Parameter(x, 3802);
-  }
-  function array(x, type) {
-    if (!Array.isArray(x))
-      return array(Array.from(arguments));
-    return new Parameter(x, type || (x.length ? inferType(x) || 25 : 0), options.shared.typeArrayMap);
-  }
-  function handler(query) {
-    if (ending)
-      return query.reject(Errors.connection("CONNECTION_ENDED", options, options));
-    if (open.length)
-      return go(open.shift(), query);
-    if (closed.length)
-      return connect(closed.shift(), query);
-    busy.length ? go(busy.shift(), query) : queries.push(query);
-  }
-  function go(c, query) {
-    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());
-    });
-  }
-  async function end({ timeout = null } = {}) {
-    if (ending)
-      return ending;
-    await 1;
-    let timer;
-    return ending = Promise.race([
-      new Promise((r) => timeout !== null && (timer = setTimeout(destroy, timeout * 1000, r))),
-      Promise.all(connections.map((c) => c.end()).concat(listen.sql ? listen.sql.end({ timeout: 0 }) : [], subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []))
-    ]).then(() => clearTimeout(timer));
-  }
-  async function close() {
-    await Promise.all(connections.map((c) => c.end()));
-  }
-  async function destroy(resolve) {
-    await Promise.all(connections.map((c) => c.terminate()));
-    while (queries.length)
-      queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
-    resolve();
-  }
-  function connect(c, query) {
-    move(c, connecting);
-    c.connect(query);
-    return c;
-  }
-  function onend(c) {
-    move(c, ended);
-  }
-  function onopen(c) {
-    if (queries.length === 0)
-      return move(c, open);
-    let max = Math.ceil(queries.length / (connecting.length + 1)), ready = true;
-    while (ready && queries.length && max-- > 0) {
-      const query = queries.shift();
-      if (query.reserve)
-        return query.reserve(c);
-      ready = c.execute(query);
-    }
-    ready ? move(c, busy) : move(c, full);
-  }
-  function onclose(c, e) {
-    move(c, closed);
-    c.reserved = null;
-    c.onclose && (c.onclose(e), c.onclose = null);
-    options.onclose && options.onclose(c.id);
-    queries.length && connect(c, queries.shift());
-  }
-}
-function parseOptions(a, b) {
-  if (a && a.shared)
-    return a;
-  const env = process.env, o = (!a || typeof a === "string" ? b : a) || {}, { url, multihost } = parseUrl(a), query = [...url.searchParams].reduce((a, [b, c]) => (a[b] = c, a), {}), host = o.hostname || o.host || multihost || url.hostname || env.PGHOST || "localhost", port = o.port || url.port || env.PGPORT || 5432, user = o.user || o.username || url.username || env.PGUSERNAME || env.PGUSER || osUsername();
-  o.no_prepare && (o.prepare = false);
-  query.sslmode && (query.ssl = query.sslmode, delete query.sslmode);
-  "timeout" in o && (console.log("The timeout option is deprecated, use idle_timeout instead"), o.idle_timeout = o.timeout);
-  query.sslrootcert === "system" && (query.ssl = "verify-full");
-  const ints = ["idle_timeout", "connect_timeout", "max_lifetime", "max_pipeline", "backoff", "keep_alive"];
-  const defaults = {
-    max: globalThis.Cloudflare ? 3 : 10,
-    ssl: false,
-    sslnegotiation: null,
-    idle_timeout: null,
-    connect_timeout: 30,
-    max_lifetime,
-    max_pipeline: 100,
-    backoff,
-    keep_alive: 60,
-    prepare: true,
-    debug: false,
-    fetch_types: true,
-    publications: "alltables",
-    target_session_attrs: null
-  };
-  return {
-    host: Array.isArray(host) ? host : host.split(",").map((x) => x.split(":")[0]),
-    port: Array.isArray(port) ? port : host.split(",").map((x) => parseInt(x.split(":")[1] || port)),
-    path: o.path || host.indexOf("/") > -1 && host + "/.s.PGSQL." + port,
-    database: o.database || o.db || (url.pathname || "").slice(1) || env.PGDATABASE || user,
-    user,
-    pass: o.pass || o.password || url.password || env.PGPASSWORD || "",
-    ...Object.entries(defaults).reduce((acc, [k, d]) => {
-      const value = k in o ? o[k] : (k in query) ? query[k] === "disable" || query[k] === "false" ? false : query[k] : env["PG" + k.toUpperCase()] || d;
-      acc[k] = typeof value === "string" && ints.includes(k) ? +value : value;
-      return acc;
-    }, {}),
-    connection: {
-      application_name: env.PGAPPNAME || "postgres.js",
-      ...o.connection,
-      ...Object.entries(query).reduce((acc, [k, v]) => ((k in defaults) || (acc[k] = v), acc), {})
-    },
-    types: o.types || {},
-    target_session_attrs: tsa(o, url, env),
-    onnotice: o.onnotice,
-    onnotify: o.onnotify,
-    onclose: o.onclose,
-    onparameter: o.onparameter,
-    socket: o.socket,
-    transform: parseTransform(o.transform || { undefined: undefined }),
-    parameters: {},
-    shared: { retries: 0, typeArrayMap: {} },
-    ...mergeUserTypes(o.types)
-  };
-}
-function tsa(o, url, env) {
-  const x = o.target_session_attrs || url.searchParams.get("target_session_attrs") || env.PGTARGETSESSIONATTRS;
-  if (!x || ["read-write", "read-only", "primary", "standby", "prefer-standby"].includes(x))
-    return x;
-  throw new Error("target_session_attrs " + x + " is not supported");
-}
-function backoff(retries) {
-  return (0.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20);
-}
-function max_lifetime() {
-  return 60 * (30 + Math.random() * 30);
-}
-function parseTransform(x) {
-  return {
-    undefined: x.undefined,
-    column: {
-      from: typeof x.column === "function" ? x.column : x.column && x.column.from,
-      to: x.column && x.column.to
-    },
-    value: {
-      from: typeof x.value === "function" ? x.value : x.value && x.value.from,
-      to: x.value && x.value.to
-    },
-    row: {
-      from: typeof x.row === "function" ? x.row : x.row && x.row.from,
-      to: x.row && x.row.to
-    }
-  };
-}
-function parseUrl(url) {
-  if (!url || typeof url !== "string")
-    return { url: { searchParams: new Map } };
-  let host = url;
-  host = host.slice(host.indexOf("://") + 3).split(/[?/]/)[0];
-  host = decodeURIComponent(host.slice(host.indexOf("@") + 1));
-  const urlObj = new URL(url.replace(host, host.split(",")[0]));
-  return {
-    url: {
-      username: decodeURIComponent(urlObj.username),
-      password: decodeURIComponent(urlObj.password),
-      host: urlObj.host,
-      hostname: urlObj.hostname,
-      port: urlObj.port,
-      pathname: urlObj.pathname,
-      searchParams: urlObj.searchParams
-    },
-    multihost: host.indexOf(",") > -1 && host
-  };
-}
-function osUsername() {
-  try {
-    return os4.userInfo().username;
-  } catch (_) {
-    return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
-  }
-}
-var src_default;
-var init_src = __esm(() => {
-  init_types4();
-  init_connection();
-  init_query();
-  init_queue();
-  init_errors2();
-  init_large();
-  Object.assign(Postgres, {
-    PostgresError,
-    toPascal,
-    pascal,
-    toCamel,
-    camel,
-    toKebab,
-    kebab,
-    fromPascal,
-    fromCamel,
-    fromKebab,
-    BigInt: {
-      to: 20,
-      from: [20],
-      parse: (x) => BigInt(x),
-      serialize: (x) => x.toString()
-    }
-  });
-  src_default = Postgres;
-});
-
 // src/lib/dev-state.ts
-import { homedir as homedir4 } from "node:os";
-import { join as join12 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join11 } from "node:path";
 function getLogsDir() {
   return LOGS_DIR;
 }
@@ -33968,9 +31822,9 @@ function isProcessRunning(pid) {
 }
 var STATE_DIR, DEV_STATE_PATH, LOGS_DIR;
 var init_dev_state = __esm(() => {
-  STATE_DIR = join12(homedir4(), ".secondlayer");
-  DEV_STATE_PATH = join12(STATE_DIR, "dev.json");
-  LOGS_DIR = join12(STATE_DIR, "logs");
+  STATE_DIR = join11(homedir3(), ".secondlayer");
+  DEV_STATE_PATH = join11(STATE_DIR, "dev.json");
+  LOGS_DIR = join11(STATE_DIR, "logs");
 });
 
 // ../../node_modules/commander/index.js
@@ -34034,7 +31888,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "22.3.4",
+  version: "23.1.0",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -34083,10 +31937,10 @@ var package_default = {
     "@inquirer/prompts": "^8.2.0",
     "@secondlayer/bundler": "^0.7.3",
     "@secondlayer/scaffold": "^1.6.3",
-    "@secondlayer/sdk": "^15.5.2",
-    "@secondlayer/shared": "^14.0.2",
+    "@secondlayer/sdk": "^16.0.0",
+    "@secondlayer/shared": "^15.0.0",
     "@secondlayer/stacks": "^6.5.3",
-    "@secondlayer/subgraphs": "^8.0.0",
+    "@secondlayer/subgraphs": "^8.0.1",
     "@secondlayer/verify": "^0.6.1",
     esbuild: "^0.28.2",
     "smol-toml": "^1.9.1",
@@ -36692,6 +34546,144 @@ async function runRefill(opts) {
     }
   });
 }
+// src/commands/keys.ts
+init_http();
+init_output();
+init_session();
+import { resolveAccountKey as resolveAccountKey4 } from "@secondlayer/sdk";
+var MIN_ID_REF_LENGTH = 8;
+function rotatableKeys(keys) {
+  return keys.filter((k) => k.status === "active" && k.product === "account");
+}
+function describeKey(key) {
+  return `${key.id.slice(0, 8)} ${key.name ?? "(unnamed)"}`;
+}
+function resolveKeyRef(keys, ref) {
+  const candidates = rotatableKeys(keys);
+  const barePrefix = ref.replace(/…$/, "");
+  const kinds = [
+    (k) => k.id === ref || ref.length >= MIN_ID_REF_LENGTH && k.id.startsWith(ref),
+    (k) => k.prefix === barePrefix,
+    (k) => k.name === ref
+  ];
+  for (const matches of kinds) {
+    const found = candidates.filter(matches);
+    if (found.length === 1)
+      return found[0];
+    if (found.length > 1) {
+      throw new Error(`"${ref}" matches ${found.length} keys: ${found.map(describeKey).join(", ")}. Use an id.`);
+    }
+  }
+  throw new Error(`No active account key matches "${ref}". Run: secondlayer keys list`);
+}
+async function applyRotationToLogin(prefix, newKey, deps = {}) {
+  const apiUrl = deps.apiUrl ?? resolveArchiveOpsUrl();
+  const read = deps.readSession ?? readSession;
+  const write = deps.writeSession ?? writeSession;
+  const envKey = "envKey" in deps ? deps.envKey : resolveAccountKey4();
+  if (!prefix)
+    return { loginUpdated: false, envStale: false };
+  let loginUpdated = false;
+  const session = await read(apiUrl);
+  if (session?.token.startsWith(prefix)) {
+    await write({ ...session, token: newKey }, apiUrl);
+    loginUpdated = true;
+  }
+  return { loginUpdated, envStale: envKey?.startsWith(prefix) ?? false };
+}
+async function saveRotatedLogin(prefix, newKey, deps = {}) {
+  try {
+    return await applyRotationToLogin(prefix, newKey, deps);
+  } catch (err) {
+    const envKey = "envKey" in deps ? deps.envKey : resolveAccountKey4();
+    return {
+      loginUpdated: false,
+      envStale: Boolean(prefix) && (envKey?.startsWith(prefix) ?? false),
+      loginError: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function fail(err) {
+  if (err instanceof Error) {
+    error(err.message);
+    process.exit(1);
+  }
+  throw err;
+}
+async function fetchKeys() {
+  const res = await httpArchiveOps("/api/keys");
+  return res.keys;
+}
+async function runList(opts) {
+  let keys;
+  try {
+    keys = rotatableKeys(await fetchKeys());
+  } catch (err) {
+    fail(err);
+  }
+  output({
+    json: opts.json,
+    data: {
+      keys: keys.map(({ rowsDaily: _rowsDaily, ...rest }) => rest)
+    },
+    human: () => {
+      if (keys.length === 0) {
+        note("No active account keys. Make one at https://www.secondlayer.tools/account/keys");
+        return;
+      }
+      console.log(formatTable(["ID", "NAME", "KEY", "LAST READ", "ROWS 30D"], keys.map((k) => [
+        k.id.slice(0, 8),
+        k.name ?? "(unnamed)",
+        `${k.prefix}…`,
+        k.lastUsedAt ?? "never",
+        k.rows30d.toLocaleString("en-US")
+      ])));
+    }
+  });
+}
+async function runRotate(ref, opts) {
+  let target;
+  try {
+    target = resolveKeyRef(await fetchKeys(), ref);
+  } catch (err) {
+    fail(err);
+  }
+  const label = target.name ?? "(unnamed)";
+  const ok = await confirmDestructive({
+    message: `Rotate "${label}" (${target.prefix}…)? Anything using it gets a 401 at once.`,
+    yes: opts.yes
+  });
+  if (!ok) {
+    info("Cancelled");
+    return;
+  }
+  let rotated;
+  try {
+    rotated = await httpArchiveOps(`/api/keys/${target.id}/rotate`, { method: "POST", body: {} });
+  } catch (err) {
+    fail(err);
+  }
+  const { loginUpdated, envStale, loginError } = await saveRotatedLogin(target.prefix, rotated.key);
+  if (opts.json) {
+    writeData(JSON.stringify({ ...rotated, loginUpdated }, null, 2));
+  } else {
+    success(`Rotated ${blue(label)}. The old key has stopped working.`);
+    writeData(rotated.key);
+    note("Shown once. Copy it now.");
+  }
+  if (loginError) {
+    warn(`Couldn't update your CLI login: ${loginError}. Run: secondlayer login --with-token`);
+  }
+  if (loginUpdated)
+    info("Updated your CLI login to the new key.");
+  if (envStale)
+    warn("SECONDLAYER_API_KEY still holds the old key. Update it.");
+}
+function registerKeysCommand(program) {
+  const keys = program.command("keys").description("Manage account keys");
+  keys.command("list").alias("ls").description("List your active account keys").option("--json", "Output as JSON").action((opts) => runList(opts));
+  keys.command("rotate <ref>").description("Replace a key's secret; the old one stops working at once").option("-y, --yes", "Skip confirmation").option("--json", "Output as JSON").action((ref, opts) => runRotate(ref, opts));
+}
 // src/commands/codegen.ts
 function registerCodegenCommand(program) {
   const codegen = program.command("codegen").description("Generate typed code: contracts, subgraphs, Index, clients");
@@ -36718,259 +34710,6 @@ function registerCodegenCommand(program) {
 }
 // src/commands/config.ts
 init_config2();
-
-// src/lib/detect.ts
-import { homedir as homedir3 } from "node:os";
-import { join as join8 } from "node:path";
-
-// src/lib/docker.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-function run2(command, args) {
-  const result = spawnSync2(command, args, { encoding: "utf8" });
-  return {
-    ok: !result.error && result.status === 0,
-    stdout: result.stdout ?? ""
-  };
-}
-async function isDockerAvailable() {
-  return run2("docker", ["info"]).ok;
-}
-
-// src/lib/detect.ts
-var STACKS_CONTAINER_PATTERNS = [
-  "stacks-blockchain",
-  "stacks-node",
-  "stacks_blockchain",
-  "stacks_node"
-];
-async function detectRunningContainers() {
-  try {
-    const psResult = await Bun.$`docker ps --format "{{.Names}}"`.quiet().nothrow();
-    if (psResult.exitCode !== 0) {
-      return null;
-    }
-    const containers = psResult.stdout.toString().trim().split(`
-`).filter(Boolean);
-    const stacksContainer = containers.find((name) => STACKS_CONTAINER_PATTERNS.some((pattern) => name.toLowerCase().includes(pattern.toLowerCase())));
-    if (!stacksContainer) {
-      return null;
-    }
-    const inspectResult = await Bun.$`docker inspect ${stacksContainer}`.quiet().nothrow();
-    if (inspectResult.exitCode !== 0) {
-      return null;
-    }
-    const inspectData = JSON.parse(inspectResult.stdout.toString());
-    if (!Array.isArray(inspectData) || inspectData.length === 0) {
-      return null;
-    }
-    const container = inspectData[0];
-    const path = await extractPathFromMounts(container);
-    if (!path) {
-      return null;
-    }
-    const network = detectNetworkFromContainer(container);
-    return {
-      path,
-      network,
-      running: true,
-      source: "container"
-    };
-  } catch {
-    return null;
-  }
-}
-async function extractPathFromMounts(container) {
-  if (container.Mounts && Array.isArray(container.Mounts)) {
-    for (const mount of container.Mounts) {
-      if (mount.Type === "bind" && mount.Source) {
-        if (mount.Source.includes("stacks-blockchain") || mount.Source.includes("stacks-node") || mount.Destination?.includes("/stacks")) {
-          return await findDockerComposeRoot(mount.Source);
-        }
-      }
-    }
-  }
-  const binds = container.HostConfig?.Binds;
-  if (binds && Array.isArray(binds)) {
-    for (const bind of binds) {
-      const [source] = bind.split(":");
-      if (source && (source.includes("stacks-blockchain") || source.includes("stacks-node"))) {
-        return await findDockerComposeRoot(source);
-      }
-    }
-  }
-  return null;
-}
-async function findDockerComposeRoot(startPath) {
-  let current = startPath;
-  while (current && current !== "/") {
-    try {
-      const composeYml = Bun.file(join8(current, "docker-compose.yml"));
-      const composeYaml = Bun.file(join8(current, "docker-compose.yaml"));
-      if (await composeYml.exists() || await composeYaml.exists()) {
-        return current;
-      }
-    } catch {}
-    current = getParentPath(current);
-  }
-  const knownPatterns = ["stacks-blockchain-docker", "stacks-node"];
-  for (const pattern of knownPatterns) {
-    const idx = startPath.indexOf(pattern);
-    if (idx !== -1) {
-      return startPath.substring(0, idx + pattern.length);
-    }
-  }
-  return getParentPath(startPath);
-}
-function getParentPath(path) {
-  const parts = path.split("/").filter(Boolean);
-  parts.pop();
-  return `/${parts.join("/")}`;
-}
-function detectNetworkFromContainer(container) {
-  const config = container.Config;
-  if (config?.Env) {
-    for (const env of config.Env) {
-      const lower = env.toLowerCase();
-      if (lower.includes("network=testnet") || lower.includes("stacks_network=testnet")) {
-        return "testnet";
-      }
-      if (lower.includes("network=mainnet") || lower.includes("stacks_network=mainnet")) {
-        return "mainnet";
-      }
-    }
-  }
-  if (config?.Labels) {
-    const networkLabel = config.Labels.network || config.Labels["stacks.network"];
-    if (networkLabel === "testnet") {
-      return "testnet";
-    }
-  }
-  return "mainnet";
-}
-var SEARCH_PATTERNS = [
-  "/Volumes/stacks-blockchain-docker",
-  "/Volumes/stacks-node",
-  "/Volumes/*/stacks-blockchain-docker",
-  "/Volumes/*/stacks-node",
-  `${homedir3()}/stacks-blockchain-docker`,
-  `${homedir3()}/stacks-node`,
-  `${homedir3()}/stacks-*`,
-  "/opt/stacks-blockchain-docker",
-  "/opt/stacks-node",
-  "/opt/stacks-*"
-];
-async function scanFilesystemPaths() {
-  const nodes = [];
-  const checkedPaths = new Set;
-  for (const pattern of SEARCH_PATTERNS) {
-    const paths = await expandGlobPattern(pattern);
-    for (const path of paths) {
-      if (checkedPaths.has(path))
-        continue;
-      checkedPaths.add(path);
-      const isValid = await isValidStacksNodeDir(path);
-      if (!isValid)
-        continue;
-      const network = await detectNetworkFromFilesystem(path);
-      const running = await isComposeProjectRunning(path);
-      nodes.push({
-        path,
-        network,
-        running,
-        source: "filesystem"
-      });
-    }
-  }
-  return nodes;
-}
-async function expandGlobPattern(pattern) {
-  try {
-    const result = await Bun.$`bash -c ${`ls -d ${pattern} 2>/dev/null`}`.quiet().nothrow();
-    if (result.exitCode !== 0) {
-      return [];
-    }
-    return result.stdout.toString().trim().split(`
-`).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-async function isValidStacksNodeDir(path) {
-  const dirName = path.split("/").filter(Boolean).pop() ?? "";
-  if (dirName.includes("stacks-blockchain") || dirName.includes("stacks-node")) {
-    return true;
-  }
-  try {
-    const composeYml = Bun.file(join8(path, "docker-compose.yml"));
-    const composeYaml = Bun.file(join8(path, "docker-compose.yaml"));
-    const hasCompose = await composeYml.exists() || await composeYaml.exists();
-    if (!hasCompose) {
-      return false;
-    }
-    const composeFile = await composeYml.exists() ? composeYml : composeYaml;
-    const content = await composeFile.text();
-    return content.includes("stacks-blockchain") || content.includes("stacks-node") || content.includes("blockstack/stacks-blockchain") || content.includes("hirosystems/stacks-blockchain");
-  } catch {
-    return false;
-  }
-}
-async function detectNetworkFromFilesystem(path) {
-  const envFile = Bun.file(join8(path, ".env"));
-  if (await envFile.exists()) {
-    try {
-      const content = await envFile.text();
-      if (content.includes("NETWORK=testnet") || content.includes("STACKS_NETWORK=testnet")) {
-        return "testnet";
-      }
-      if (content.includes("NETWORK=mainnet") || content.includes("STACKS_NETWORK=mainnet")) {
-        return "mainnet";
-      }
-    } catch {}
-  }
-  const testnetConfig = Bun.file(join8(path, "configurations/testnet"));
-  const mainnetConfig = Bun.file(join8(path, "configurations/mainnet"));
-  const activeConfig = Bun.file(join8(path, "configurations/active"));
-  if (await activeConfig.exists()) {
-    try {
-      const result = await Bun.$`readlink ${join8(path, "configurations/active")}`.quiet().nothrow();
-      const link = result.stdout.toString().trim();
-      if (link.includes("testnet"))
-        return "testnet";
-    } catch {}
-  }
-  if (path.toLowerCase().includes("testnet")) {
-    return "testnet";
-  }
-  return "mainnet";
-}
-async function isComposeProjectRunning(path) {
-  try {
-    const result = await Bun.$`docker compose -f ${join8(path, "docker-compose.yml")} ps -q`.quiet().nothrow();
-    return result.exitCode === 0 && result.stdout.toString().trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-async function detectStacksNodes() {
-  const nodes = [];
-  if (await isDockerAvailable()) {
-    const containerNode = await detectRunningContainers();
-    if (containerNode) {
-      nodes.push(containerNode);
-    }
-  }
-  const filesystemNodes = await scanFilesystemPaths();
-  const seenPaths = new Set(nodes.map((n) => n.path));
-  for (const node of filesystemNodes) {
-    if (!seenPaths.has(node.path)) {
-      nodes.push(node);
-      seenPaths.add(node.path);
-    }
-  }
-  return nodes;
-}
-
-// src/commands/config.ts
 init_output();
 function registerConfigCommand(program) {
   const config = program.command("config").description("Manage CLI configuration");
@@ -36983,25 +34722,18 @@ function registerConfigCommand(program) {
       }
       note(`Config file: ${getConfigPath()}`);
       console.log("");
-      await printConfigTree(cfg);
+      printConfig(cfg);
     } catch (err) {
       error(`Failed to load config: ${err}`);
       process.exit(1);
     }
   });
-  config.command("set <key> <value>").description("Set a configuration value (supports dot notation: ports.api)").option("--no-validate", "Skip connection validation for database/redis URLs").addHelpText("after", `
+  config.command("set <key> <value>").description("Set a configuration value").addHelpText("after", `
 Examples:
-  $ secondlayer config set network local
-  $ secondlayer config set ports.api 3800
-  $ secondlayer config set database.url postgres://localhost:5432/secondlayer_dev`).action(async (key, value, options) => {
+  $ secondlayer config set network local`).action(async (key, value) => {
     try {
       await setConfigValue(key, value);
       success(`Set ${key} = ${value}`);
-      if (options.validate) {
-        if (key === "database.url") {
-          await validateDatabaseConnection(value);
-        }
-      }
     } catch (err) {
       if (err instanceof Error && err.message.includes("Invalid")) {
         error(`Invalid value for ${key}: ${err.message}`);
@@ -37044,78 +34776,12 @@ Examples:
     }
   });
 }
-async function printConfigTree(cfg) {
-  const defaults = getDefaultConfig();
-  printValue("network", cfg.network, isDefaultValue(cfg, "network"));
-  if (cfg.defaultProject) {
-    printValue("defaultProject", cfg.defaultProject, false);
-  }
-  const resolvedDataDir = getDataDir(cfg);
-  const dataDirDisplay = cfg.dataDir === resolvedDataDir ? cfg.dataDir : `${cfg.dataDir} ${dim(`→ ${resolvedDataDir}`)}`;
-  printValue("dataDir", dataDirDisplay, isDefaultValue(cfg, "dataDir"));
-  if (cfg.network === "local") {
-    console.log("");
-    console.log(blue("node:"));
-    if (cfg.node) {
-      printValue("  installPath", cfg.node.installPath, false, 2);
-      printValue("  network", cfg.node.network, cfg.node.network === "mainnet", 2);
-    } else {
-      console.log(dim("  (not configured)"));
-      try {
-        const detected = await detectStacksNodes();
-        if (detected.length > 0) {
-          console.log("");
-          console.log(dim(`  Detected ${detected.length} node${detected.length > 1 ? "s" : ""}:`));
-          for (const node of detected.slice(0, 3)) {
-            const status = node.running ? green("●") : dim("○");
-            console.log(dim(`    ${status} ${node.path} (${node.network})`));
-          }
-          console.log(dim("  Run 'secondlayer init' to configure"));
-        }
-      } catch {}
-    }
-    console.log("");
-    console.log(blue("ports:"));
-    printValue("  api", cfg.ports.api, cfg.ports.api === defaults.ports.api, 2);
-    printValue("  indexer", cfg.ports.indexer, cfg.ports.indexer === defaults.ports.indexer, 2);
-    console.log("");
-    console.log(blue("database:"));
-    printValue("  type", cfg.database.type, cfg.database.type === "docker", 2);
-    if (cfg.database.url) {
-      printValue("  url", maskUrl(cfg.database.url), false, 2);
-    }
-  }
+function printConfig(cfg) {
+  const isDefault = cfg.network === getDefaultConfig().network;
+  const value = isDefault ? dim(cfg.network) : green(cfg.network);
+  console.log(`network: ${value}${isDefault ? dim(" (default)") : ""}`);
   console.log("");
 }
-function printValue(key, value, isDefault, _indent = 0) {
-  const valueStr = String(value);
-  const defaultIndicator = isDefault ? dim(" (default)") : "";
-  const valueColor = isDefault ? dim(valueStr) : green(valueStr);
-  console.log(`${key}: ${valueColor}${defaultIndicator}`);
-}
-function maskUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = "****";
-    }
-    return parsed.toString();
-  } catch {
-    return url;
-  }
-}
-async function validateDatabaseConnection(url) {
-  try {
-    await Promise.resolve().then(() => init_src());
-    const sql = src_default(url);
-    await sql`SELECT 1`;
-    await sql.end();
-    success("Database connection verified");
-  } catch (err) {
-    warn(`Could not connect to database: ${err instanceof Error ? err.message : err}`);
-    console.log(dim("The URL was saved but connection failed. Check your database settings."));
-  }
-}
 // src/commands/context.ts
 init_http();
 import {
@@ -37933,9 +35599,9 @@ function registerWebhooksCommand(program) {
   attachWebhookSubcommands(webhooks);
 }
 // src/commands/devnet.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 
 // src/lib/devnet-compose.ts
 var DEFAULT_IMAGE_OWNER = "ryanwaits";
@@ -38090,14 +35756,14 @@ volumes:
 
 // src/lib/devnet-config.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6, join as join9, parse as parsePath } from "node:path";
+import { dirname as dirname6, join as join8, parse as parsePath } from "node:path";
 import { parse as parseToml } from "smol-toml";
 var DEFAULT_INDEXER_OBSERVER = "host.docker.internal:3700";
 function findClarinetProject(startDir) {
   let dir = startDir;
   const { root } = parsePath(dir);
   while (true) {
-    if (existsSync5(join9(dir, "Clarinet.toml")))
+    if (existsSync5(join8(dir, "Clarinet.toml")))
       return dir;
     if (dir === root)
       return null;
@@ -38149,7 +35815,7 @@ init_resolve_auth();
 // src/commands/faucet.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 import { http as http3, createWalletClient } from "@secondlayer/stacks";
 import { mnemonicToAccount } from "@secondlayer/stacks/accounts";
 import { devnet } from "@secondlayer/stacks/chains";
@@ -38159,7 +35825,7 @@ init_output();
 var DUST_LIMIT_SATS = 546n;
 var DEFAULT_AMOUNT_SATS = 1000000n;
 async function readDeployerMnemonic(projectDir) {
-  const path = join10(projectDir, "settings", "Devnet.toml");
+  const path = join9(projectDir, "settings", "Devnet.toml");
   let raw;
   try {
     raw = await readFile5(path, "utf8");
@@ -38276,9 +35942,9 @@ is what makes minting possible without Bitcoin.`).action(async (opts) => {
 }
 
 // src/commands/devnet.ts
-var COMPOSE_REL = join11(".secondlayer", "docker-compose.yml");
+var COMPOSE_REL = join10(".secondlayer", "docker-compose.yml");
 function ensureDocker() {
-  const probe = spawnSync3("docker", ["info"], { stdio: "ignore" });
+  const probe = spawnSync2("docker", ["info"], { stdio: "ignore" });
   if (probe.error || probe.status !== 0) {
     error(`Docker isn't available.
 
@@ -38289,7 +35955,7 @@ function ensureDocker() {
   }
 }
 function dockerCompose(composePath, args) {
-  const res = spawnSync3("docker", ["compose", "-f", composePath, ...args], {
+  const res = spawnSync2("docker", ["compose", "-f", composePath, ...args], {
     stdio: "inherit"
   });
   return res.status ?? 1;
@@ -38321,7 +35987,7 @@ function registerDevnetCommand(program) {
 }
 function resolveProject(explicit) {
   if (explicit) {
-    if (!existsSync6(join11(explicit, "Clarinet.toml"))) {
+    if (!existsSync6(join10(explicit, "Clarinet.toml"))) {
       error(`No Clarinet.toml in ${explicit}`);
       process.exit(1);
     }
@@ -38337,7 +36003,7 @@ function resolveProject(explicit) {
 }
 async function connect(options) {
   const project = resolveProject(options.project);
-  const devnetToml = join11(project, "settings", "Devnet.toml");
+  const devnetToml = join10(project, "settings", "Devnet.toml");
   mkdirSync3(dirname7(devnetToml), { recursive: true });
   const result = ensureEventObserver(devnetToml, DEFAULT_INDEXER_OBSERVER);
   console.log(`${green("✓")} found Clarinet.toml`);
@@ -38347,7 +36013,7 @@ async function connect(options) {
     console.log(`${green("✓")} ${result.status === "created" ? "created" : "patched"} settings/Devnet.toml`);
     console.log(dim(`    + stacks_node_events_observers = ["${DEFAULT_INDEXER_OBSERVER}"]`));
   }
-  const composePath = join11(project, COMPOSE_REL);
+  const composePath = join10(project, COMPOSE_REL);
   mkdirSync3(dirname7(composePath), { recursive: true });
   writeFileSync5(composePath, buildDevnetCompose({ owner: options.owner, imageTag: options.imageTag }));
   console.log(`${green("✓")} wrote ${COMPOSE_REL}`);
@@ -38380,7 +36046,7 @@ Stop with: secondlayer devnet down`));
 }
 async function down(options) {
   const project = resolveProject(options.project);
-  const composePath = join11(project, COMPOSE_REL);
+  const composePath = join10(project, COMPOSE_REL);
   if (!existsSync6(composePath)) {
     error(`No ${COMPOSE_REL} in ${project} — nothing to stop. Run \`secondlayer devnet connect\` first.`);
     process.exit(1);
@@ -38395,7 +36061,7 @@ async function down(options) {
 }
 async function logs(service, options) {
   const project = resolveProject(options.project);
-  const composePath = join11(project, COMPOSE_REL);
+  const composePath = join10(project, COMPOSE_REL);
   if (!existsSync6(composePath)) {
     error(`No ${COMPOSE_REL} in ${project} — run \`secondlayer devnet connect\` first.`);
     process.exit(1);
@@ -38654,7 +36320,7 @@ function parseMaxPages(value) {
 }
 function consumeHandlers(io) {
   return {
-    onBatch: (events, _envelope, ctx) => {
+    onBatch: (events, ctx) => {
       for (const e of events)
         io.stdout(JSON.stringify(e));
       if (ctx.cursor)
@@ -38837,7 +36503,6 @@ init_index_api();
 init_config2();
 
 // src/lib/health.ts
-init_config2();
 init_dev_state();
 
 // src/lib/network.ts
@@ -38855,96 +36520,30 @@ function networkFromId(networkId) {
     return "testnet";
   return null;
 }
-async function validateNetworkConsistency(config) {
-  const issues = [];
-  const network = config.node?.network;
-  if (!network) {
-    return { valid: true, issues: [] };
-  }
-  const expected = CHAIN_IDS[network].decimal;
-  try {
-    const res = await fetch("http://localhost:20443/v2/info", {
-      signal: AbortSignal.timeout(3000)
-    });
-    if (res.ok) {
-      const info = await res.json();
-      if (info.network_id !== expected) {
-        const actual = networkFromId(info.network_id);
-        issues.push(`RPC reports network_id=${info.network_id} (${actual ?? "unknown"}) but config says ${network} (${expected})`);
-      }
-    }
-  } catch {}
-  try {
-    const result = await Bun.$`docker inspect --format={{.Config.Env}} stacks-blockchain`.quiet().nothrow();
-    if (result.exitCode === 0) {
-      const envStr = result.stdout.toString();
-      const match = envStr.match(/STACKS_CHAIN_ID=(0x[0-9a-fA-F]+|\d+)/);
-      if (match) {
-        const containerId = Number.parseInt(match[1], match[1]?.startsWith("0x") ? 16 : 10);
-        if (containerId !== expected) {
-          issues.push(`Container STACKS_CHAIN_ID=${containerId} but config expects ${expected} (${network})`);
-        }
-      }
-    }
-  } catch {}
-  if (config.node?.installPath) {
-    try {
-      const envFile = Bun.file(`${config.node.installPath}/.env`);
-      if (await envFile.exists()) {
-        const content = await envFile.text();
-        const match = content.match(/STACKS_CHAIN_ID=(0x[0-9a-fA-F]+|\d+)/);
-        if (match) {
-          const fileId = Number.parseInt(match[1], match[1]?.startsWith("0x") ? 16 : 10);
-          if (fileId !== expected) {
-            issues.push(`Node .env STACKS_CHAIN_ID=${fileId} but config expects ${expected} (${network})`);
-          }
-        }
-      }
-    } catch {}
-  }
-  return { valid: issues.length === 0, issues };
-}
 
-// src/lib/node-manager.ts
-init_config2();
-async function getNodeContainers() {
+// src/lib/health.ts
+async function isNodeRunning() {
   try {
-    const result = await Bun.$`docker ps --format json --filter "name=stacks"`.quiet();
+    const result = await Bun.$`docker ps --format json --filter "name=stacks-blockchain"`.quiet();
     if (result.exitCode !== 0)
-      return [];
-    const lines = result.stdout.toString().trim().split(`
-`).filter(Boolean);
-    const containers = [];
-    for (const line of lines) {
-      try {
-        const container = JSON.parse(line);
-        containers.push({
-          name: container.Names || container.Name,
-          status: container.Status || "unknown"
-        });
-      } catch {}
-    }
-    return containers;
+      return false;
+    return result.stdout.toString().trim().split(`
+`).filter(Boolean).some((line) => {
+      const { Status } = JSON.parse(line);
+      return !Status?.includes("Restarting");
+    });
   } catch {
-    return [];
+    return false;
   }
 }
-async function isNodeRunning() {
-  const containers = await getNodeContainers();
-  return containers.some((c) => c.name.includes("stacks-blockchain") && !c.status.includes("Restarting"));
-}
-
-// src/lib/health.ts
 async function checkHealth() {
-  const config = await loadConfig2();
   const issues = [];
   const node = {
     running: false,
-    network: config.node?.network ?? null,
+    network: null,
     height: null,
     burnHeight: null,
     chainId: null,
-    chainIdValid: true,
     peers: 0,
     version: null
   };
@@ -38960,7 +36559,7 @@ async function checkHealth() {
         node.height = info.stacks_tip_height ?? null;
         node.burnHeight = info.burn_block_height ?? null;
         node.version = info.server_version ?? null;
-        node.network = networkFromId(info.network_id) ?? node.network;
+        node.network = networkFromId(info.network_id);
       }
     } catch {
       issues.push("Node RPC not responding");
@@ -38974,9 +36573,6 @@ async function checkHealth() {
         node.peers = (peers.inbound?.length ?? 0) + (peers.outbound?.length ?? 0);
       }
     } catch {}
-    const validation = await validateNetworkConsistency(config);
-    node.chainIdValid = validation.valid;
-    issues.push(...validation.issues);
   }
   const containers = [];
   try {
@@ -39050,8 +36646,8 @@ async function checkHealth() {
     infrastructure.postgres = pg.stdout.toString().trim().length > 0;
   } catch {}
   const portsToCheck = [
-    { port: config.ports.api, name: "API" },
-    { port: config.ports.indexer, name: "Indexer" },
+    { port: 3800, name: "API" },
+    { port: 3700, name: "Indexer" },
     { port: 20443, name: "Node RPC" }
   ];
   for (const { port, name } of portsToCheck) {
@@ -39168,22 +36764,17 @@ function doctorVerdictSuffix(diagnosis) {
   return ` — the API reports status=${diagnosis.overall}.`;
 }
 async function runLocalDoctor(jsonOutput) {
-  const config = await loadConfig2();
   const report = await checkHealth();
   if (jsonOutput) {
     console.log(JSON.stringify(report, null, 2));
     return;
   }
-  const network = config.node?.network;
-  const chainIdHex = network ? getChainIdHex(network) : "N/A";
+  const { network } = report.node;
   console.log("");
   console.log(blue("Stack"));
   console.log(formatKeyValue([
     ["  Network", network ?? dim("not configured")],
-    [
-      "  Chain ID",
-      network ? `${chainIdHex} (${report.node.chainIdValid ? green("valid") : red("MISMATCH")})` : dim("N/A")
-    ]
+    ["  Chain ID", network ? getChainIdHex(network) : dim("N/A")]
   ]));
   console.log("");
   console.log(blue("Node"));
@@ -39226,30 +36817,8 @@ async function runLocalDoctor(jsonOutput) {
   console.log(`  ${report.infrastructure.postgres ? green("✓") : red("✗")} PostgreSQL`);
   console.log("");
   console.log(blue("Config"));
-  const configPath = (await Promise.resolve().then(() => (init_config2(), exports_config))).getConfigPath();
-  const dataDir = getDataDir(config);
-  console.log(formatKeyValue([
-    ["  Config", dim(configPath)],
-    ["  Data dir", dim(dataDir)],
-    ["  Node path", dim(config.node?.installPath ?? "not set")]
-  ]));
+  console.log(formatKeyValue([["  Config", dim(getConfigPath())]]));
   console.log("");
-  try {
-    const result = await Bun.$`df -h ${dataDir}`.quiet().nothrow();
-    if (result.exitCode === 0) {
-      const lines = result.stdout.toString().trim().split(`
-`);
-      if (lines.length >= 2) {
-        const parts = lines[1]?.split(/\s+/);
-        const used = parts[2];
-        const avail = parts[3];
-        const pct = parts[4];
-        console.log(blue("Disk"));
-        console.log(`  Used: ${used}  Available: ${avail}  (${pct})`);
-        console.log("");
-      }
-    }
-  } catch {}
   try {
     await Promise.resolve().then(() => init_dev_state());
     const logsDir = getLogsDir();
@@ -39279,54 +36848,9 @@ async function runLocalDoctor(jsonOutput) {
 }
 // src/commands/whoami.ts
 init_api_url();
-init_config2();
 init_http();
 init_output();
 import { resolveApiKey as resolveApiKey4 } from "@secondlayer/sdk";
-
-// src/lib/project-file.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname9, join as join13, parse as parsePath2, resolve as resolve8 } from "node:path";
-import { z as z4 } from "zod";
-var ProjectFileSchema = z4.object({
-  slug: z4.string().min(1)
-});
-var FILENAME = "project";
-var DIRNAME = ".secondlayer";
-async function readActiveProject(cwd, globalDefault) {
-  let dir = resolve8(cwd);
-  const home = resolve8(homedir5());
-  const fsRoot = parsePath2(dir).root;
-  while (true) {
-    const candidate = join13(dir, DIRNAME, FILENAME);
-    if (existsSync7(candidate)) {
-      try {
-        const raw = await readFile6(candidate, "utf8");
-        const parsed = ProjectFileSchema.parse(JSON.parse(raw));
-        return { slug: parsed.slug, resolvedFrom: candidate };
-      } catch {}
-    }
-    if (existsSync7(join13(dir, ".git")))
-      break;
-    if (dir === home || dir === fsRoot)
-      break;
-    const parent = dirname9(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  if (globalDefault) {
-    return {
-      slug: globalDefault,
-      resolvedFrom: join13(homedir5(), ".secondlayer", "config.json")
-    };
-  }
-  return null;
-}
-
-// src/commands/whoami.ts
 async function runWhoami() {
   const instanceUrl = resolveApiUrl();
   const merchantUrl = resolveArchiveOpsUrl();
@@ -39342,8 +36866,6 @@ async function runWhoami() {
     merchantOk = false;
   }
   const merchantCredential = source === "env" ? "SECONDLAYER_API_KEY" : source === "session" ? "session" : null;
-  const config = await loadConfig2();
-  const active = await readActiveProject(process.cwd(), config.defaultProject);
   return {
     instance: {
       url: instanceUrl,
@@ -39355,8 +36877,7 @@ async function runWhoami() {
       credential: merchantCredential,
       status: merchantOk ? "set" : "missing",
       email
-    },
-    project: active ? { slug: active.slug, source: active.resolvedFrom } : null
+    }
   };
 }
 function registerWhoamiCommand(program) {
@@ -39374,12 +36895,6 @@ function registerWhoamiCommand(program) {
         const merchantCred = result.merchant.credential ?? "SECONDLAYER_API_KEY|session";
         const merchantValue = result.merchant.email ? `${result.merchant.url}  ${merchantCred}  ${result.merchant.status}  (${result.merchant.email})` : `${result.merchant.url}  ${merchantCred}  ${result.merchant.status}`;
         rows.push(["merchant", merchantValue]);
-        if (result.project) {
-          rows.push(["project", result.project.slug]);
-          rows.push(["project source", dim(result.project.source)]);
-        } else {
-          rows.push(["project", dim("(none)")]);
-        }
         console.log(formatKeyValue(rows));
         if (result.merchant.status === "missing") {
           note(`merchant identity missing. ${ARCHIVE_AUTH_HINT}`);
@@ -39667,13 +37182,13 @@ init_output();
 init_resolve_auth();
 import {
   chmodSync,
-  existsSync as existsSync8,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync7,
   statSync as statSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { join as join14, resolve as resolve9 } from "node:path";
+import { join as join12, resolve as resolve8 } from "node:path";
 import { closeDb, getDb as getDb4, sql as sql2 } from "@secondlayer/shared/db";
 import {
   decryptBundle,
@@ -39822,10 +37337,10 @@ async function runBackup(opts) {
     printError(plan.reason);
     process.exit(BACKUP_EXIT.REFUSED);
   }
-  const outDir = resolve9(opts.out);
+  const outDir = resolve8(opts.out);
   mkdirSync4(outDir, { recursive: true });
   console.error("dumping database…");
-  const dumpPath = join14(outDir, DB_FILE);
+  const dumpPath = join12(outDir, DB_FILE);
   const dumpCmd = pgDumpInvocation(databaseUrl, dumpPath);
   const dump = await runProcess(dumpCmd.cmd, "pg_dump", dumpCmd.env);
   if (!dump.ok) {
@@ -39845,7 +37360,7 @@ async function runBackup(opts) {
     const lines = SECRET_ENV_KEYS.filter((k) => process.env[k]).map((k) => `${k}=${process.env[k]}`);
     const sealed = encryptBundle(lines.join(`
 `), passphrase);
-    const secretsPath = join14(outDir, SECRETS_FILE);
+    const secretsPath = join12(outDir, SECRETS_FILE);
     writeFileSync6(secretsPath, sealed);
     chmodSync(secretsPath, 384);
     manifest.secrets = {
@@ -39854,7 +37369,7 @@ async function runBackup(opts) {
       canary: sealKeyCanary(secretsKey)
     };
   }
-  writeFileSync6(join14(outDir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync6(join12(outDir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
 `);
   output({
     json: opts.json,
@@ -39883,14 +37398,14 @@ function attachRestoreCommand(cmd) {
 }
 async function runRestore(opts) {
   const databaseUrl = requireDatabaseUrl();
-  const dir = resolve9(opts.from);
-  const manifestPath = join14(dir, MANIFEST_FILE);
-  if (!existsSync8(manifestPath)) {
+  const dir = resolve8(opts.from);
+  const manifestPath = join12(dir, MANIFEST_FILE);
+  if (!existsSync7(manifestPath)) {
     printError(`no ${MANIFEST_FILE} in ${dir}`);
     process.exit(BACKUP_EXIT.REFUSED);
   }
   const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
-  const dumpPath = join14(dir, manifest.db?.file ?? DB_FILE);
+  const dumpPath = join12(dir, manifest.db?.file ?? DB_FILE);
   if (manifest.db && await sha256File(dumpPath) !== manifest.db.sha256) {
     printError("the database dump does not match the digest in the manifest; this bundle is corrupt or truncated");
     process.exit(BACKUP_EXIT.REFUSED);
@@ -39904,7 +37419,7 @@ async function runRestore(opts) {
       process.exit(BACKUP_EXIT.REFUSED);
     }
     try {
-      const env = decryptBundle(readFileSync7(join14(dir, manifest.secrets.file)), passphrase);
+      const env = decryptBundle(readFileSync7(join12(dir, manifest.secrets.file)), passphrase);
       bundleKey = env.split(`
 `).find((l) => l.startsWith("SECONDLAYER_SECRETS_KEY="))?.slice("SECONDLAYER_SECRETS_KEY=".length).trim();
     } catch {
@@ -39982,8 +37497,8 @@ function registerRestoreCommand(program) {
 // src/lib/instance-init.ts
 init_output();
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 import { ARCHIVE_ROOT_PUBLIC_KEY_PEM } from "@secondlayer/shared/archive/root-key";
 import { generateEd25519KeyPair } from "@secondlayer/shared/crypto/ed25519";
 import { INSTANCE_NETWORKS } from "@secondlayer/shared/db/queries/instance";
@@ -40032,7 +37547,7 @@ function unescapeEnvValue(raw) {
 `).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
 }
 function readEnvValue(envPath, key) {
-  if (!existsSync9(envPath))
+  if (!existsSync8(envPath))
     return null;
   const match = readFileSync8(envPath, "utf8").match(new RegExp(`^${key}=(.*)$`, "m"));
   return match ? unescapeEnvValue(match[1]) : null;
@@ -40080,12 +37595,12 @@ function renderInstanceEnv(env) {
 `);
 }
 function writeInstanceEnv(cwd, env, file = INSTANCE_ENV_FILE) {
-  const path = resolve10(cwd, file);
+  const path = resolve9(cwd, file);
   writeFileSync7(path, renderInstanceEnv(env), { mode: 384 });
   return path;
 }
 function loadExistingInstanceEnv(cwd, file = INSTANCE_ENV_FILE) {
-  const path = resolve10(cwd, file);
+  const path = resolve9(cwd, file);
   return {
     INSTANCE_TOKEN: readEnvValue(path, "INSTANCE_TOKEN"),
     SECONDLAYER_SECRETS_KEY: readEnvValue(path, "SECONDLAYER_SECRETS_KEY"),
@@ -40238,6 +37753,7 @@ registerObserverCommand(program);
 registerLoginCommand(program);
 registerLogoutCommand(program);
 registerWhoamiCommand(program);
+registerKeysCommand(program);
 program.commandsGroup("Your data:");
 registerSubgraphsCommand(program);
 registerWebhooksCommand(program);
@@ -40261,5 +37777,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=59184906FD67FE5F64756E2164756E21
+//# debugId=0DC9F45DD895F4A264756E2164756E21
 //# sourceMappingURL=cli.js.map