@secondlayer/cli 1.6.8 → 1.8.0

package/dist/cli.js

@@ -2141,7 +2141,7 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/lib/fs.ts
-import { readFile, writeFile, mkdir, unlink, stat } from "node:fs/promises";
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
 async function readJsonFile(path) {
   const text = await readFile(path, "utf-8");
   return JSON.parse(text);
@@ -2248,7 +2248,10 @@ function migrateConfig(raw) {
     migrated.ports = { ...DEFAULT_CONFIG.ports, ...old.ports };
   }
   if (old.database && typeof old.database === "object") {
-    migrated.database = { ...DEFAULT_CONFIG.database, ...old.database };
+    migrated.database = {
+      ...DEFAULT_CONFIG.database,
+      ...old.database
+    };
   }
   if (typeof old.indexerPort === "number") {
     migrated.ports.indexer = old.indexerPort;
@@ -2290,19 +2293,19 @@ function applyEnvOverrides(config) {
     result.dataDir = process.env.SL_DATA_DIR;
   }
   if (process.env.SL_API_PORT) {
-    const port = parseInt(process.env.SL_API_PORT, 10);
+    const port = Number.parseInt(process.env.SL_API_PORT, 10);
     if (!isNaN(port) && port > 0 && port <= 65535) {
       result.ports = { ...result.ports, api: port };
     }
   }
   if (process.env.SL_INDEXER_PORT) {
-    const port = parseInt(process.env.SL_INDEXER_PORT, 10);
+    const port = Number.parseInt(process.env.SL_INDEXER_PORT, 10);
     if (!isNaN(port) && port > 0 && port <= 65535) {
       result.ports = { ...result.ports, indexer: port };
     }
   }
   if (process.env.SL_RECEIVER_PORT) {
-    const port = parseInt(process.env.SL_RECEIVER_PORT, 10);
+    const port = Number.parseInt(process.env.SL_RECEIVER_PORT, 10);
     if (!isNaN(port) && port > 0 && port <= 65535) {
       result.ports = { ...result.ports, receiver: port };
     }
@@ -4558,6 +4561,7 @@ __export(exports_api_client, {
   listSubgraphsApi: () => listSubgraphsApi,
   listStreams: () => listStreams,
   handleApiError: () => handleApiError,
+  getSubgraphGaps: () => getSubgraphGaps,
   getSubgraphApi: () => getSubgraphApi,
   getStream: () => getStream,
   getQueueStats: () => getQueueStats,
@@ -4567,6 +4571,7 @@ __export(exports_api_client, {
   deleteSubgraphApi: () => deleteSubgraphApi,
   deleteStream: () => deleteStream,
   createStream: () => createStream,
+  backfillSubgraphApi: () => backfillSubgraphApi,
   authHeaders: () => authHeaders,
   assertOk: () => assertOk,
   ApiError: () => ApiError
@@ -4651,6 +4656,9 @@ async function getSubgraphApi(name) {
 async function reindexSubgraphApi(name, options) {
   return (await getClient()).subgraphs.reindex(name, options);
 }
+async function backfillSubgraphApi(name, options) {
+  return (await getClient()).subgraphs.backfill(name, options);
+}
 async function deleteSubgraphApi(name) {
   return (await getClient()).subgraphs.delete(name);
 }
@@ -4663,6 +4671,9 @@ async function querySubgraphTable(name, table, params = {}) {
 async function querySubgraphTableCount(name, table, params = {}) {
   return (await getClient()).subgraphs.queryTableCount(name, table, params);
 }
+async function getSubgraphGaps(name, opts) {
+  return (await getClient()).subgraphs.gaps(name, opts);
+}
 var init_api_client = __esm(() => {
   init_config();
 });
@@ -4800,6 +4811,261 @@ async function formatCode(code) {
 var biome = null;
 var init_format = () => {};
 
+// src/utils/abi-compat.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer2 = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer2?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined
+  };
+}
+
+// src/parsers/clarity.ts
+import { promises as fs2 } from "fs";
+async function parseClarityFile(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const result = parseClarityContent(content);
+    if (result.functions.length === 0) {
+      console.warn(`⚠️  No functions found in ${filePath}. ` + `For complex contracts, deploy first and use the contract address instead.`);
+    }
+    return result;
+  } catch (error2) {
+    throw new Error(`Unable to parse ${filePath}. ` + `For complex contracts, deploy first and use the contract address instead.
+` + `Original error: ${error2}`);
+  }
+}
+function parseClarityContent(content) {
+  const functions = [];
+  const functionRegex = /\(define-(public|read-only|private)\s+\(([^)]+)\)([\s\S]*?)\)\s*$/gm;
+  let match;
+  while ((match = functionRegex.exec(content)) !== null) {
+    const [, access, signature, body] = match;
+    const func = parseFunctionSignature(signature, access, body);
+    if (func) {
+      functions.push(func);
+    }
+  }
+  return { functions };
+}
+function parseFunctionSignature(signature, access, body) {
+  const parts = signature.trim().split(/\s+/);
+  const name = parts[0];
+  const args = [];
+  for (let i = 1;i < parts.length; i += 2) {
+    if (parts[i] && parts[i + 1]) {
+      const argName = parts[i].replace(/[()]/g, "");
+      const argType = parseType(parts[i + 1]);
+      if (argType) {
+        args.push({ name: argName, type: argType });
+      }
+    }
+  }
+  const outputs = inferReturnType(body);
+  return {
+    name,
+    access,
+    args,
+    outputs
+  };
+}
+function parseType(typeStr) {
+  typeStr = typeStr.replace(/[()]/g, "").trim();
+  switch (typeStr) {
+    case "uint":
+    case "uint128":
+      return "uint128";
+    case "int":
+    case "int128":
+      return "int128";
+    case "bool":
+      return "bool";
+    case "principal":
+      return "principal";
+    case "trait_reference":
+      return "principal";
+    default:
+      if (typeStr.startsWith("string-ascii")) {
+        return { "string-ascii": { length: 256 } };
+      }
+      if (typeStr.startsWith("string-utf8")) {
+        return { "string-utf8": { length: 256 } };
+      }
+      if (typeStr.startsWith("buff")) {
+        return { buff: { length: 32 } };
+      }
+      return "uint128";
+  }
+}
+function inferReturnType(body) {
+  if (body.includes("(ok")) {
+    if (body.includes("(err")) {
+      return {
+        response: {
+          ok: "bool",
+          error: "uint128"
+        }
+      };
+    }
+  }
+  if (body.includes("true") || body.includes("false")) {
+    return "bool";
+  }
+  return "bool";
+}
+function parseApiResponse(apiResponse) {
+  try {
+    return normalizeAbi(apiResponse);
+  } catch (error2) {
+    throw new Error(`Failed to parse API response: ${error2}`);
+  }
+}
+var init_clarity = () => {};
+
 // ../../node_modules/@sindresorhus/is/dist/index.js
 function isTypedArrayName(name) {
   return typedArrayTypeNames.includes(name);
@@ -12491,8 +12757,8 @@ class StacksApiClient {
 var gotWithRetry;
 var init_api = __esm(() => {
   init_source3();
-  init_config();
   init_api_client();
+  init_config();
   gotWithRetry = source_default2.extend({
     timeout: { request: 30000 },
     retry: {
@@ -12513,261 +12779,6 @@ function inferNetwork(address) {
   return;
 }
 
-// src/utils/abi-compat.ts
-function normalizeAccess(access) {
-  if (access === "read_only")
-    return "read-only";
-  return access;
-}
-function normalizeType(type) {
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-      case "int128":
-      case "bool":
-      case "principal":
-      case "trait_reference":
-        return type;
-      default:
-        return type;
-    }
-  }
-  if (typeof type !== "object" || type === null) {
-    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
-  }
-  const typeObj = type;
-  if ("buffer" in typeObj) {
-    const buffer2 = typeObj.buffer;
-    return {
-      buff: {
-        length: buffer2?.length ?? 32
-      }
-    };
-  }
-  if ("buff" in typeObj) {
-    const buff = typeObj.buff;
-    return {
-      buff: {
-        length: buff?.length ?? 32
-      }
-    };
-  }
-  if ("string-ascii" in typeObj) {
-    const strAscii = typeObj["string-ascii"];
-    return {
-      "string-ascii": {
-        length: strAscii?.length ?? 256
-      }
-    };
-  }
-  if ("string-utf8" in typeObj) {
-    const strUtf8 = typeObj["string-utf8"];
-    return {
-      "string-utf8": {
-        length: strUtf8?.length ?? 256
-      }
-    };
-  }
-  if ("response" in typeObj) {
-    const response2 = typeObj.response;
-    return {
-      response: {
-        ok: normalizeType(response2?.ok ?? "bool"),
-        error: normalizeType(response2?.error ?? "uint128")
-      }
-    };
-  }
-  if ("optional" in typeObj) {
-    return {
-      optional: normalizeType(typeObj.optional)
-    };
-  }
-  if ("list" in typeObj) {
-    const list = typeObj.list;
-    return {
-      list: {
-        type: normalizeType(list?.type ?? "uint128"),
-        length: list?.length ?? 100
-      }
-    };
-  }
-  if ("tuple" in typeObj) {
-    const tuple = typeObj.tuple;
-    return {
-      tuple: tuple.map((field) => ({
-        name: field.name,
-        type: normalizeType(field.type)
-      }))
-    };
-  }
-  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
-}
-function normalizeFunction(func) {
-  const access = normalizeAccess(func.access);
-  const args = func.args ?? [];
-  const outputs = func.outputs;
-  return {
-    name: func.name,
-    access,
-    args: args.map((arg) => ({
-      name: arg.name,
-      type: normalizeType(arg.type)
-    })),
-    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
-  };
-}
-function normalizeMap(map) {
-  return {
-    name: map.name,
-    key: normalizeType(map.key),
-    value: normalizeType(map.value)
-  };
-}
-function normalizeVariable(variable) {
-  return {
-    name: variable.name,
-    type: normalizeType(variable.type),
-    access: variable.access
-  };
-}
-function normalizeAbi(abi) {
-  if (typeof abi !== "object" || abi === null) {
-    return { functions: [] };
-  }
-  const abiObj = abi;
-  const functions = [];
-  const maps = [];
-  const variables = [];
-  if (Array.isArray(abiObj.functions)) {
-    for (const func of abiObj.functions) {
-      if (typeof func === "object" && func !== null) {
-        functions.push(normalizeFunction(func));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.maps)) {
-    for (const map of abiObj.maps) {
-      if (typeof map === "object" && map !== null) {
-        maps.push(normalizeMap(map));
-      }
-    }
-  }
-  if (Array.isArray(abiObj.variables)) {
-    for (const variable of abiObj.variables) {
-      if (typeof variable === "object" && variable !== null) {
-        variables.push(normalizeVariable(variable));
-      }
-    }
-  }
-  return {
-    functions,
-    maps: maps.length > 0 ? maps : undefined,
-    variables: variables.length > 0 ? variables : undefined
-  };
-}
-
-// src/parsers/clarity.ts
-import { promises as fs2 } from "fs";
-async function parseClarityFile(filePath) {
-  try {
-    const content = await fs2.readFile(filePath, "utf-8");
-    const result = parseClarityContent(content);
-    if (result.functions.length === 0) {
-      console.warn(`⚠️  No functions found in ${filePath}. ` + `For complex contracts, deploy first and use the contract address instead.`);
-    }
-    return result;
-  } catch (error2) {
-    throw new Error(`Unable to parse ${filePath}. ` + `For complex contracts, deploy first and use the contract address instead.
-` + `Original error: ${error2}`);
-  }
-}
-function parseClarityContent(content) {
-  const functions = [];
-  const functionRegex = /\(define-(public|read-only|private)\s+\(([^)]+)\)([\s\S]*?)\)\s*$/gm;
-  let match;
-  while ((match = functionRegex.exec(content)) !== null) {
-    const [, access, signature, body] = match;
-    const func = parseFunctionSignature(signature, access, body);
-    if (func) {
-      functions.push(func);
-    }
-  }
-  return { functions };
-}
-function parseFunctionSignature(signature, access, body) {
-  const parts = signature.trim().split(/\s+/);
-  const name = parts[0];
-  const args = [];
-  for (let i = 1;i < parts.length; i += 2) {
-    if (parts[i] && parts[i + 1]) {
-      const argName = parts[i].replace(/[()]/g, "");
-      const argType = parseType(parts[i + 1]);
-      if (argType) {
-        args.push({ name: argName, type: argType });
-      }
-    }
-  }
-  const outputs = inferReturnType(body);
-  return {
-    name,
-    access,
-    args,
-    outputs
-  };
-}
-function parseType(typeStr) {
-  typeStr = typeStr.replace(/[()]/g, "").trim();
-  switch (typeStr) {
-    case "uint":
-    case "uint128":
-      return "uint128";
-    case "int":
-    case "int128":
-      return "int128";
-    case "bool":
-      return "bool";
-    case "principal":
-      return "principal";
-    case "trait_reference":
-      return "principal";
-    default:
-      if (typeStr.startsWith("string-ascii")) {
-        return { "string-ascii": { length: 256 } };
-      }
-      if (typeStr.startsWith("string-utf8")) {
-        return { "string-utf8": { length: 256 } };
-      }
-      if (typeStr.startsWith("buff")) {
-        return { buff: { length: 32 } };
-      }
-      return "uint128";
-  }
-}
-function inferReturnType(body) {
-  if (body.includes("(ok")) {
-    if (body.includes("(err")) {
-      return {
-        response: {
-          ok: "bool",
-          error: "uint128"
-        }
-      };
-    }
-  }
-  if (body.includes("true") || body.includes("false")) {
-    return "bool";
-  }
-  return "bool";
-}
-function parseApiResponse(apiResponse) {
-  try {
-    return normalizeAbi(apiResponse);
-  } catch (error2) {
-    throw new Error(`Failed to parse API response: ${error2}`);
-  }
-}
-var init_clarity = () => {};
-
 // src/lib/network.ts
 function getChainId(network) {
   return CHAIN_IDS[network].decimal.toString();
@@ -12807,7 +12818,7 @@ async function validateNetworkConsistency(config) {
       const envStr = result.stdout.toString();
       const match = envStr.match(/STACKS_CHAIN_ID=(0x[0-9a-fA-F]+|\d+)/);
       if (match) {
-        const containerId = parseInt(match[1], match[1].startsWith("0x") ? 16 : 10);
+        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})`);
         }
@@ -12821,7 +12832,7 @@ async function validateNetworkConsistency(config) {
         const content = await envFile.text();
         const match = content.match(/STACKS_CHAIN_ID=(0x[0-9a-fA-F]+|\d+)/);
         if (match) {
-          const fileId = parseInt(match[1], match[1].startsWith("0x") ? 16 : 10);
+          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})`);
           }
@@ -12860,7 +12871,15 @@ async function validateNodePath(path) {
   return { valid: true };
 }
 async function runManageScript(installPath, network, action, extraArgs = []) {
-  const args = ["bash", "./manage.sh", "-n", network, "-a", action, ...extraArgs];
+  const args = [
+    "bash",
+    "./manage.sh",
+    "-n",
+    network,
+    "-a",
+    action,
+    ...extraArgs
+  ];
   const proc = Bun.spawn(args, {
     cwd: installPath,
     stdin: "inherit",
@@ -12871,9 +12890,7 @@ async function runManageScript(installPath, network, action, extraArgs = []) {
   return { stdout: "", stderr: "", exitCode };
 }
 async function startNodeContainers(installPath, network) {
-  const dirs = [
-    `${installPath}/persistent-data/${network}/stacks-blockchain`
-  ];
+  const dirs = [`${installPath}/persistent-data/${network}/stacks-blockchain`];
   for (const dir of dirs) {
     await Bun.$`mkdir -p ${dir}`.quiet().nothrow();
   }
@@ -12884,7 +12901,11 @@ async function startNodeContainers(installPath, network) {
       const envStr = inspect2.stdout.toString();
       const match = envStr.match(/STACKS_CHAIN_ID=(\d+)/);
       if (match && match[1] !== chainId) {
-        await Bun.$`docker compose -f compose-files/common.yaml -f compose-files/networks/${network}.yaml --env-file .env down`.cwd(installPath).env({ ...process.env, SCRIPTPATH: installPath, STACKS_CHAIN_ID: chainId }).quiet().nothrow();
+        await Bun.$`docker compose -f compose-files/common.yaml -f compose-files/networks/${network}.yaml --env-file .env down`.cwd(installPath).env({
+          ...process.env,
+          SCRIPTPATH: installPath,
+          STACKS_CHAIN_ID: chainId
+        }).quiet().nothrow();
       }
     }
   } catch {}
@@ -12999,7 +13020,7 @@ function formatLogLine(line) {
     return line;
   }
   const [, level, timestamp, _source, _thread, message] = match;
-  const date = new Date(parseFloat(timestamp) * 1000);
+  const date = new Date(Number.parseFloat(timestamp) * 1000);
   const isoTime = date.toISOString();
   const shortMessage = extractKeyInfo(message);
   return `[stacks-node] [${isoTime}] ${level}: ${shortMessage}`;
@@ -13146,7 +13167,7 @@ var init_manager = __esm(() => {
 });
 
 // src/services/indexer.ts
-import { resolve as resolve2, dirname } from "node:path";
+import { dirname, resolve as resolve2 } from "node:path";
 async function startIndexer(options2) {
   const port = options2.port ?? 3700;
   const rootDir = dirname(dirname(dirname(dirname(import.meta.dir))));
@@ -13166,7 +13187,7 @@ var init_indexer = __esm(() => {
 });
 
 // src/services/worker.ts
-import { resolve as resolve3, dirname as dirname2 } from "node:path";
+import { dirname as dirname2, resolve as resolve3 } from "node:path";
 async function startWorker(options2) {
   const rootDir = dirname2(dirname2(dirname2(dirname2(import.meta.dir))));
   const workerPath = resolve3(rootDir, "packages/worker/src/index.ts");
@@ -13184,7 +13205,7 @@ var init_worker = __esm(() => {
 });
 
 // src/services/api.ts
-import { resolve as resolve4, dirname as dirname3 } from "node:path";
+import { dirname as dirname3, resolve as resolve4 } from "node:path";
 async function startApi(options2) {
   const port = options2.port ?? 3800;
   const rootDir = dirname3(dirname3(dirname3(dirname3(import.meta.dir))));
@@ -13291,7 +13312,7 @@ var init_receiver_server = __esm(() => {
 });
 
 // src/services/subgraph-processor.ts
-import { resolve as resolve5, dirname as dirname4 } from "node:path";
+import { dirname as dirname4, resolve as resolve5 } from "node:path";
 async function startSubgraphProcessor(options2) {
   const rootDir = dirname4(dirname4(dirname4(dirname4(import.meta.dir))));
   const servicePath = resolve5(rootDir, "packages/subgraphs/src/service.ts");
@@ -13329,8 +13350,8 @@ __export(exports_dev_impl, {
   restartDev: () => restartDev,
   isDevAlreadyRunning: () => isDevAlreadyRunning
 });
-import { resolve as resolve6, dirname as dirname5, join as join6 } from "node:path";
 import { mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname5, join as join6, resolve as resolve6 } from "node:path";
 async function isDevAlreadyRunning() {
   if (await isDevRunning()) {
     const running = await getRunningServices();
@@ -13356,9 +13377,9 @@ async function runBackground(options2) {
   }
   const config = await loadConfig();
   const dataDir = getDataDir(config);
-  const indexerPort = options2.stacksNode ? 3701 : parseInt(options2.indexerPort) || config.ports.indexer;
-  const apiPort = parseInt(options2.apiPort) || config.ports.api;
-  const receiverPort = parseInt(options2.receiverPort) || config.ports.receiver;
+  const indexerPort = options2.stacksNode ? 3701 : Number.parseInt(options2.indexerPort) || config.ports.indexer;
+  const apiPort = Number.parseInt(options2.apiPort) || config.ports.api;
+  const receiverPort = Number.parseInt(options2.receiverPort) || config.ports.receiver;
   if (options2.stacksNode && config.node) {
     const validation = await validateNetworkConsistency(config);
     if (!validation.valid) {
@@ -13455,7 +13476,11 @@ async function runBackground(options2) {
     }
     {
       const subgraphsLogFile = getLogFile("subgraphs");
-      const subgraphsProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/subgraphs/src/service.ts")], {
+      const subgraphsProc = Bun.spawn([
+        "bun",
+        "run",
+        resolve6(packagesDir, "packages/subgraphs/src/service.ts")
+      ], {
         env: { ...process.env, ...env },
         stdout: Bun.file(subgraphsLogFile),
         stderr: Bun.file(subgraphsLogFile)
@@ -13470,8 +13495,15 @@ async function runBackground(options2) {
     }
     if (options2.receiver) {
       const receiverLogFile = getLogFile("receiver");
-      const receiverArgs = ["bun", "run", resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")];
-      const receiverEnv = { ...process.env, PORT: String(receiverPort) };
+      const receiverArgs = [
+        "bun",
+        "run",
+        resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")
+      ];
+      const receiverEnv = {
+        ...process.env,
+        PORT: String(receiverPort)
+      };
       if (options2.secret)
         receiverEnv.SIGNING_SECRET = options2.secret;
       const receiverProc = Bun.spawn(receiverArgs, {
@@ -13531,9 +13563,9 @@ async function runForeground(options2) {
   }
   const config = await loadConfig();
   const dataDir = getDataDir(config);
-  const indexerPort = options2.stacksNode ? 3701 : parseInt(options2.indexerPort) || config.ports.indexer;
-  const apiPort = parseInt(options2.apiPort) || config.ports.api;
-  const receiverPort = parseInt(options2.receiverPort) || config.ports.receiver;
+  const indexerPort = options2.stacksNode ? 3701 : Number.parseInt(options2.indexerPort) || config.ports.indexer;
+  const apiPort = Number.parseInt(options2.apiPort) || config.ports.api;
+  const receiverPort = Number.parseInt(options2.receiverPort) || config.ports.receiver;
   let devPostgresStarted = false;
   const shutdown = async () => {
     console.log(`
@@ -13593,13 +13625,18 @@ async function runForeground(options2) {
     }
     await startApi({ port: apiPort, onLog: (line) => logService("api", line) });
     console.log(green("  ✓ API"), dim(`http://localhost:${apiPort}`));
-    await startIndexer({ port: indexerPort, onLog: (line) => logService("indexer", line) });
+    await startIndexer({
+      port: indexerPort,
+      onLog: (line) => logService("indexer", line)
+    });
     console.log(green("  ✓ Indexer"), dim(`http://localhost:${indexerPort}`));
     if (options2.worker) {
       await startWorker({ onLog: (line) => logService("worker", line) });
       console.log(green("  ✓ Worker"), dim("processing jobs"));
     }
-    await startSubgraphProcessor({ onLog: (line) => logService("subgraphs", line) });
+    await startSubgraphProcessor({
+      onLog: (line) => logService("subgraphs", line)
+    });
     console.log(green("  ✓ Subgraph processor"), dim("processing subgraphs"));
     console.log("");
     printUrls(indexerPort, apiPort, receiverPort, options2.receiver);
@@ -13634,7 +13671,7 @@ async function showLogs(options2) {
     info("No log files found");
     return;
   }
-  const lines = parseInt(options2.lines);
+  const lines = Number.parseInt(options2.lines);
   const verbose = options2.verbose ?? false;
   if (options2.follow) {
     await followLogs2(serviceEntries, lines, verbose);
@@ -13855,8 +13892,15 @@ async function restartDev() {
   if (state.services.receiver) {
     const receiverPort = config.ports.receiver;
     const receiverLogFile = getLogFile("receiver");
-    const receiverProc = Bun.spawn(["bun", "run", resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")], {
-      env: { ...process.env, PORT: String(receiverPort) },
+    const receiverProc = Bun.spawn([
+      "bun",
+      "run",
+      resolve6(packagesDir, "packages/cli/src/services/receiver-standalone.ts")
+    ], {
+      env: {
+        ...process.env,
+        PORT: String(receiverPort)
+      },
       stdout: Bun.file(receiverLogFile),
       stderr: Bun.file(receiverLogFile)
     });
@@ -13979,13 +14023,21 @@ async function isDatabaseReachable(url) {
   try {
     const parsed = new URL(url);
     const host = parsed.hostname;
-    const port = parseInt(parsed.port || "5432");
+    const port = Number.parseInt(parsed.port || "5432");
     const socket = await Bun.$`pg_isready -h ${host} -p ${port}`.quiet().nothrow();
     if (socket.exitCode === 0)
       return true;
-    const conn = await Bun.connect({ hostname: host, port, socket: { data() {}, open(s) {
-      s.end();
-    }, error() {} } }).catch(() => null);
+    const conn = await Bun.connect({
+      hostname: host,
+      port,
+      socket: {
+        data() {},
+        open(s) {
+          s.end();
+        },
+        error() {}
+      }
+    }).catch(() => null);
     return conn !== null;
   } catch {
     return false;
@@ -14021,12 +14073,12 @@ async function runMigrations(databaseUrl) {
 }
 var DEV_DATABASE_URL3 = "postgres://postgres:postgres@localhost:5432/streams_dev", serviceColors;
 var init_dev_impl = __esm(() => {
-  init_services();
-  init_output();
-  init_dev_state();
   init_config();
+  init_dev_state();
   init_docker();
   init_network();
+  init_output();
+  init_services();
   serviceColors = {
     api: blue,
     indexer: cyan,
@@ -14047,7 +14099,7 @@ __export(exports_node_impl, {
   runSetupWizard: () => runSetupWizard,
   restartNode: () => restartNode
 });
-import { input as input3, select as select3, confirm as confirm6 } from "@inquirer/prompts";
+import { confirm as confirm6, input as input3, select as select3 } from "@inquirer/prompts";
 async function runSetupWizard() {
   console.log("");
   console.log(blue("Stacks Node Setup Wizard"));
@@ -14099,14 +14151,14 @@ async function runSetupWizard() {
         message: "Enter custom indexer port:",
         default: "3700",
         validate: (value) => {
-          const port = parseInt(value);
+          const port = Number.parseInt(value);
           if (isNaN(port) || port < 1 || port > 65535) {
             return "Invalid port number";
           }
           return true;
         }
       });
-      indexerPort = parseInt(portInput);
+      indexerPort = Number.parseInt(portInput);
     }
   }
   const config = await loadConfig();
@@ -14126,7 +14178,10 @@ async function runSetupWizard() {
   console.log(formatKeyValue([
     ["  Install path", installPath],
     ["  Network", network],
-    ["  Auto-start indexer", autoStartIndexer ? `Yes (port ${indexerPort})` : "No"]
+    [
+      "  Auto-start indexer",
+      autoStartIndexer ? `Yes (port ${indexerPort})` : "No"
+    ]
   ]));
   console.log("");
   console.log(dim("Next steps:"));
@@ -14357,8 +14412,14 @@ async function showStatus(pathOverride, jsonOutput) {
   if (nodeInfo) {
     console.log(blue("Chain Info"));
     console.log(formatKeyValue([
-      ["  Stacks Height", nodeInfo.stacks_tip_height?.toString() || "syncing..."],
-      ["  Burn Height", nodeInfo.burn_block_height?.toString() || "syncing..."],
+      [
+        "  Stacks Height",
+        nodeInfo.stacks_tip_height?.toString() || "syncing..."
+      ],
+      [
+        "  Burn Height",
+        nodeInfo.burn_block_height?.toString() || "syncing..."
+      ],
       ["  Peers", peerCount.toString()],
       ["  Version", nodeInfo.server_version || "unknown"]
     ]));
@@ -14447,11 +14508,11 @@ async function showConfigCheck(indexerPort) {
 }
 var DEFAULT_RPC_PORT = 20443;
 var init_node_impl = __esm(() => {
+  init_api_client();
   init_config();
+  init_network();
   init_node_manager();
   init_output();
-  init_api_client();
-  init_network();
 });
 
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -20467,197 +20528,16 @@ var init_plugin_manager = __esm(() => {
   validateStacksAddress = _validateStacksAddress;
 });
 
-// src/utils/config.ts
-import { promises as fs4 } from "fs";
-import path2 from "path";
-import { tmpdir } from "os";
-import { randomBytes } from "crypto";
-import { pathToFileURL } from "url";
-import { createRequire as createRequire2 } from "module";
-async function findConfigFile(cwd) {
-  for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path2.join(cwd, fileName);
-    try {
-      await fs4.access(filePath);
-      return filePath;
-    } catch {}
-  }
-  return null;
-}
-async function loadConfig2(configPath) {
-  const cwd = process.cwd();
-  const resolvedPath = configPath ? path2.resolve(cwd, configPath) : await findConfigFile(cwd);
-  if (!resolvedPath) {
-    throw new Error("No config file found. Create a secondlayer.config.ts file or specify a path with --config");
-  }
-  let config;
-  if (resolvedPath.endsWith(".ts")) {
-    const code = await fs4.readFile(resolvedPath, "utf-8");
-    let replacementPath;
-    try {
-      const require2 = createRequire2(import.meta.url);
-      const packagePath = require2.resolve("@secondlayer/cli");
-      replacementPath = pathToFileURL(packagePath).href;
-    } catch {
-      const currentModuleDir = path2.dirname(new URL(import.meta.url).pathname);
-      const indexPath = path2.resolve(currentModuleDir, "../index");
-      replacementPath = pathToFileURL(indexPath).href;
-    }
-    const transformedCode = code.replace(/from\s+["']@secondlayer\/cli["']/g, `from '${replacementPath}'`);
-    const { transformSync } = await import("esbuild");
-    const result = transformSync(transformedCode, {
-      format: "esm",
-      target: "node18",
-      loader: "ts"
-    });
-    const tempPath = path2.join(tmpdir(), `secondlayer-config-${randomBytes(4).toString("hex")}.mjs`);
-    await fs4.writeFile(tempPath, result.code);
-    try {
-      const fileUrl = pathToFileURL(tempPath).href;
-      const module = await import(fileUrl);
-      config = module.default;
-    } finally {
-      await fs4.unlink(tempPath).catch(() => {});
-    }
-  } else {
-    const fileUrl = pathToFileURL(resolvedPath).href;
-    const module = await import(fileUrl);
-    config = module.default;
-  }
-  if (!config) {
-    throw new Error("Config file must export a default configuration");
-  }
-  if (typeof config === "function") {
-    config = config({});
-  }
-  validateConfig(config);
-  const pluginManager = new PluginManager;
-  if (config.plugins && Array.isArray(config.plugins)) {
-    for (const plugin of config.plugins) {
-      pluginManager.register(plugin);
-    }
-  }
-  const resolvedConfig = await pluginManager.transformConfig(config);
-  return resolvedConfig;
-}
-function validateConfig(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("Config must be an object");
-  }
-  const c = config;
-  if (c.contracts && !Array.isArray(c.contracts)) {
-    throw new Error("Config contracts must be an array");
-  }
-  if (!c.out || typeof c.out !== "string") {
-    throw new Error("Config out must be a string path");
-  }
-  if (c.contracts) {
-    for (const contract of c.contracts) {
-      if (!contract.address && !contract.source) {
-        throw new Error("Each contract must have either an address or source");
-      }
-    }
-  }
-  if (c.plugins && !Array.isArray(c.plugins)) {
-    throw new Error("Config plugins must be an array");
-  }
-}
-var CONFIG_FILE_NAMES;
-var init_config2 = __esm(() => {
-  init_plugin_manager();
-  CONFIG_FILE_NAMES = [
-    "secondlayer.config.ts",
-    "secondlayer.config",
-    "secondlayer.config.mjs"
-  ];
-});
-
-// src/utils/type-mapping.ts
+// src/utils/clarity-conversion.ts
 import {
-  toCamelCase as toCamelCase3,
+  isAbiBuffer as isAbiBuffer2,
   isAbiList,
-  isAbiTuple,
   isAbiOptional as isAbiOptional2,
   isAbiResponse,
-  isAbiBuffer as isAbiBuffer2,
   isAbiStringAscii as isAbiStringAscii2,
-  isAbiStringUtf8 as isAbiStringUtf82
-} from "@secondlayer/stacks/clarity";
-function clarityTypeToTS(type) {
-  if (typeof type === "string") {
-    switch (type) {
-      case "uint128":
-      case "int128":
-        return "bigint";
-      case "bool":
-        return "boolean";
-      case "principal":
-      case "trait_reference":
-        return "string";
-      default: {
-        const typeStr = type;
-        if (typeStr === "none") {
-          return "null";
-        }
-        if (typeStr.includes("string") || typeStr.includes("ascii") || typeStr.includes("utf8")) {
-          return "string";
-        }
-        if (typeStr.includes("buff")) {
-          return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-        }
-        if (typeStr.includes("uint") || typeStr.includes("int")) {
-          return "bigint";
-        }
-        return "any";
-      }
-    }
-  }
-  if (isAbiBuffer2(type)) {
-    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
-  }
-  if (isAbiStringAscii2(type) || isAbiStringUtf82(type)) {
-    return "string";
-  }
-  if (isAbiOptional2(type)) {
-    const innerType = clarityTypeToTS(type.optional);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType}) | null`;
-    }
-    return `${innerType} | null`;
-  }
-  if (isAbiList(type)) {
-    const innerType = clarityTypeToTS(type.list.type);
-    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
-      return `(${innerType})[]`;
-    }
-    return `${innerType}[]`;
-  }
-  if (isAbiTuple(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase3(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
-    return `{ ${fields} }`;
-  }
-  if (isAbiResponse(type)) {
-    const okType = clarityTypeToTS(type.response.ok);
-    const errType = clarityTypeToTS(type.response.error);
-    return `{ ok: ${okType} } | { err: ${errType} }`;
-  }
-  return "any";
-}
-function getTypeForArg(arg) {
-  return clarityTypeToTS(arg.type);
-}
-var init_type_mapping = () => {};
-
-// src/utils/clarity-conversion.ts
-import {
-  toCamelCase as toCamelCase4,
-  isAbiStringAscii as isAbiStringAscii3,
-  isAbiStringUtf8 as isAbiStringUtf83,
-  isAbiBuffer as isAbiBuffer3,
-  isAbiOptional as isAbiOptional3,
-  isAbiList as isAbiList2,
-  isAbiTuple as isAbiTuple2,
-  isAbiResponse as isAbiResponse2
+  isAbiStringUtf8 as isAbiStringUtf82,
+  isAbiTuple,
+  toCamelCase as toCamelCase3
 } from "@secondlayer/stacks/clarity";
 function generateClarityConversion(argName, argType) {
   const type = argType.type;
@@ -20688,13 +20568,13 @@ function generateClarityConversion(argName, argType) {
         return `${argName}`;
     }
   }
-  if (isAbiStringAscii3(type)) {
+  if (isAbiStringAscii2(type)) {
     return `Cl.stringAscii(${argName})`;
   }
-  if (isAbiStringUtf83(type)) {
+  if (isAbiStringUtf82(type)) {
     return `Cl.stringUtf8(${argName})`;
   }
-  if (isAbiBuffer3(type)) {
+  if (isAbiBuffer2(type)) {
     return `(() => {
       const value = ${argName};
       if (value instanceof Uint8Array) {
@@ -20725,13 +20605,13 @@ function generateClarityConversion(argName, argType) {
       throw new Error(\`Invalid buffer value: \${value}\`);
     })()`;
   }
-  if (isAbiOptional3(type)) {
+  if (isAbiOptional2(type)) {
     const innerConversion = generateClarityConversion(argName, {
       type: type.optional
     });
     return `${argName} !== null ? Cl.some(${innerConversion.replace(argName, `${argName}`)}) : Cl.none()`;
   }
-  if (isAbiList2(type)) {
+  if (isAbiList(type)) {
     const innerConversion = generateClarityConversion("item", {
       type: type.list.type
     });
@@ -20744,11 +20624,11 @@ function generateClarityConversion(argName, argType) {
       return Cl.list(listValue.map(item => ${innerConversion}));
     })()`;
   }
-  if (isAbiTuple2(type)) {
+  if (isAbiTuple(type)) {
     const requiredFields = type.tuple.map((f) => f.name);
     const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase4(field.name);
+      const camelFieldName = toCamelCase3(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20764,7 +20644,7 @@ function generateClarityConversion(argName, argType) {
       return Cl.tuple({ ${fields} });
     })()`;
   }
-  if (isAbiResponse2(type)) {
+  if (isAbiResponse(type)) {
     const okConversion = generateClarityConversion(`responseValue.ok`, {
       type: type.response.ok
     });
@@ -20788,8 +20668,87 @@ function generateClarityConversion(argName, argType) {
 }
 var init_clarity_conversion = () => {};
 
+// src/utils/type-mapping.ts
+import {
+  isAbiBuffer as isAbiBuffer3,
+  isAbiList as isAbiList2,
+  isAbiOptional as isAbiOptional3,
+  isAbiResponse as isAbiResponse2,
+  isAbiStringAscii as isAbiStringAscii3,
+  isAbiStringUtf8 as isAbiStringUtf83,
+  isAbiTuple as isAbiTuple2,
+  toCamelCase as toCamelCase4
+} from "@secondlayer/stacks/clarity";
+function clarityTypeToTS(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+        return "bigint";
+      case "bool":
+        return "boolean";
+      case "principal":
+      case "trait_reference":
+        return "string";
+      default: {
+        const typeStr = type;
+        if (typeStr === "none") {
+          return "null";
+        }
+        if (typeStr.includes("string") || typeStr.includes("ascii") || typeStr.includes("utf8")) {
+          return "string";
+        }
+        if (typeStr.includes("buff")) {
+          return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+        }
+        if (typeStr.includes("uint") || typeStr.includes("int")) {
+          return "bigint";
+        }
+        return "any";
+      }
+    }
+  }
+  if (isAbiBuffer3(type)) {
+    return "Uint8Array | string | { type: 'ascii' | 'utf8' | 'hex'; value: string }";
+  }
+  if (isAbiStringAscii3(type) || isAbiStringUtf83(type)) {
+    return "string";
+  }
+  if (isAbiOptional3(type)) {
+    const innerType = clarityTypeToTS(type.optional);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType}) | null`;
+    }
+    return `${innerType} | null`;
+  }
+  if (isAbiList2(type)) {
+    const innerType = clarityTypeToTS(type.list.type);
+    if (innerType.includes(" | ") && !innerType.startsWith("(")) {
+      return `(${innerType})[]`;
+    }
+    return `${innerType}[]`;
+  }
+  if (isAbiTuple2(type)) {
+    const fields = type.tuple.map((field) => `${toCamelCase4(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    return `{ ${fields} }`;
+  }
+  if (isAbiResponse2(type)) {
+    const okType = clarityTypeToTS(type.response.ok);
+    const errType = clarityTypeToTS(type.response.error);
+    return `{ ok: ${okType} } | { err: ${errType} }`;
+  }
+  return "any";
+}
+function getTypeForArg(arg) {
+  return clarityTypeToTS(arg.type);
+}
+var init_type_mapping = () => {};
+
 // src/utils/generator-helpers.ts
-import { toCamelCase as toCamelCase5, isAbiTuple as isAbiTuple3 } from "@secondlayer/stacks/clarity";
+import {
+  isAbiTuple as isAbiTuple3,
+  toCamelCase as toCamelCase5
+} from "@secondlayer/stacks/clarity";
 function generateMapKeyConversion(keyType) {
   if (isAbiTuple3(keyType)) {
     const fields = keyType.tuple.map((field) => {
@@ -20802,8 +20761,8 @@ function generateMapKeyConversion(keyType) {
   return generateClarityConversion("key", { type: keyType });
 }
 var init_generator_helpers = __esm(() => {
-  init_type_mapping();
   init_clarity_conversion();
+  init_type_mapping();
 });
 
 // src/generators/contract.ts
@@ -21104,10 +21063,115 @@ function generateConstantsObject(variables, address, contractName) {
   }`;
 }
 var init_contract = __esm(() => {
-  init_format();
-  init_type_mapping();
   init_clarity_conversion();
+  init_format();
   init_generator_helpers();
+  init_type_mapping();
+});
+
+// src/utils/config.ts
+import { randomBytes } from "crypto";
+import { promises as fs4 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { tmpdir } from "os";
+import path2 from "path";
+import { pathToFileURL } from "url";
+async function findConfigFile(cwd) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = path2.join(cwd, fileName);
+    try {
+      await fs4.access(filePath);
+      return filePath;
+    } catch {}
+  }
+  return null;
+}
+async function loadConfig2(configPath) {
+  const cwd = process.cwd();
+  const resolvedPath = configPath ? path2.resolve(cwd, configPath) : await findConfigFile(cwd);
+  if (!resolvedPath) {
+    throw new Error("No config file found. Create a secondlayer.config.ts file or specify a path with --config");
+  }
+  let config;
+  if (resolvedPath.endsWith(".ts")) {
+    const code = await fs4.readFile(resolvedPath, "utf-8");
+    let replacementPath;
+    try {
+      const require2 = createRequire2(import.meta.url);
+      const packagePath = require2.resolve("@secondlayer/cli");
+      replacementPath = pathToFileURL(packagePath).href;
+    } catch {
+      const currentModuleDir = path2.dirname(new URL(import.meta.url).pathname);
+      const indexPath = path2.resolve(currentModuleDir, "../index");
+      replacementPath = pathToFileURL(indexPath).href;
+    }
+    const transformedCode = code.replace(/from\s+["']@secondlayer\/cli["']/g, `from '${replacementPath}'`);
+    const { transformSync } = await import("esbuild");
+    const result = transformSync(transformedCode, {
+      format: "esm",
+      target: "node18",
+      loader: "ts"
+    });
+    const tempPath = path2.join(tmpdir(), `secondlayer-config-${randomBytes(4).toString("hex")}.mjs`);
+    await fs4.writeFile(tempPath, result.code);
+    try {
+      const fileUrl = pathToFileURL(tempPath).href;
+      const module = await import(fileUrl);
+      config = module.default;
+    } finally {
+      await fs4.unlink(tempPath).catch(() => {});
+    }
+  } else {
+    const fileUrl = pathToFileURL(resolvedPath).href;
+    const module = await import(fileUrl);
+    config = module.default;
+  }
+  if (!config) {
+    throw new Error("Config file must export a default configuration");
+  }
+  if (typeof config === "function") {
+    config = config({});
+  }
+  validateConfig(config);
+  const pluginManager = new PluginManager;
+  if (config.plugins && Array.isArray(config.plugins)) {
+    for (const plugin of config.plugins) {
+      pluginManager.register(plugin);
+    }
+  }
+  const resolvedConfig = await pluginManager.transformConfig(config);
+  return resolvedConfig;
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Config must be an object");
+  }
+  const c = config;
+  if (c.contracts && !Array.isArray(c.contracts)) {
+    throw new Error("Config contracts must be an array");
+  }
+  if (!c.out || typeof c.out !== "string") {
+    throw new Error("Config out must be a string path");
+  }
+  if (c.contracts) {
+    for (const contract of c.contracts) {
+      if (!contract.address && !contract.source) {
+        throw new Error("Each contract must have either an address or source");
+      }
+    }
+  }
+  if (c.plugins && !Array.isArray(c.plugins)) {
+    throw new Error("Config plugins must be an array");
+  }
+}
+var CONFIG_FILE_NAMES;
+var init_config2 = __esm(() => {
+  init_plugin_manager();
+  CONFIG_FILE_NAMES = [
+    "secondlayer.config.ts",
+    "secondlayer.config",
+    "secondlayer.config.mjs"
+  ];
 });
 
 // ../../node_modules/ansis/index.cjs
@@ -32229,8 +32293,8 @@ async function checkBaseDependencies(targetDir) {
 var BASE_DEPENDENCIES;
 var init_dependencies = __esm(() => {
   init_dist4();
-  init_execa();
   init_source4();
+  init_execa();
   BASE_DEPENDENCIES = {
     dependencies: ["@secondlayer/stacks"],
     devDependencies: []
@@ -32245,8 +32309,8 @@ __export(exports_generate, {
   generate: () => generate
 });
 import path10 from "path";
-import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
+import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
 function isContractAddress(input4) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
   return contractIdPattern.test(input4);
@@ -32475,11 +32539,11 @@ async function resolveContracts(source, defaultNetwork, apiKey, apiUrl) {
 var import_fast_glob, DEFAULT_DEVNET_ADDRESS = "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM";
 var init_generate = __esm(() => {
   init_source4();
-  init_config2();
-  init_api();
-  init_clarity();
-  init_contract();
   init_plugin_manager();
+  init_contract();
+  init_clarity();
+  init_api();
+  init_config2();
   init_dependencies();
   import_fast_glob = __toESM(require_out4(), 1);
 });
@@ -32552,7 +32616,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "1.6.8",
+  version: "1.8.0",
   description: "CLI for streams, subgraphs, and real-time blockchain indexing on Stacks",
   type: "module",
   bin: {
@@ -32593,10 +32657,10 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
-    "@secondlayer/sdk": "^0.6.4",
-    "@secondlayer/shared": "^0.7.0",
+    "@secondlayer/sdk": "^0.8.0",
+    "@secondlayer/shared": "^0.8.0",
     "@secondlayer/stacks": "^0.2.2",
-    "@secondlayer/subgraphs": "^0.5.7",
+    "@secondlayer/subgraphs": "^0.7.0",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
     esbuild: "^0.19.0",
@@ -32984,10 +33048,10 @@ async function validateDatabaseConnection(url) {
   }
 }
 // src/commands/setup.ts
-init_output();
 init_api_client();
-import { select as select2, input, confirm } from "@inquirer/prompts";
 init_config();
+import { confirm, input, select as select2 } from "@inquirer/prompts";
+init_output();
 var STREAMS_DIR = "streams";
 function registerSetupCommand(program2) {
   program2.command("setup").description("Set up a streams project and configure settings").option("--detect-only", "Only detect existing Stacks nodes, don't initialize").option("-y, --yes", "Use defaults without prompts").option("--data-dir <path>", "Data directory path").option("--node-path <path>", "Path to Stacks node").option("--network <network>", "Network (local, testnet, or mainnet)").option("--endpoint-url <url>", "Default endpoint URL for new streams").action(async (options) => {
@@ -33050,9 +33114,15 @@ async function runWizard() {
   const network = await select2({
     message: "How do you want to use Stacks Streams?",
     choices: [
-      { name: "Hosted mainnet (recommended — zero setup)", value: "mainnet" },
+      {
+        name: "Hosted mainnet (recommended — zero setup)",
+        value: "mainnet"
+      },
       { name: "Hosted testnet", value: "testnet" },
-      { name: "Local development (run your own node + services)", value: "local" }
+      {
+        name: "Local development (run your own node + services)",
+        value: "local"
+      }
     ]
   });
   config.network = network;
@@ -33262,14 +33332,22 @@ async function hostedLogin(config) {
   }
   const result = await verifyRes.json();
   const { hostname } = await import("node:os");
-  const sessionHeaders = { Authorization: `Bearer ${result.sessionToken}`, "Content-Type": "application/json" };
+  const sessionHeaders = {
+    Authorization: `Bearer ${result.sessionToken}`,
+    "Content-Type": "application/json"
+  };
   const keyName = `cli-${hostname().toLowerCase()}`;
-  const listRes = await fetch(`${apiUrl}/api/keys`, { headers: sessionHeaders });
+  const listRes = await fetch(`${apiUrl}/api/keys`, {
+    headers: sessionHeaders
+  });
   if (listRes.ok) {
     const { keys } = await listRes.json();
     const existing = keys.find((k) => k.name === keyName && k.status === "active");
     if (existing) {
-      await fetch(`${apiUrl}/api/keys/${existing.id}`, { method: "DELETE", headers: sessionHeaders });
+      await fetch(`${apiUrl}/api/keys/${existing.id}`, {
+        method: "DELETE",
+        headers: sessionHeaders
+      });
     }
   }
   const createRes = await fetch(`${apiUrl}/api/keys`, {
@@ -33287,7 +33365,10 @@ async function hostedLogin(config) {
   config.apiKey = key;
   await saveConfig(config);
   try {
-    await fetch(`${apiUrl}/api/auth/logout`, { method: "POST", headers: sessionHeaders });
+    await fetch(`${apiUrl}/api/auth/logout`, {
+      method: "POST",
+      headers: sessionHeaders
+    });
   } catch {}
   const account = result.account;
   console.log();
@@ -33355,97 +33436,28 @@ function printNodeInfo(node) {
   console.log(`           network: ${node.network}, source: ${source}
 `);
 }
-// src/commands/new.ts
-import { join as join3 } from "node:path";
-
-// src/templates/stream.ts
-function generateStreamTemplate(name, endpointUrl) {
-  return {
-    name,
-    endpointUrl: endpointUrl || "https://example.com/endpoint",
-    filters: [
-      {
-        type: "contract_call",
-        contractId: "SP000000000000000000002Q6VF78.pox-4"
-      }
-    ],
-    options: {
-      decodeClarityValues: true,
-      includeRawTx: false,
-      includeBlockMetadata: true,
-      rateLimit: 10,
-      timeoutMs: 1e4,
-      maxRetries: 3
-    }
-  };
-}
-
-// src/commands/new.ts
-init_output();
-init_config();
-init_fs();
-var STREAMS_DIR2 = "streams";
-function registerNewCommand(program2) {
-  program2.command("new <name>").description("Generate a new stream configuration file").option("-o, --output <path>", "Output path (default: streams/<name>.json)").action(async (name, options) => {
-    try {
-      const config = await loadConfig();
-      const outputPath = options.output || join3(STREAMS_DIR2, `${name}.json`);
-      if (await fileExists(outputPath)) {
-        warn(`File already exists: ${outputPath}`);
-        process.exit(1);
-      }
-      const dir = outputPath.substring(0, outputPath.lastIndexOf("/"));
-      if (dir) {
-        await ensureDir(dir);
-      }
-      const template = generateStreamTemplate(name, config.defaultEndpointUrl);
-      await writeTextFile(outputPath, JSON.stringify(template, null, 2) + `
-`);
-      success(`Created ${outputPath}`);
-      if (!config.defaultEndpointUrl) {
-        warn("Edit the endpointUrl before registering — it must be a reachable HTTPS endpoint");
-      }
-      console.log(`
-Edit the file to configure your stream, then run:`);
-      console.log(`  sl streams register ${outputPath}`);
-    } catch (err) {
-      error(`Failed to create stream: ${err}`);
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/list.ts
+// src/commands/delete.ts
 init_api_client();
 init_output();
-function registerListCommand(program2) {
-  program2.command("list").alias("ls").description("List all streams").option("-s, --status <status>", "Filter by status (inactive/active/paused/failed)").option("--json", "Output as JSON").action(async (options) => {
+import { confirm as confirm2 } from "@inquirer/prompts";
+function registerDeleteCommand(program2) {
+  program2.command("delete <id>").alias("rm").description("Delete a stream").option("-f, --force", "Skip confirmation prompt").action(async (id, options) => {
     try {
-      const { streams, total } = await listStreams({
-        status: options.status
-      });
-      if (options.json) {
-        console.log(JSON.stringify(streams, null, 2));
-        return;
-      }
-      if (streams.length === 0) {
-        console.log("No streams found");
-        return;
+      const stream = await getStream(id);
+      if (!options.force) {
+        const confirmed = await confirm2({
+          message: `Delete stream "${stream.name}" (${stream.id})?`,
+          default: false
+        });
+        if (!confirmed) {
+          warn("Aborted");
+          return;
+        }
       }
-      const rows = streams.map((s) => {
-        const statusColor = s.status === "active" ? green : s.status === "failed" ? red : s.status === "paused" ? yellow : dim;
-        return [
-          s.id.slice(0, 8),
-          s.name,
-          statusColor(s.status),
-          s.totalDeliveries.toString()
-        ];
-      });
-      console.log(formatTable(["ID", "Name", "Status", "Deliveries"], rows));
-      console.log(dim(`
-${total} stream(s) total`));
+      await deleteStream(id);
+      success(`Deleted stream: ${stream.name}`);
     } catch (err) {
-      handleApiError(err, "list streams");
+      handleApiError(err, "delete stream");
     }
   });
 }
@@ -33490,280 +33502,44 @@ ${dim("Options:")}`);
   });
 }
 
-// src/commands/register.ts
-init_api_client();
-init_output();
-init_fs();
-import { CreateStreamSchema } from "@secondlayer/shared/schemas";
-function registerRegisterCommand(program2) {
-  program2.command("register <file>").description("Register a stream from a JSON configuration file").option("-u, --update", "Update existing stream if name matches").action(async (filePath, options) => {
-    try {
-      if (!await fileExists(filePath)) {
-        error(`File not found: ${filePath}`);
-        process.exit(1);
-      }
-      const content = await readJsonFile(filePath);
-      const parsed = CreateStreamSchema.safeParse(content);
-      if (!parsed.success) {
-        error("Invalid stream configuration:");
-        for (const issue of parsed.error.issues) {
-          console.log(`  - ${issue.path.join(".")}: ${issue.message}`);
-        }
-        process.exit(1);
-      }
-      const streamData = parsed.data;
-      if (options.update) {
-        try {
-          const updated = await updateStreamByName(streamData.name, streamData);
-          success(`Updated stream: ${updated.name}`);
-          console.log(formatKeyValue([
-            ["ID", updated.id],
-            ["Name", updated.name]
-          ]));
-          return;
-        } catch (err) {
-          if (err instanceof ApiError && err.status === 404) {
-            warn("Stream not found, creating new...");
-          } else {
-            throw err;
-          }
-        }
-      }
-      const result = await createStream(streamData);
-      success(`Registered stream: ${result.stream.name}`);
-      console.log(formatKeyValue([
-        ["ID", result.stream.id],
-        ["Name", result.stream.name],
-        ["Signing Secret", result.signingSecret]
-      ]));
-      console.log(dim(`
-Save the signing secret - it won't be shown again!`));
-    } catch (err) {
-      handleApiError(err, "register stream");
-    }
-  });
-}
-
-// src/commands/delete.ts
-init_api_client();
-init_output();
-import { confirm as confirm2 } from "@inquirer/prompts";
-function registerDeleteCommand(program2) {
-  program2.command("delete <id>").alias("rm").description("Delete a stream").option("-f, --force", "Skip confirmation prompt").action(async (id, options) => {
-    try {
-      const stream = await getStream(id);
-      if (!options.force) {
-        const confirmed = await confirm2({
-          message: `Delete stream "${stream.name}" (${stream.id})?`,
-          default: false
-        });
-        if (!confirmed) {
-          warn("Aborted");
-          return;
-        }
-      }
-      await deleteStream(id);
-      success(`Deleted stream: ${stream.name}`);
-    } catch (err) {
-      handleApiError(err, "delete stream");
-    }
-  });
-}
-
-// src/commands/set.ts
-init_config();
+// src/commands/list.ts
 init_api_client();
 init_output();
-function registerSetCommand(program2) {
-  program2.command("set [id] [state]").description("Set stream state (active, disabled, paused)").option("--all", "Apply to all streams").option("--wait", "Wait for pending jobs to complete (with paused)").option("--retry", "Re-enable an errored stream").option("--replay-failed", "Also replay failed deliveries (with --retry)").option("-o, --option <kv...>", "Set stream option (key=value, e.g. maxRetries=5)").action(async (id, state, options) => {
+function registerListCommand(program2) {
+  program2.command("list").alias("ls").description("List all streams").option("-s, --status <status>", "Filter by status (inactive/active/paused/failed)").option("--json", "Output as JSON").action(async (options) => {
     try {
-      if (options.retry) {
-        if (!id) {
-          error("Stream ID is required with --retry");
-          process.exit(1);
-        }
-        await retryStream(id, options.replayFailed);
+      const { streams, total } = await listStreams({
+        status: options.status
+      });
+      if (options.json) {
+        console.log(JSON.stringify(streams, null, 2));
         return;
       }
-      if (options.all) {
-        if (!state) {
-          error("State is required: sl streams set --all <active|paused>");
-          process.exit(1);
-        }
-        await setAllStreams(state, options.wait);
+      if (streams.length === 0) {
+        console.log("No streams found");
         return;
       }
-      if (options.option?.length) {
-        if (!id) {
-          error("Stream ID is required with --option");
-          process.exit(1);
-        }
-        const parsedOptions = parseOptions2(options.option);
-        await updateStream(id, { options: parsedOptions });
-        success(`Updated stream options: ${Object.entries(parsedOptions).map(([k, v]) => `${k}=${v}`).join(", ")}`);
-        if (!state)
-          return;
-      }
-      if (!id || !state) {
-        error("Usage: sl streams set <id> <active|disabled>");
-        console.log(dim(`
-Examples:`));
-        console.log(dim("  sl streams set <id> active"));
-        console.log(dim("  sl streams set <id> disabled"));
-        console.log(dim("  sl streams set --all paused --wait"));
-        console.log(dim("  sl streams set <id> --retry --replay-failed"));
-        console.log(dim("  sl streams set <id> --option maxRetries=5"));
-        process.exit(1);
-      }
-      await setSingleStream(id, state);
+      const rows = streams.map((s) => {
+        const statusColor = s.status === "active" ? green : s.status === "failed" ? red : s.status === "paused" ? yellow : dim;
+        return [
+          s.id.slice(0, 8),
+          s.name,
+          statusColor(s.status),
+          s.totalDeliveries.toString()
+        ];
+      });
+      console.log(formatTable(["ID", "Name", "Status", "Deliveries"], rows));
+      console.log(dim(`
+${total} stream(s) total`));
     } catch (err) {
-      handleApiError(err, "set stream state");
-    }
-  });
-}
-async function setSingleStream(id, state) {
-  switch (state) {
-    case "active": {
-      const stream = await enableStream(id);
-      success(`Enabled stream: ${stream.name} (status: active)`);
-      break;
-    }
-    case "disabled": {
-      const stream = await disableStream(id);
-      success(`Disabled stream: ${stream.name} (status: inactive)`);
-      break;
-    }
-    default:
-      error(`Unknown state: ${state}. Use active, disabled, or paused (with --all)`);
-      process.exit(1);
-  }
-}
-async function setAllStreams(state, wait) {
-  switch (state) {
-    case "paused": {
-      const result = await pauseAllStreams();
-      if (result.paused === 0) {
-        info("No active streams to pause");
-        return;
-      }
-      success(`Paused ${result.paused} stream${result.paused === 1 ? "" : "s"}`);
-      if (wait) {
-        await waitForQueueDrain();
-      }
-      break;
-    }
-    case "active": {
-      const result = await resumeAllStreams();
-      if (result.resumed === 0) {
-        info("No paused streams to resume");
-        return;
-      }
-      success(`Resumed ${result.resumed} stream${result.resumed === 1 ? "" : "s"}`);
-      break;
+      handleApiError(err, "list streams");
     }
-    default:
-      error(`Unknown state for --all: ${state}. Use active or paused`);
-      process.exit(1);
-  }
-}
-async function retryStream(id, replayFailed) {
-  const config = await loadConfig();
-  const apiUrl = resolveApiUrl(config);
-  const getRes = await fetch(`${apiUrl}/api/streams/${id}`, {
-    headers: authHeaders(config)
   });
-  if (!getRes.ok) {
-    const body = await getRes.text();
-    throw new Error(parseError2(getRes.status, body));
-  }
-  const stream = await getRes.json();
-  if (stream.status !== "failed") {
-    warn(`Stream is not in failed status (current status: ${stream.status})`);
-    console.log(dim(`
-Use 'sl streams set <id> active' to enable an inactive stream.`));
-    process.exit(1);
-  }
-  if (stream.errorMessage) {
-    console.log(red(`Previous error: ${stream.errorMessage}`));
-    console.log("");
-  }
-  const enableRes = await fetch(`${apiUrl}/streams/${id}/enable`, {
-    method: "POST",
-    headers: authHeaders(config)
-  });
-  if (!enableRes.ok) {
-    const body = await enableRes.text();
-    throw new Error(parseError2(enableRes.status, body));
-  }
-  success(`Re-enabled stream: ${stream.name}`);
-  if (replayFailed) {
-    info("Replaying failed deliveries...");
-    const replayRes = await fetch(`${apiUrl}/streams/${id}/replay-failed`, {
-      method: "POST",
-      headers: authHeaders(config)
-    });
-    if (!replayRes.ok) {
-      const body = await replayRes.text();
-      warn(`Failed to replay: ${parseError2(replayRes.status, body)}`);
-    } else {
-      const result = await replayRes.json();
-      success(`Enqueued ${result.jobCount} replay jobs`);
-    }
-  }
-  console.log(dim(`
-Monitor with: sl streams logs ` + id + " -f"));
-}
-async function waitForQueueDrain() {
-  const POLL_INTERVAL_MS = 1000;
-  process.stdout.write(dim("Waiting for jobs to complete..."));
-  while (true) {
-    const stats = await getQueueStats();
-    const active = stats.pending + stats.processing;
-    if (active === 0) {
-      process.stdout.write(`
-`);
-      success("All jobs completed");
-      return;
-    }
-    process.stdout.write(`\r${dim(`Waiting for jobs to complete... ${active} remaining`)}`);
-    await Bun.sleep(POLL_INTERVAL_MS);
-  }
-}
-function parseOptions2(kvPairs) {
-  const result = {};
-  for (const kv of kvPairs) {
-    const eqIndex = kv.indexOf("=");
-    if (eqIndex === -1) {
-      throw new Error(`Invalid option format: "${kv}". Use key=value.`);
-    }
-    const key = kv.slice(0, eqIndex);
-    const raw = kv.slice(eqIndex + 1);
-    if (raw === "true")
-      result[key] = true;
-    else if (raw === "false")
-      result[key] = false;
-    else if (raw !== "" && !isNaN(Number(raw)))
-      result[key] = Number(raw);
-    else
-      result[key] = raw;
-  }
-  return result;
-}
-function parseError2(status, body) {
-  let message = `HTTP ${status}`;
-  try {
-    const json = JSON.parse(body);
-    message = json.error || json.message || message;
-  } catch {
-    if (body)
-      message = body;
-  }
-  return message;
 }
 
 // src/commands/logs.ts
-init_config();
 init_api_client();
+init_config();
 init_output();
 function registerLogsCommand(program2) {
   program2.command("logs <stream-id>").description("View delivery logs for a stream").option("-f, --follow", "Follow logs in real-time").option("-n, --limit <count>", "Number of logs to show", "20").option("-s, --status <status>", "Filter by status (success|failed)").action(async (streamId, options) => {
@@ -33773,7 +33549,7 @@ function registerLogsCommand(program2) {
       if (options.follow) {
         await followLogs(resolveApiUrl(config), fullId, config, options.status);
       } else {
-        await showRecentLogs(resolveApiUrl(config), fullId, parseInt(options.limit), config, options.status);
+        await showRecentLogs(resolveApiUrl(config), fullId, Number.parseInt(options.limit), config, options.status);
       }
     } catch (err) {
       handleApiError(err, "get logs");
@@ -33884,9 +33660,123 @@ function printDelivery(d) {
   }
 }
 
-// src/commands/replay.ts
+// src/commands/new.ts
 init_config();
+init_fs();
+init_output();
+import { join as join3 } from "node:path";
+
+// src/templates/stream.ts
+function generateStreamTemplate(name, endpointUrl) {
+  return {
+    name,
+    endpointUrl: endpointUrl || "https://example.com/endpoint",
+    filters: [
+      {
+        type: "contract_call",
+        contractId: "SP000000000000000000002Q6VF78.pox-4"
+      }
+    ],
+    options: {
+      decodeClarityValues: true,
+      includeRawTx: false,
+      includeBlockMetadata: true,
+      rateLimit: 10,
+      timeoutMs: 1e4,
+      maxRetries: 3
+    }
+  };
+}
+
+// src/commands/new.ts
+var STREAMS_DIR2 = "streams";
+function registerNewCommand(program2) {
+  program2.command("new <name>").description("Generate a new stream configuration file").option("-o, --output <path>", "Output path (default: streams/<name>.json)").action(async (name, options) => {
+    try {
+      const config = await loadConfig();
+      const outputPath = options.output || join3(STREAMS_DIR2, `${name}.json`);
+      if (await fileExists(outputPath)) {
+        warn(`File already exists: ${outputPath}`);
+        process.exit(1);
+      }
+      const dir = outputPath.substring(0, outputPath.lastIndexOf("/"));
+      if (dir) {
+        await ensureDir(dir);
+      }
+      const template = generateStreamTemplate(name, config.defaultEndpointUrl);
+      await writeTextFile(outputPath, JSON.stringify(template, null, 2) + `
+`);
+      success(`Created ${outputPath}`);
+      if (!config.defaultEndpointUrl) {
+        warn("Edit the endpointUrl before registering — it must be a reachable HTTPS endpoint");
+      }
+      console.log(`
+Edit the file to configure your stream, then run:`);
+      console.log(`  sl streams register ${outputPath}`);
+    } catch (err) {
+      error(`Failed to create stream: ${err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/register.ts
 init_api_client();
+init_fs();
+init_output();
+import { CreateStreamSchema } from "@secondlayer/shared/schemas";
+function registerRegisterCommand(program2) {
+  program2.command("register <file>").description("Register a stream from a JSON configuration file").option("-u, --update", "Update existing stream if name matches").action(async (filePath, options) => {
+    try {
+      if (!await fileExists(filePath)) {
+        error(`File not found: ${filePath}`);
+        process.exit(1);
+      }
+      const content = await readJsonFile(filePath);
+      const parsed = CreateStreamSchema.safeParse(content);
+      if (!parsed.success) {
+        error("Invalid stream configuration:");
+        for (const issue of parsed.error.issues) {
+          console.log(`  - ${issue.path.join(".")}: ${issue.message}`);
+        }
+        process.exit(1);
+      }
+      const streamData = parsed.data;
+      if (options.update) {
+        try {
+          const updated = await updateStreamByName(streamData.name, streamData);
+          success(`Updated stream: ${updated.name}`);
+          console.log(formatKeyValue([
+            ["ID", updated.id],
+            ["Name", updated.name]
+          ]));
+          return;
+        } catch (err) {
+          if (err instanceof ApiError && err.status === 404) {
+            warn("Stream not found, creating new...");
+          } else {
+            throw err;
+          }
+        }
+      }
+      const result = await createStream(streamData);
+      success(`Registered stream: ${result.stream.name}`);
+      console.log(formatKeyValue([
+        ["ID", result.stream.id],
+        ["Name", result.stream.name],
+        ["Signing Secret", result.signingSecret]
+      ]));
+      console.log(dim(`
+Save the signing secret - it won't be shown again!`));
+    } catch (err) {
+      handleApiError(err, "register stream");
+    }
+  });
+}
+
+// src/commands/replay.ts
+init_api_client();
+init_config();
 init_output();
 function registerReplayCommand(program2) {
   program2.command("replay <stream-id>").description("Replay blocks through a stream (re-evaluate and re-deliver)").option("--from <block>", "Start block height").option("--to <block>", "End block height").option("--last <count>", "Replay last N blocks").option("--block <height>", "Trigger evaluation for a single block").option("--fixture <path>", "Load block from fixture file (only with --block)").action(async (rawStreamId, options) => {
@@ -33904,7 +33794,7 @@ function registerReplayCommand(program2) {
       let fromBlock;
       let toBlock;
       if (options.last) {
-        const lastCount = parseInt(options.last);
+        const lastCount = Number.parseInt(options.last);
         if (isNaN(lastCount) || lastCount <= 0) {
           error("--last must be a positive number");
           process.exit(1);
@@ -33925,8 +33815,8 @@ function registerReplayCommand(program2) {
         fromBlock = Math.max(0, toBlock - lastCount + 1);
         info(`Replaying last ${lastCount} blocks (${fromBlock} to ${toBlock})`);
       } else if (options.from && options.to) {
-        fromBlock = parseInt(options.from);
-        toBlock = parseInt(options.to);
+        fromBlock = Number.parseInt(options.from);
+        toBlock = Number.parseInt(options.to);
         if (isNaN(fromBlock) || fromBlock < 0) {
           error("--from must be a non-negative number");
           process.exit(1);
@@ -33956,7 +33846,7 @@ Examples:`));
       });
       if (!response.ok) {
         const body = await response.text();
-        throw new Error(parseError3(response.status, body));
+        throw new Error(parseError2(response.status, body));
       }
       const result = await response.json();
       success("Replay started");
@@ -33975,7 +33865,7 @@ Jobs will be processed by the worker in block order.`));
   });
 }
 async function triggerBlock(config, streamId, blockStr, fixturePath) {
-  const blockHeight = parseInt(blockStr);
+  const blockHeight = Number.parseInt(blockStr);
   if (isNaN(blockHeight) || blockHeight < 0) {
     error("Block height must be a non-negative number");
     process.exit(1);
@@ -34006,7 +33896,7 @@ async function triggerBlock(config, streamId, blockStr, fixturePath) {
   });
   if (!response.ok) {
     const body = await response.text();
-    throw new Error(parseError3(response.status, body));
+    throw new Error(parseError2(response.status, body));
   }
   const result = await response.json();
   success(`Triggered evaluation for block ${blockHeight}`);
@@ -34016,7 +33906,7 @@ async function triggerBlock(config, streamId, blockStr, fixturePath) {
     ["Block", result.blockHeight.toString()]
   ]));
 }
-function parseError3(status, body) {
+function parseError2(status, body) {
   let message = `HTTP ${status}`;
   try {
     const json = JSON.parse(body);
@@ -34060,6 +33950,197 @@ Save the signing secret - it won't be shown again!`));
   });
 }
 
+// src/commands/set.ts
+init_api_client();
+init_config();
+init_output();
+function registerSetCommand(program2) {
+  program2.command("set [id] [state]").description("Set stream state (active, disabled, paused)").option("--all", "Apply to all streams").option("--wait", "Wait for pending jobs to complete (with paused)").option("--retry", "Re-enable an errored stream").option("--replay-failed", "Also replay failed deliveries (with --retry)").option("-o, --option <kv...>", "Set stream option (key=value, e.g. maxRetries=5)").action(async (id, state, options) => {
+    try {
+      if (options.retry) {
+        if (!id) {
+          error("Stream ID is required with --retry");
+          process.exit(1);
+        }
+        await retryStream(id, options.replayFailed);
+        return;
+      }
+      if (options.all) {
+        if (!state) {
+          error("State is required: sl streams set --all <active|paused>");
+          process.exit(1);
+        }
+        await setAllStreams(state, options.wait);
+        return;
+      }
+      if (options.option?.length) {
+        if (!id) {
+          error("Stream ID is required with --option");
+          process.exit(1);
+        }
+        const parsedOptions = parseOptions2(options.option);
+        await updateStream(id, { options: parsedOptions });
+        success(`Updated stream options: ${Object.entries(parsedOptions).map(([k, v]) => `${k}=${v}`).join(", ")}`);
+        if (!state)
+          return;
+      }
+      if (!id || !state) {
+        error("Usage: sl streams set <id> <active|disabled>");
+        console.log(dim(`
+Examples:`));
+        console.log(dim("  sl streams set <id> active"));
+        console.log(dim("  sl streams set <id> disabled"));
+        console.log(dim("  sl streams set --all paused --wait"));
+        console.log(dim("  sl streams set <id> --retry --replay-failed"));
+        console.log(dim("  sl streams set <id> --option maxRetries=5"));
+        process.exit(1);
+      }
+      await setSingleStream(id, state);
+    } catch (err) {
+      handleApiError(err, "set stream state");
+    }
+  });
+}
+async function setSingleStream(id, state) {
+  switch (state) {
+    case "active": {
+      const stream = await enableStream(id);
+      success(`Enabled stream: ${stream.name} (status: active)`);
+      break;
+    }
+    case "disabled": {
+      const stream = await disableStream(id);
+      success(`Disabled stream: ${stream.name} (status: inactive)`);
+      break;
+    }
+    default:
+      error(`Unknown state: ${state}. Use active, disabled, or paused (with --all)`);
+      process.exit(1);
+  }
+}
+async function setAllStreams(state, wait) {
+  switch (state) {
+    case "paused": {
+      const result = await pauseAllStreams();
+      if (result.paused === 0) {
+        info("No active streams to pause");
+        return;
+      }
+      success(`Paused ${result.paused} stream${result.paused === 1 ? "" : "s"}`);
+      if (wait) {
+        await waitForQueueDrain();
+      }
+      break;
+    }
+    case "active": {
+      const result = await resumeAllStreams();
+      if (result.resumed === 0) {
+        info("No paused streams to resume");
+        return;
+      }
+      success(`Resumed ${result.resumed} stream${result.resumed === 1 ? "" : "s"}`);
+      break;
+    }
+    default:
+      error(`Unknown state for --all: ${state}. Use active or paused`);
+      process.exit(1);
+  }
+}
+async function retryStream(id, replayFailed) {
+  const config = await loadConfig();
+  const apiUrl = resolveApiUrl(config);
+  const getRes = await fetch(`${apiUrl}/api/streams/${id}`, {
+    headers: authHeaders(config)
+  });
+  if (!getRes.ok) {
+    const body = await getRes.text();
+    throw new Error(parseError3(getRes.status, body));
+  }
+  const stream = await getRes.json();
+  if (stream.status !== "failed") {
+    warn(`Stream is not in failed status (current status: ${stream.status})`);
+    console.log(dim(`
+Use 'sl streams set <id> active' to enable an inactive stream.`));
+    process.exit(1);
+  }
+  if (stream.errorMessage) {
+    console.log(red(`Previous error: ${stream.errorMessage}`));
+    console.log("");
+  }
+  const enableRes = await fetch(`${apiUrl}/streams/${id}/enable`, {
+    method: "POST",
+    headers: authHeaders(config)
+  });
+  if (!enableRes.ok) {
+    const body = await enableRes.text();
+    throw new Error(parseError3(enableRes.status, body));
+  }
+  success(`Re-enabled stream: ${stream.name}`);
+  if (replayFailed) {
+    info("Replaying failed deliveries...");
+    const replayRes = await fetch(`${apiUrl}/streams/${id}/replay-failed`, {
+      method: "POST",
+      headers: authHeaders(config)
+    });
+    if (!replayRes.ok) {
+      const body = await replayRes.text();
+      warn(`Failed to replay: ${parseError3(replayRes.status, body)}`);
+    } else {
+      const result = await replayRes.json();
+      success(`Enqueued ${result.jobCount} replay jobs`);
+    }
+  }
+  console.log(dim(`
+Monitor with: sl streams logs ` + id + " -f"));
+}
+async function waitForQueueDrain() {
+  const POLL_INTERVAL_MS = 1000;
+  process.stdout.write(dim("Waiting for jobs to complete..."));
+  while (true) {
+    const stats = await getQueueStats();
+    const active = stats.pending + stats.processing;
+    if (active === 0) {
+      process.stdout.write(`
+`);
+      success("All jobs completed");
+      return;
+    }
+    process.stdout.write(`\r${dim(`Waiting for jobs to complete... ${active} remaining`)}`);
+    await Bun.sleep(POLL_INTERVAL_MS);
+  }
+}
+function parseOptions2(kvPairs) {
+  const result = {};
+  for (const kv of kvPairs) {
+    const eqIndex = kv.indexOf("=");
+    if (eqIndex === -1) {
+      throw new Error(`Invalid option format: "${kv}". Use key=value.`);
+    }
+    const key = kv.slice(0, eqIndex);
+    const raw = kv.slice(eqIndex + 1);
+    if (raw === "true")
+      result[key] = true;
+    else if (raw === "false")
+      result[key] = false;
+    else if (raw !== "" && !isNaN(Number(raw)))
+      result[key] = Number(raw);
+    else
+      result[key] = raw;
+  }
+  return result;
+}
+function parseError3(status, body) {
+  let message = `HTTP ${status}`;
+  try {
+    const json = JSON.parse(body);
+    message = json.error || json.message || message;
+  } catch {
+    if (body)
+      message = body;
+  }
+  return message;
+}
+
 // src/commands/streams.ts
 function registerStreamsCommand(program2) {
   const streams = program2.command("streams").description("Manage event streams");
@@ -34074,8 +34155,8 @@ function registerStreamsCommand(program2) {
   registerRotateSecretCommand(streams);
 }
 // src/commands/status.ts
-init_config();
 init_api_client();
+init_config();
 init_output();
 function registerStatusCommand(program2) {
   program2.command("status").description("Show system status").option("--json", "Output as JSON").action(async (options) => {
@@ -34172,7 +34253,10 @@ function printStatus(status) {
     ["  Total", status.streams.total.toString()],
     ["  Active", green(status.streams.active.toString())],
     ["  Paused", yellow(status.streams.paused.toString())],
-    ["  Error", status.streams.error > 0 ? red(status.streams.error.toString()) : "0"]
+    [
+      "  Error",
+      status.streams.error > 0 ? red(status.streams.error.toString()) : "0"
+    ]
   ]));
   console.log("");
   if (status.activeSubgraphs !== undefined || status.recentDeliveries !== undefined) {
@@ -34190,19 +34274,22 @@ function printStatus(status) {
 // src/commands/sync.ts
 init_config();
 init_output();
+import { confirm as confirm4 } from "@inquirer/prompts";
+import { getDb } from "@secondlayer/shared/db";
+import {
+  countMissingBlocks,
+  findGaps
+} from "@secondlayer/shared/db/queries/integrity";
 import { StacksNodeClient } from "@secondlayer/shared/node";
 import { HiroClient } from "@secondlayer/shared/node/hiro-client";
 import { LocalClient } from "@secondlayer/shared/node/local-client";
-import { findGaps, countMissingBlocks } from "@secondlayer/shared/db/queries/integrity";
-import { getDb } from "@secondlayer/shared/db";
-import { confirm as confirm4 } from "@inquirer/prompts";
 var DEV_DATABASE_URL = "postgres://postgres:postgres@localhost:5432/streams_dev";
 function registerSyncCommand(program2) {
   program2.command("sync").description("Fetch missing blocks and index them").option("--from <block>", "Start block height").option("--to <block>", "End block height").option("--gaps", "Auto-detect and fill all gaps").option("--concurrency <n>", "Parallel fetch limit (default: 1 for hiro, 5 for node)").option("--delay <ms>", "Delay between batches in ms (default: 500 for hiro, 0 for node)").option("--source <source>", "Data source: auto, local, hiro, node", "auto").option("-y, --yes", "Skip confirmation prompt").action(async function() {
     const opts = this.opts();
     const config = await loadConfig();
     const indexerUrl = process.env.INDEXER_URL || `http://localhost:${config.ports.indexer}`;
-    let concurrency = opts.concurrency ? parseInt(opts.concurrency) : 0;
+    let concurrency = opts.concurrency ? Number.parseInt(opts.concurrency) : 0;
     try {
       const nodeClient = new StacksNodeClient;
       const hiroClient = new HiroClient;
@@ -34270,10 +34357,13 @@ Set HIRO_API_URL or check your internet connection.`));
           process.exit(0);
         }
         info(`Found ${gaps.length} gaps, ${missing} missing blocks`);
-        ranges = gaps.map((g) => ({ start: g.gapStart, end: g.gapEnd }));
+        ranges = gaps.map((g) => ({
+          start: g.gapStart,
+          end: g.gapEnd
+        }));
       } else if (opts.from && opts.to) {
-        const from = parseInt(opts.from);
-        const to = parseInt(opts.to);
+        const from = Number.parseInt(opts.from);
+        const to = Number.parseInt(opts.to);
         if (isNaN(from) || from < 0) {
           error("--from must be a non-negative number");
           process.exit(1);
@@ -34313,7 +34403,7 @@ Examples:`));
           process.exit(0);
         }
       }
-      const batchDelay = opts.delay ? parseInt(opts.delay) : useHiro ? 500 : 0;
+      const batchDelay = opts.delay ? Number.parseInt(opts.delay) : useHiro ? 500 : 0;
       if (useHiro && batchDelay > 0) {
         info(`Pacing: ${batchDelay}ms delay between batches (concurrency: ${concurrency})`);
       }
@@ -34398,13 +34488,16 @@ Examples:`));
   });
 }
 // src/commands/db.ts
-init_output();
-init_dev_state();
 init_config();
+init_dev_state();
+init_output();
+import { confirm as confirm5 } from "@inquirer/prompts";
 import { getDb as getDb2, sql } from "@secondlayer/shared/db";
-import { findGaps as findGaps2, countMissingBlocks as countMissingBlocks2 } from "@secondlayer/shared/db/queries/integrity";
+import {
+  countMissingBlocks as countMissingBlocks2,
+  findGaps as findGaps2
+} from "@secondlayer/shared/db/queries/integrity";
 import { StacksNodeClient as StacksNodeClient2 } from "@secondlayer/shared/node";
-import { confirm as confirm5 } from "@inquirer/prompts";
 var DEV_DATABASE_URL2 = "postgres://postgres:postgres@localhost:5432/streams_dev";
 function registerDbCommand(program2) {
   const dbCmd = program2.command("db").description("Inspect indexer database tables").hook("preAction", async () => {
@@ -34414,19 +34507,19 @@ function registerDbCommand(program2) {
   });
   dbCmd.command("blocks").description("Show recent blocks").option("--limit <n>", "Number of rows", "10").option("--json", "Output as JSON").action(async function() {
     const opts = this.opts();
-    await showBlocks(parseInt(opts.limit), opts.json);
+    await showBlocks(Number.parseInt(opts.limit), opts.json);
   });
   dbCmd.command("txs").description("Show recent transactions").option("--limit <n>", "Number of rows", "10").option("--json", "Output as JSON").action(async function() {
     const opts = this.opts();
-    await showTransactions(parseInt(opts.limit), opts.json);
+    await showTransactions(Number.parseInt(opts.limit), opts.json);
   });
   dbCmd.command("events").description("Show recent events").option("--limit <n>", "Number of rows", "10").option("--json", "Output as JSON").action(async function() {
     const opts = this.opts();
-    await showEvents(parseInt(opts.limit), opts.json);
+    await showEvents(Number.parseInt(opts.limit), opts.json);
   });
   dbCmd.command("gaps").description("Show gaps in indexed block data").option("--limit <n>", "Number of gaps to show", "50").option("--json", "Output as JSON").action(async function() {
     const opts = this.opts();
-    await showGaps(parseInt(opts.limit), opts.json);
+    await showGaps(Number.parseInt(opts.limit), opts.json);
   });
   dbCmd.command("reset").description("Truncate all indexed data (blocks, txs, events, jobs, deliveries)").option("-y, --yes", "Skip confirmation prompt").action(async function() {
     const opts = this.opts();
@@ -34506,7 +34599,15 @@ async function showBlocks(limit, json) {
 async function showTransactions(limit, json) {
   try {
     const db = ensureDb();
-    const rows = await db.selectFrom("transactions").select(["tx_id", "block_height", "type", "sender", "status", "contract_id", "function_name"]).orderBy("block_height", "desc").limit(limit).execute();
+    const rows = await db.selectFrom("transactions").select([
+      "tx_id",
+      "block_height",
+      "type",
+      "sender",
+      "status",
+      "contract_id",
+      "function_name"
+    ]).orderBy("block_height", "desc").limit(limit).execute();
     if (json) {
       console.log(JSON.stringify(rows, null, 2));
       process.exit(0);
@@ -34706,7 +34807,10 @@ async function resyncDatabase(skipConfirm, backfill) {
             throw new Error(`Block ${height} not found`);
           const res = await fetch(`${indexerUrl}/new_block`, {
             method: "POST",
-            headers: { "Content-Type": "application/json", "X-Source": "backfill" },
+            headers: {
+              "Content-Type": "application/json",
+              "X-Source": "backfill"
+            },
             body: JSON.stringify(block)
           });
           if (!res.ok)
@@ -34737,8 +34841,8 @@ async function resyncDatabase(skipConfirm, backfill) {
   }
 }
 // src/commands/receiver.ts
-init_output();
 init_config();
+init_output();
 import { join as join5 } from "node:path";
 function registerReceiverCommand(program2) {
   const receiver = program2.command("receiver").description("Receiver development tools").hook("preAction", async () => {
@@ -34747,7 +34851,7 @@ function registerReceiverCommand(program2) {
   receiver.command("init <directory>").description("Scaffold a receiver handler with types and signature verification").option("-n, --name <name>", "Stream name", "my-stream").option("--network <network>", "Network (mainnet/testnet)", "mainnet").option("-p, --port <port>", "Server port", "4000").action(async (directory, options) => {
     try {
       const config = await loadConfig();
-      const port = parseInt(options.port);
+      const port = Number.parseInt(options.port);
       const network = options.network;
       const dir = join5(process.cwd(), directory);
       const dirExists = await Bun.file(join5(dir, "package.json")).exists();
@@ -35064,65 +35168,8 @@ async function generatePackageJson(dir, name) {
 `);
 }
 // src/commands/subgraphs.ts
-init_output();
-import { resolve } from "node:path";
 import { existsSync, mkdirSync, watch } from "node:fs";
-
-// src/templates/subgraph.ts
-function generateSubgraphTemplate(name) {
-  return `import { defineSubgraph } from "@secondlayer/subgraphs";
-
-export default defineSubgraph({
-  name: "${name}",
-  version: "1.0.0",
-  description: "TODO: describe what this subgraph tracks",
-
-  // Sources define what blockchain data this subgraph processes.
-  // Each source filters transactions/events by contract, type, function, or event.
-  // Examples:
-  //   { contract: "SP000...::my-contract" }              — all txs to a contract
-  //   { contract: "SP000...::my-contract", event: "transfer" } — specific event
-  //   { type: "stx_transfer", minAmount: 1000000n }      — STX transfers >= 1 STX
-  //   { contract: "*.pox-*" }                             — wildcard contract match
-  sources: [
-    { contract: "SP000000000000000000002Q6VF78.pox-4" },
-  ],
-
-  // Schema defines the tables this subgraph creates.
-  // Each table gets auto-columns: _id, _block_height, _tx_id, _created_at.
-  // Column types: text, uint, int, principal, boolean, timestamp, jsonb
-  schema: {
-    data: {
-      columns: {
-        sender: { type: "principal", indexed: true },
-        amount: { type: "uint" },
-        memo: { type: "text", nullable: true },
-      },
-      // Optional composite indexes
-      // indexes: [["sender", "amount"]],
-    },
-  },
-
-  // Handlers process matched events and write to your tables via the context.
-  // Keys match source patterns (use sourceKey format), or "*" as catch-all.
-  // Context methods: ctx.insert(), ctx.update(), ctx.delete()
-  handlers: {
-    "*": async (event, ctx) => {
-      await ctx.insert("data", {
-        sender: event.sender ?? event.tx?.sender,
-        amount: event.amount ?? 0,
-        memo: event.memo ?? null,
-      });
-    },
-  },
-});
-`;
-}
-
-// src/commands/subgraphs.ts
-init_api_client();
-init_config();
-init_fs();
+import { resolve } from "node:path";
 
 // src/generators/subgraph-scaffold.ts
 init_format();
@@ -35130,9 +35177,9 @@ init_format();
 // src/generators/clarity-to-subgraph.ts
 import {
   isAbiBuffer,
+  isAbiOptional,
   isAbiStringAscii,
-  isAbiStringUtf8,
-  isAbiOptional
+  isAbiStringUtf8
 } from "@secondlayer/stacks/clarity";
 function clarityTypeToSubgraphColumn(abiType) {
   return mapType(abiType, false);
@@ -35227,9 +35274,6 @@ ${handlersBlock}
   return formatCode(code);
 }
 
-// src/generators/subgraphs.ts
-init_format();
-
 // src/utils/case-conversion.ts
 import { toCamelCase } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
@@ -35240,6 +35284,7 @@ function toPascalCase(str) {
 }
 
 // src/generators/subgraphs.ts
+init_format();
 async function generateSubgraphConsumer(subgraphName, detail) {
   const tables = Object.entries(detail.tables);
   const rowInterfaces = tables.map(([tableName, tableDef]) => {
@@ -35313,8 +35358,65 @@ function subgraphTypeToTS(type) {
 }
 
 // src/commands/subgraphs.ts
-init_api();
+init_api_client();
+init_config();
+init_fs();
+init_output();
 init_clarity();
+
+// src/templates/subgraph.ts
+function generateSubgraphTemplate(name) {
+  return `import { defineSubgraph } from "@secondlayer/subgraphs";
+
+export default defineSubgraph({
+  name: "${name}",
+  version: "1.0.0",
+  description: "TODO: describe what this subgraph tracks",
+
+  // Sources define what blockchain data this subgraph processes.
+  // Each source filters transactions/events by contract, type, function, or event.
+  // Examples:
+  //   { contract: "SP000...::my-contract" }              — all txs to a contract
+  //   { contract: "SP000...::my-contract", event: "transfer" } — specific event
+  //   { type: "stx_transfer", minAmount: 1000000n }      — STX transfers >= 1 STX
+  //   { contract: "*.pox-*" }                             — wildcard contract match
+  sources: [
+    { contract: "SP000000000000000000002Q6VF78.pox-4" },
+  ],
+
+  // Schema defines the tables this subgraph creates.
+  // Each table gets auto-columns: _id, _block_height, _tx_id, _created_at.
+  // Column types: text, uint, int, principal, boolean, timestamp, jsonb
+  schema: {
+    data: {
+      columns: {
+        sender: { type: "principal", indexed: true },
+        amount: { type: "uint" },
+        memo: { type: "text", nullable: true },
+      },
+      // Optional composite indexes
+      // indexes: [["sender", "amount"]],
+    },
+  },
+
+  // Handlers process matched events and write to your tables via the context.
+  // Keys match source patterns (use sourceKey format), or "*" as catch-all.
+  // Context methods: ctx.insert(), ctx.update(), ctx.delete()
+  handlers: {
+    "*": async (event, ctx) => {
+      await ctx.insert("data", {
+        sender: event.sender ?? event.tx?.sender,
+        amount: event.amount ?? 0,
+        memo: event.memo ?? null,
+      });
+    },
+  },
+});
+`;
+}
+
+// src/commands/subgraphs.ts
+init_api();
 function registerSubgraphsCommand(program2) {
   const subgraphs = program2.command("subgraphs").description("Manage materialized subgraphs");
   subgraphs.command("new <name>").description("Scaffold a new subgraph definition file").action(async (name) => {
@@ -35352,7 +35454,9 @@ function registerSubgraphsCommand(program2) {
         const { getDb: getDb3 } = await import("@secondlayer/shared/db");
         validateSubgraphDefinition(def);
         const db = getDb3();
-        const result = await deploySchema(db, def, absPath, { forceReindex: false });
+        const result = await deploySchema(db, def, absPath, {
+          forceReindex: false
+        });
         if (result.action === "unchanged") {
           info(`[${new Date().toLocaleTimeString()}] No schema changes`);
         } else if (result.action === "created") {
@@ -35431,7 +35535,9 @@ Stopped watching.`);
         const { deploySchema } = await import("@secondlayer/subgraphs");
         const { getDb: getDb3, closeDb } = await import("@secondlayer/shared/db");
         const db = getDb3();
-        const result = await deploySchema(db, def, absPath, { forceReindex: options2.reindex });
+        const result = await deploySchema(db, def, absPath, {
+          forceReindex: options2.reindex
+        });
         if (result.action === "unchanged") {
           info(`Subgraph "${def.name}" is up to date (no schema changes)`);
         } else if (result.action === "created") {
@@ -35482,10 +35588,19 @@ ${data.length} subgraph(s) total`));
       const subgraph = await getSubgraphApi(name);
       const rowCounts = Object.entries(subgraph.tables).map(([t, info2]) => `${t}: ${info2.rowCount}`).join(", ") || "N/A";
       const errorRate = subgraph.health.totalProcessed > 0 ? `${(subgraph.health.errorRate * 100).toFixed(2)}%` : "N/A";
+      const sync = subgraph.sync;
+      const syncStatus = sync ? `${sync.status} — ${(sync.progress * 100).toFixed(1)}% (${sync.lastProcessedBlock} / ${sync.chainTip})` : "unknown";
+      const blocksRemaining = sync ? String(sync.blocksRemaining) : "N/A";
+      const gapSummary = sync && sync.gaps.count > 0 ? `${sync.gaps.count} unresolved (${sync.gaps.totalMissingBlocks} missing blocks)` : "none";
+      const integrity = sync?.integrity ?? "unknown";
       console.log(formatKeyValue([
         ["Name", subgraph.name],
         ["Version", subgraph.version],
         ["Status", subgraph.status],
+        ["Sync", syncStatus],
+        ["Blocks Remaining", blocksRemaining],
+        ["Integrity", integrity],
+        ["Gaps", gapSummary],
         ["Last Block", String(subgraph.lastProcessedBlock)],
         ["Row Count", rowCounts],
         ["Total Processed", String(subgraph.health.totalProcessed)],
@@ -35496,6 +35611,20 @@ ${data.length} subgraph(s) total`));
         ["Created", subgraph.createdAt],
         ["Updated", subgraph.updatedAt]
       ]));
+      if (sync && sync.gaps.count > 0 && sync.gaps.ranges.length > 0) {
+        console.log(dim(`
+Gap ranges (top 10):`));
+        const gapRows = sync.gaps.ranges.map((g) => [
+          String(g.start),
+          String(g.end),
+          String(g.size),
+          g.reason
+        ]);
+        console.log(formatTable(["Start", "End", "Size", "Reason"], gapRows));
+        if (sync.gaps.count > sync.gaps.ranges.length) {
+          console.log(dim(`  ... and ${sync.gaps.count - sync.gaps.ranges.length} more. Run: sl subgraphs gaps ${name}`));
+        }
+      }
       const tableEntries = Object.entries(subgraph.tables);
       if (tableEntries.length > 0) {
         console.log(dim(`
@@ -35512,8 +35641,8 @@ Table endpoints:`));
     try {
       info(`Reindexing subgraph "${name}"...`);
       const result = await reindexSubgraphApi(name, {
-        fromBlock: options2.from ? parseInt(options2.from, 10) : undefined,
-        toBlock: options2.to ? parseInt(options2.to, 10) : undefined
+        fromBlock: options2.from ? Number.parseInt(options2.from, 10) : undefined,
+        toBlock: options2.to ? Number.parseInt(options2.to, 10) : undefined
       });
       success(result.message);
       info(`From block ${result.fromBlock} to ${result.toBlock}`);
@@ -35521,6 +35650,51 @@ Table endpoints:`));
       handleApiError(err, "reindex subgraph");
     }
   });
+  subgraphs.command("backfill <name>").description("Backfill a block range without dropping existing data").requiredOption("--from <block>", "Start block height").requiredOption("--to <block>", "End block height").action(async (name, options2) => {
+    try {
+      const fromBlock = Number.parseInt(options2.from, 10);
+      const toBlock = Number.parseInt(options2.to, 10);
+      if (isNaN(fromBlock) || isNaN(toBlock)) {
+        error("--from and --to must be valid block numbers");
+        process.exit(1);
+      }
+      info(`Backfilling subgraph "${name}" from block ${fromBlock} to ${toBlock}...`);
+      const result = await backfillSubgraphApi(name, { fromBlock, toBlock });
+      success(result.message);
+      info(`From block ${result.fromBlock} to ${result.toBlock}`);
+    } catch (err) {
+      handleApiError(err, "backfill subgraph");
+    }
+  });
+  subgraphs.command("gaps <name>").description("Show block gaps for a subgraph").option("--resolved", "Include resolved gaps").option("--limit <n>", "Max gaps to return", "50").option("--json", "Output as JSON").action(async (name, options2) => {
+    try {
+      const result = await getSubgraphGaps(name, {
+        limit: Number.parseInt(options2.limit ?? "50", 10),
+        resolved: options2.resolved
+      });
+      if (options2.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.data.length === 0) {
+        success("No gaps detected");
+        return;
+      }
+      const rows = result.data.map((g) => [
+        String(g.start),
+        String(g.end),
+        String(g.size),
+        g.reason,
+        g.detectedAt.replace("T", " ").slice(0, 19),
+        g.resolvedAt ? g.resolvedAt.replace("T", " ").slice(0, 19) : dim("—")
+      ]);
+      console.log(formatTable(["Start", "End", "Size", "Reason", "Detected", "Resolved"], rows));
+      console.log(dim(`
+${result.meta.total} gap(s), ${result.meta.totalMissingBlocks} total missing blocks`));
+    } catch (err) {
+      handleApiError(err, "get subgraph gaps");
+    }
+  });
   subgraphs.command("query <name> <table>").description("Query a subgraph table").option("--sort <column>", "Sort by column").option("--order <dir>", "Sort direction (asc|desc)", "asc").option("--limit <n>", "Max rows to return", "20").option("--offset <n>", "Skip first N rows").option("--fields <cols>", "Comma-separated columns to include").option("--filter <kv...>", "Filter as key=value (supports .gte/.lte/.gt/.lt/.neq suffixes)").option("--count", "Return row count only").option("--json", "Output as JSON").action(async (name, table, options2) => {
     try {
       const filters = {};
@@ -35537,8 +35711,8 @@ Table endpoints:`));
       const params = {
         sort: options2.sort,
         order: options2.sort ? options2.order : undefined,
-        limit: parseInt(options2.limit, 10),
-        offset: options2.offset ? parseInt(options2.offset, 10) : undefined,
+        limit: Number.parseInt(options2.limit, 10),
+        offset: options2.offset ? Number.parseInt(options2.offset, 10) : undefined,
         fields: options2.fields,
         filters: Object.keys(filters).length > 0 ? filters : undefined
       };
@@ -35646,10 +35820,10 @@ ${rows.length} row(s)`));
 }
 // src/commands/stack.ts
 init_config();
-init_network();
-init_node_manager();
 init_dev_state();
 init_docker();
+init_network();
+init_node_manager();
 init_output();
 function registerStackCommand(program2) {
   const stack = program2.command("stack").description("Manage the full stack");
@@ -35743,7 +35917,13 @@ async function stackStart(options2) {
     if (await isDevRunning()) {
       info("Dev services already running");
     } else {
-      const args = ["bun", "run", import.meta.dir + "/../../bin/secondlayer.ts", "dev", "start"];
+      const args = [
+        "bun",
+        "run",
+        import.meta.dir + "/../../bin/secondlayer.ts",
+        "dev",
+        "start"
+      ];
       if (config.node?.installPath) {
         args.push("--stacks-node");
       }
@@ -35790,7 +35970,13 @@ async function stackStop(options2) {
   if (options2.dev) {
     if (await isDevRunning()) {
       info("Stopping dev services...");
-      const proc = Bun.spawn(["bun", "run", import.meta.dir + "/../../bin/secondlayer.ts", "dev", "stop"], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+      const proc = Bun.spawn([
+        "bun",
+        "run",
+        import.meta.dir + "/../../bin/secondlayer.ts",
+        "dev",
+        "stop"
+      ], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
       await proc.exited;
     } else {
       info("Dev services not running");
@@ -35834,11 +36020,15 @@ async function stackStop(options2) {
   success("Stack stopped");
   console.log("");
 }
+// src/commands/doctor.ts
+init_api_client();
+init_config();
+
 // src/lib/health.ts
-init_dev_state();
-init_node_manager();
 init_config();
+init_dev_state();
 init_network();
+init_node_manager();
 async function checkHealth() {
   const config = await loadConfig();
   const issues = [];
@@ -35906,7 +36096,7 @@ async function checkHealth() {
           try {
             const inspect2 = await Bun.$`docker inspect --format={{.RestartCount}} ${name}`.quiet().nothrow();
             if (inspect2.exitCode === 0) {
-              restartCount = parseInt(inspect2.stdout.toString().trim()) || 0;
+              restartCount = Number.parseInt(inspect2.stdout.toString().trim()) || 0;
             }
           } catch {}
           containers.push({ name, status, health, restartCount });
@@ -35975,8 +36165,6 @@ async function checkHealth() {
 }
 
 // src/commands/doctor.ts
-init_config();
-init_api_client();
 init_network();
 init_output();
 function registerDoctorCommand(program2) {
@@ -35997,7 +36185,9 @@ async function runHostedDoctor(jsonOutput) {
   let apiHealthy = false;
   let statusData = null;
   try {
-    const res = await fetch(`${apiUrl}/status`, { headers: authHeaders(config) });
+    const res = await fetch(`${apiUrl}/status`, {
+      headers: authHeaders(config)
+    });
     apiHealthy = res.ok;
     if (res.ok) {
       statusData = await res.json();
@@ -36013,7 +36203,9 @@ async function runHostedDoctor(jsonOutput) {
   let authOk = false;
   let account = null;
   try {
-    const res = await fetch(`${apiUrl}/api/accounts/me`, { headers: authHeaders(config) });
+    const res = await fetch(`${apiUrl}/api/accounts/me`, {
+      headers: authHeaders(config)
+    });
     if (res.ok) {
       authOk = true;
       account = await res.json();
@@ -36097,7 +36289,10 @@ async function runLocalDoctor(jsonOutput) {
   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 ? `${chainIdHex} (${report.node.chainIdValid ? green("valid") : red("MISMATCH")})` : dim("N/A")
+    ]
   ]));
   console.log("");
   console.log(blue("Node"));
@@ -36107,7 +36302,10 @@ async function runLocalDoctor(jsonOutput) {
     console.log(formatKeyValue([
       ["  Height", `${heightStr} ${burnStr}`],
       ["  Peers", report.node.peers.toString()],
-      ["  Status", report.node.height ? green("syncing") : yellow("starting")],
+      [
+        "  Status",
+        report.node.height ? green("syncing") : yellow("starting")
+      ],
       ["  Version", report.node.version ?? dim("unknown")]
     ]));
   } else {
@@ -36189,8 +36387,8 @@ async function runLocalDoctor(jsonOutput) {
   console.log("");
 }
 // src/commands/auth.ts
-init_config();
 init_api_client();
+init_config();
 init_output();
 import { hostname } from "node:os";
 import { input as input2 } from "@inquirer/prompts";
@@ -36226,14 +36424,22 @@ function registerAuthCommand(program2) {
       });
       await assertOk(verifyRes);
       const result = await verifyRes.json();
-      const sessionHeaders = { Authorization: `Bearer ${result.sessionToken}`, "Content-Type": "application/json" };
+      const sessionHeaders = {
+        Authorization: `Bearer ${result.sessionToken}`,
+        "Content-Type": "application/json"
+      };
       const keyName = `cli-${hostname().toLowerCase()}`;
-      const listRes = await fetch(`${apiUrl}/api/keys`, { headers: sessionHeaders });
+      const listRes = await fetch(`${apiUrl}/api/keys`, {
+        headers: sessionHeaders
+      });
       if (listRes.ok) {
         const { keys: keys2 } = await listRes.json();
         const existing = keys2.find((k) => k.name === keyName && k.status === "active");
         if (existing) {
-          await fetch(`${apiUrl}/api/keys/${existing.id}`, { method: "DELETE", headers: sessionHeaders });
+          await fetch(`${apiUrl}/api/keys/${existing.id}`, {
+            method: "DELETE",
+            headers: sessionHeaders
+          });
         }
       }
       const createRes = await fetch(`${apiUrl}/api/keys`, {
@@ -36246,7 +36452,10 @@ function registerAuthCommand(program2) {
       config.apiKey = key;
       await saveConfig(config);
       try {
-        await fetch(`${apiUrl}/api/auth/logout`, { method: "POST", headers: sessionHeaders });
+        await fetch(`${apiUrl}/api/auth/logout`, {
+          method: "POST",
+          headers: sessionHeaders
+        });
       } catch {}
       success(`Authenticated as ${result.account.email}`);
       console.log(dim(`Key: ${prefix}...`));
@@ -36272,7 +36481,10 @@ function registerAuthCommand(program2) {
         const currentPrefix = config.apiKey.slice(0, 14);
         const match = keys2.find((k) => currentPrefix.startsWith(k.prefix));
         if (match) {
-          await fetch(`${apiUrl}/api/keys/${match.id}`, { method: "DELETE", headers });
+          await fetch(`${apiUrl}/api/keys/${match.id}`, {
+            method: "DELETE",
+            headers
+          });
         }
       }
     } catch {}
@@ -36286,7 +36498,10 @@ function registerAuthCommand(program2) {
     const pairs = [
       ["Network", config.network],
       ["API", apiUrl || "(not configured)"],
-      ["API Key", config.apiKey ? config.apiKey.slice(0, 14) + "..." : "(none)"]
+      [
+        "API Key",
+        config.apiKey ? config.apiKey.slice(0, 14) + "..." : "(none)"
+      ]
     ];
     if (config.apiKey && apiUrl) {
       try {
@@ -36328,7 +36543,10 @@ function registerAuthCommand(program2) {
   keys.command("create").description("Create a new API key").option("--name <name>", "Name for the API key").action(async (options2) => {
     const config = await loadConfig();
     const apiUrl = resolveApiUrl(config);
-    const headers = { ...authHeaders(config), "Content-Type": "application/json" };
+    const headers = {
+      ...authHeaders(config),
+      "Content-Type": "application/json"
+    };
     try {
       const res = await fetch(`${apiUrl}/api/keys`, {
         method: "POST",
@@ -36428,7 +36646,13 @@ init_config();
 init_dev_state();
 init_node_manager();
 init_output();
-var DEV_SERVICES = ["api", "indexer", "worker", "receiver", "subgraphs"];
+var DEV_SERVICES = [
+  "api",
+  "indexer",
+  "worker",
+  "receiver",
+  "subgraphs"
+];
 function registerLocalCommand(program2) {
   const local = program2.command("local").description("Manage local development environment and Stacks node").hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.name() === "help")
@@ -36491,7 +36715,7 @@ function registerLocalCommand(program2) {
   });
   node.command("config-check").description("Show events observer configuration for Config.toml").option("--indexer-port <port>", "Indexer port to display", "3700").action(async (options2) => {
     const { showConfigCheck: showConfigCheck2 } = await Promise.resolve().then(() => (init_node_impl(), exports_node_impl));
-    await showConfigCheck2(parseInt(options2.indexerPort));
+    await showConfigCheck2(Number.parseInt(options2.indexerPort));
   });
   node.command("logs").description("View Stacks node logs").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines to show", "50").option("-q, --quiet", "Filter out common noise").action(async (options2) => {
     await showLocalLogs({ ...options2, service: "node" });
@@ -36538,13 +36762,18 @@ var serviceColors2 = {
   node: red
 };
 async function showLocalLogs(options2) {
-  const lines = parseInt(options2.lines);
+  const lines = Number.parseInt(options2.lines);
   const service = options2.service?.toLowerCase();
   const showDev = !service || service === "dev" || DEV_SERVICES.includes(service);
   const showNode = !service || service === "node";
   if (service && DEV_SERVICES.includes(service)) {
     const { showLogs: showLogs2 } = await Promise.resolve().then(() => (init_dev_impl(), exports_dev_impl));
-    await showLogs2({ follow: options2.follow, service, lines: options2.lines, verbose: options2.verbose });
+    await showLogs2({
+      follow: options2.follow,
+      service,
+      lines: options2.lines,
+      verbose: options2.verbose
+    });
     return;
   }
   if (service === "node") {
@@ -36565,7 +36794,7 @@ async function showNodeLogs(options2) {
   }
   const logs = await getNodeLogs({
     follow: options2.follow,
-    lines: parseInt(options2.lines),
+    lines: Number.parseInt(options2.lines),
     quiet: options2.quiet,
     format: true
   });
@@ -36710,8 +36939,8 @@ function formatDeliverySummary2(jsonStr) {
   }
 }
 // src/commands/whoami.ts
-init_config();
 init_api_client();
+init_config();
 init_output();
 function registerWhoamiCommand(program2) {
   program2.command("whoami").description("Show current authenticated account").action(async () => {
@@ -36783,5 +37012,5 @@ registerWhoamiCommand(program);
 registerReceiverCommand(program);
 program.parse();
 
-//# debugId=60C3F60FD3E0B1F064756E2164756E21
+//# debugId=CCE78279B6461B3364756E2164756E21
 //# sourceMappingURL=cli.js.map