@secondlayer/subgraphs 3.24.1 → 3.24.3

package/dist/src/service.js

@@ -1627,6 +1627,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map, f
 }
 
 // src/runtime/block-processor.ts
+import { secretsKeyAvailable } from "@secondlayer/shared/crypto/secrets";
 import { getTargetDb } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
@@ -1639,7 +1640,7 @@ import {
   rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger6 } from "@secondlayer/shared/logger";
+import { logger as logger7 } from "@secondlayer/shared/logger";
 import { sql as sql3 } from "kysely";
 
 // src/runtime/block-source.ts
@@ -2080,6 +2081,315 @@ async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block
   return rows.length;
 }
 
+// src/runtime/sandbox/flag.ts
+function sandboxWorkersGloballyEnabled() {
+  return process.env.SUBGRAPH_SANDBOX_WORKERS === "1";
+}
+function sandboxEnabled(subgraph) {
+  return sandboxWorkersGloballyEnabled() && subgraph.sandbox_workers === true;
+}
+
+// src/runtime/sandbox/host.ts
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { logger as logger6 } from "@secondlayer/shared/logger";
+
+// src/runtime/sandbox/bundle.ts
+import esbuild from "esbuild";
+var ALLOWED_BARE_SPECIFIERS = new Set;
+var SUBGRAPHS_PACKAGE_SPECIFIER = "@secondlayer/subgraphs";
+var SUBGRAPHS_STUB_SOURCE = `export function defineSubgraph(def) { return def; }
+`;
+function resolverLockdownPlugin() {
+  return {
+    name: "f071-sandbox-resolver-lockdown",
+    setup(build) {
+      build.onResolve({ filter: /^@secondlayer\/subgraphs$/ }, (args) => ({
+        path: args.path,
+        namespace: "f071-sandbox-subgraphs-stub"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "f071-sandbox-subgraphs-stub" }, () => ({ contents: SUBGRAPHS_STUB_SOURCE, loader: "js" }));
+      build.onResolve({ filter: /^(node:|bun:)/ }, (args) => ({
+        path: args.path,
+        namespace: "f071-sandbox-blocked"
+      }));
+      build.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (args.path === SUBGRAPHS_PACKAGE_SPECIFIER)
+          return;
+        if (ALLOWED_BARE_SPECIFIERS.has(args.path))
+          return;
+        return { path: args.path, namespace: "f071-sandbox-blocked" };
+      });
+      build.onLoad({ filter: /.*/, namespace: "f071-sandbox-blocked" }, (args) => ({
+        contents: `throw new Error(${JSON.stringify(`subgraph sandbox: import of "${args.path}" is blocked in sandboxed handler code — handlers must use the injected \`ctx\` for all I/O`)});`,
+        loader: "js"
+      }));
+    }
+  };
+}
+async function bundleHandlerCode(handlerCode) {
+  const result = await esbuild.build({
+    stdin: {
+      contents: handlerCode,
+      loader: "ts",
+      resolveDir: process.cwd()
+    },
+    bundle: true,
+    platform: "neutral",
+    format: "esm",
+    write: false,
+    logLevel: "silent",
+    plugins: [resolverLockdownPlugin()]
+  });
+  const out = result.outputFiles?.[0];
+  if (!out)
+    throw new Error("esbuild produced no output for handler_code bundle");
+  return new TextDecoder().decode(out.contents);
+}
+
+// src/runtime/sandbox/host.ts
+var BLOCK_TIMEOUT_MS = Number.parseInt(process.env.SUBGRAPH_SANDBOX_BLOCK_TIMEOUT_MS ?? "60000");
+var SUBPROCESS_ENTRY_PATH = fileURLToPath(new URL("./subprocess-entry.ts", import.meta.url));
+function spawnSandboxProcess() {
+  let onMessage = null;
+  const proc = Bun.spawn({
+    cmd: [process.execPath, "--no-env-file", SUBPROCESS_ENTRY_PATH],
+    env: { PATH: process.env.PATH ?? "" },
+    cwd: tmpdir(),
+    stdio: ["ignore", "ignore", "pipe"],
+    serialization: "advanced",
+    ipc(message) {
+      onMessage?.(message);
+    }
+  });
+  (async () => {
+    const reader = proc.stderr.getReader();
+    const decoder = new TextDecoder;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        const text = decoder.decode(value, { stream: true });
+        if (text.trim()) {
+          logger6.warn("Sandbox subprocess stderr", { stderr: text.trim() });
+        }
+      }
+    } catch {}
+  })();
+  return {
+    send: (msg) => proc.send(msg),
+    kill: () => proc.kill(),
+    exited: proc.exited,
+    setOnMessage: (handler) => {
+      onMessage = handler;
+    }
+  };
+}
+var pool = new Map;
+
+class SandboxWorkerCrash extends Error {
+  constructor(subgraphName, cause) {
+    super(`sandbox subprocess for "${subgraphName}" failed: ${cause}`);
+    this.name = "SandboxWorkerCrash";
+  }
+}
+async function initSandboxProcess(proc, subgraphName, version, handlerCode) {
+  const bundledCode = await bundleHandlerCode(handlerCode);
+  let settled = false;
+  const ready = new Promise((resolve, reject) => {
+    proc.setOnMessage((msg) => {
+      if (msg.type === "ready" && msg.version === version) {
+        settled = true;
+        proc.setOnMessage(null);
+        resolve();
+      } else if (msg.type === "error") {
+        settled = true;
+        proc.setOnMessage(null);
+        reject(new SandboxWorkerCrash(subgraphName, msg.message));
+      }
+    });
+    const init = { type: "init", bundledCode, version };
+    proc.send(init);
+  });
+  const crashed = proc.exited.then((code) => {
+    if (settled)
+      return;
+    throw new SandboxWorkerCrash(subgraphName, `subprocess exited (code ${code}) during init`);
+  });
+  await Promise.race([ready, crashed]);
+}
+async function ensureSandboxProcess(subgraphName, version, handlerCode) {
+  if (handlerCode == null) {
+    throw new SandboxWorkerCrash(subgraphName, "subgraph has no handler_code; cannot bundle for the sandbox path");
+  }
+  const existing = pool.get(subgraphName);
+  if (existing && existing.version === version)
+    return existing;
+  if (existing) {
+    try {
+      await initSandboxProcess(existing.proc, subgraphName, version, handlerCode);
+      existing.version = version;
+      logger6.info("Sandbox subprocess handler reloaded", {
+        subgraph: subgraphName,
+        version
+      });
+      return existing;
+    } catch (err) {
+      existing.proc.kill();
+      pool.delete(subgraphName);
+      logger6.warn("Sandbox subprocess re-init failed; respawning", {
+        subgraph: subgraphName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const proc = spawnSandboxProcess();
+  try {
+    await initSandboxProcess(proc, subgraphName, version, handlerCode);
+  } catch (err) {
+    proc.kill();
+    throw err;
+  }
+  const entry = { proc, version, chain: Promise.resolve() };
+  pool.set(subgraphName, entry);
+  return entry;
+}
+function evictSandboxWorker(subgraphName) {
+  const entry = pool.get(subgraphName);
+  if (!entry)
+    return;
+  entry.proc.kill();
+  pool.delete(subgraphName);
+}
+async function runHandlersSandboxed(params) {
+  const { subgraphName, version, handlerCode, hostCtx, block, matched } = params;
+  const entry = await ensureSandboxProcess(subgraphName, version, handlerCode);
+  const run = entry.chain.then(() => runBlockThroughProcess(entry, subgraphName, hostCtx, block, matched));
+  entry.chain = run.catch(() => {
+    return;
+  });
+  return run;
+}
+async function runBlockThroughProcess(entry, subgraphName, hostCtx, block, matched) {
+  const { proc } = entry;
+  let timeoutHandle;
+  let settled = false;
+  try {
+    const done = new Promise((resolve, reject) => {
+      proc.setOnMessage((msg) => {
+        if (msg.type === "readRequest") {
+          answerRead(hostCtx, msg).then((reply) => {
+            proc.send({ type: "readResponse", id: msg.id, reply });
+          }).catch((err) => {
+            settled = true;
+            reject(new SandboxWorkerCrash(subgraphName, `host read failed: ${err instanceof Error ? err.message : String(err)}`));
+          });
+          return;
+        }
+        if (msg.type === "blockDone") {
+          settled = true;
+          resolve({
+            ops: msg.ops,
+            result: { processed: msg.processed, errors: msg.errors }
+          });
+          return;
+        }
+        if (msg.type === "error") {
+          settled = true;
+          reject(new SandboxWorkerCrash(subgraphName, msg.message));
+        }
+      });
+      proc.send({ type: "runBlock", block, matched });
+    });
+    const crashed = proc.exited.then((code) => {
+      if (settled)
+        return;
+      throw new SandboxWorkerCrash(subgraphName, `subprocess exited unexpectedly (code ${code}) mid-block`);
+    });
+    const deadline = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        settled = true;
+        reject(new SandboxWorkerCrash(subgraphName, `block ${block.height} exceeded ${BLOCK_TIMEOUT_MS}ms deadline`));
+      }, BLOCK_TIMEOUT_MS);
+    });
+    const { ops, result } = await Promise.race([done, crashed, deadline]);
+    for (const op of ops) {
+      hostCtx.setTx(op.tx);
+      replayOp(hostCtx, op);
+    }
+    return result;
+  } catch (err) {
+    evictSandboxWorker(subgraphName);
+    logger6.warn("Sandbox subprocess run failed; subprocess evicted", {
+      subgraph: subgraphName,
+      blockHeight: block.height,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  } finally {
+    if (timeoutHandle !== undefined)
+      clearTimeout(timeoutHandle);
+    proc.setOnMessage(null);
+  }
+}
+function replayOp(hostCtx, op) {
+  switch (op.method) {
+    case "insert":
+      hostCtx.insert(op.table, op.args[0]);
+      return;
+    case "upsert":
+      hostCtx.upsert(op.table, op.args[0], op.args[1]);
+      return;
+    case "increment":
+      hostCtx.increment(op.table, op.args[0], op.args[1]);
+      return;
+    case "update":
+      hostCtx.update(op.table, op.args[0], op.args[1]);
+      return;
+    case "delete":
+      hostCtx.delete(op.table, op.args[0]);
+      return;
+  }
+}
+async function answerRead(hostCtx, msg) {
+  const { method, table, where, column } = msg;
+  switch (method) {
+    case "findOne":
+      return { kind: "row", row: await hostCtx.findOne(table, where) };
+    case "findMany":
+      return { kind: "rows", rows: await hostCtx.findMany(table, where) };
+    case "count":
+      return { kind: "count", count: await hostCtx.count(table, where) };
+    case "countDistinct": {
+      if (!column)
+        throw new Error("countDistinct read missing column");
+      return {
+        kind: "count",
+        count: await hostCtx.countDistinct(table, column, where)
+      };
+    }
+    case "sum": {
+      if (!column)
+        throw new Error("sum read missing column");
+      const v = await hostCtx.sum(table, column, where);
+      return { kind: "amount", amount: v.toString() };
+    }
+    case "min": {
+      if (!column)
+        throw new Error("min read missing column");
+      const v = await hostCtx.min(table, column, where);
+      return { kind: "amount", amount: v == null ? null : v.toString() };
+    }
+    case "max": {
+      if (!column)
+        throw new Error("max read missing column");
+      const v = await hostCtx.max(table, column, where);
+      return { kind: "amount", amount: v == null ? null : v.toString() };
+    }
+  }
+}
+
 // src/runtime/subscription-state.ts
 import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
 import { sql as sql2 } from "kysely";
@@ -2255,22 +2565,36 @@ async function refreshMatcher(db) {
 
 // src/runtime/block-processor.ts
 var routeCache = new Map;
+
+class ByoKeyUnavailableError extends Error {
+  constructor(subgraphName) {
+    super(`subgraph ${subgraphName} is BYO (database_url_enc set) but this process has no SECONDLAYER_SECRETS_KEY — the subgraph processor deliberately does not hold it (f072). Route BYO subgraphs to a process that does, or unset BYO.`);
+    this.name = "ByoKeyUnavailableError";
+  }
+}
 async function resolveRoute(subgraphName, targetDb) {
   const cached = routeCache.get(subgraphName);
   if (cached)
     return cached;
   const row = await targetDb.selectFrom("subgraphs").selectAll().where("name", "=", subgraphName).executeTakeFirst();
   const byo = row ? isByoSubgraph(row) : false;
+  if (row && byo && !secretsKeyAvailable()) {
+    throw new ByoKeyUnavailableError(subgraphName);
+  }
   const route = {
     schemaName: row?.schema_name ?? pgSchemaName(subgraphName),
     dataDb: row && byo ? resolveSubgraphDb(row) : targetDb,
-    byo
+    byo,
+    sandboxWorkers: row?.sandbox_workers === true,
+    handlerCode: row?.handler_code ?? null,
+    version: row?.version ?? ""
   };
   routeCache.set(subgraphName, route);
   return route;
 }
 function invalidateSubgraphRoute(subgraphName) {
   routeCache.delete(subgraphName);
+  evictSandboxWorker(subgraphName);
 }
 async function resolveFactoryContracts(subgraph, blockHeight, schemaName, db, txs, evts) {
   const factories = new Map;
@@ -2376,7 +2700,7 @@ async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts,
       const delay = retryDelaysMs[attempt];
       if (delay === undefined)
         break;
-      logger6.warn("Block processing failed, retrying", {
+      logger7.warn("Block processing failed, retrying", {
         subgraph: subgraphName,
         blockHeight,
         attempt: attempt + 1,
@@ -2408,7 +2732,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   } else {
     const data = (await resolveBlockSource(subgraph).loadBlockRange(blockHeight, blockHeight)).get(blockHeight);
     if (!data) {
-      logger6.debug("Block not found or non-canonical for subgraph processing", {
+      logger7.debug("Block not found or non-canonical for subgraph processing", {
         subgraph: subgraphName,
         blockHeight
       });
@@ -2544,7 +2868,16 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         }
         const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, false, journalEnabled(opts));
         const handlerStart = performance.now();
-        const runResult = await runHandlers(subgraph, matched, ctx);
+        const runResult = sandboxEnabled({
+          sandbox_workers: route.sandboxWorkers
+        }) ? await runHandlersSandboxed({
+          subgraphName,
+          version: route.version,
+          handlerCode: route.handlerCode,
+          hostCtx: ctx,
+          block: blockMeta,
+          matched
+        }) : await runHandlers(subgraph, matched, ctx);
         handlerMs = performance.now() - handlerStart;
         result.processed = runResult.processed;
         result.errors = runResult.errors;
@@ -2570,7 +2903,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       });
     } catch (err) {
       if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-        logger6.warn("cursor race lost — block already covered", {
+        logger7.warn("cursor race lost — block already covered", {
           subgraph: subgraphName,
           blockHeight,
           error: err.message
@@ -2596,7 +2929,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
-          logger6.warn("Subgraph table exceeds 10M rows (estimate)", {
+          logger7.warn("Subgraph table exceeds 10M rows (estimate)", {
             subgraph: subgraphName,
             table,
             count
@@ -2604,7 +2937,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         }
       }
     } catch (err) {
-      logger6.debug("Row count sample failed", {
+      logger7.debug("Row count sample failed", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -2694,11 +3027,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger7 } from "@secondlayer/shared/logger";
+import { logger as logger8 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -2709,7 +3042,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger7.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger8.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -2731,14 +3064,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger7.warn("reindex-complete email failed", {
+      logger8.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger7.warn("reindex-complete email threw", {
+    logger8.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -2850,7 +3183,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger8.info("Block processing aborted", {
+      logger9.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -2899,7 +3232,7 @@ async function processBlockRange(def, opts) {
         });
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger8.error("Block processing failed persistently", {
+        logger9.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -2945,7 +3278,7 @@ async function processBlockRange(def, opts) {
         lastProgressFlushAt = now;
       }
       if (blocksProcessed % LOG_INTERVAL === 0) {
-        logger8.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+        logger9.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -2965,7 +3298,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger8.warn("Failed to record subgraph gaps", {
+        logger9.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -2982,7 +3315,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger8.info("Sparse skip", {
+        logger9.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -3022,11 +3355,11 @@ async function reindexSubgraph(def, opts) {
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger8.info("Reindex starting", { subgraph: subgraphName });
+  logger9.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger8.info("No blocks to reindex", {
+      logger9.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -3040,7 +3373,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger8.info("Schema recreated for reindex", {
+    logger9.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -3054,7 +3387,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger8.info("Reindexing blocks", {
+    logger9.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -3076,9 +3409,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger8.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger9.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger8.info("Reindex interrupted by shutdown, will resume", {
+        logger9.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -3086,7 +3419,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger8.info("Reindex complete", {
+    logger9.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3099,7 +3432,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger8.error("Reindex failed", {
+    logger9.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3121,7 +3454,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger8.info("No reindex metadata, starting fresh reindex", {
+    logger9.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -3130,12 +3463,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger8.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger9.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger8.info("Resuming reindex", {
+  logger9.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -3157,9 +3490,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger8.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger9.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger8.info("Resume interrupted by shutdown, will resume again", {
+        logger9.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -3167,13 +3500,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger8.info("Resumed reindex complete", {
+    logger9.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger8.error("Resumed reindex failed", {
+    logger9.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3184,7 +3517,7 @@ async function resumeReindex(def, opts) {
 async function backfillSubgraph(def, opts) {
   const targetDb = getTargetDb2();
   const subgraphName = def.name;
-  logger8.info("Backfill starting", {
+  logger9.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -3202,17 +3535,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger8.info("Backfill aborted", { subgraph: subgraphName });
+      logger9.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger8.info("Resolved subgraph gaps via backfill", {
+      logger9.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger8.info("Backfill complete", {
+    logger9.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3220,7 +3553,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger8.error("Backfill failed", {
+    logger9.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3231,7 +3564,7 @@ async function backfillSubgraph(def, opts) {
 // src/runtime/catchup.ts
 import { getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 
 // src/runtime/catchup-leader.ts
 import {
@@ -3365,7 +3698,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     const subgraphStart = Number(subgraphRow.start_block) || 1;
     const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
     const totalBlocks = chainTip - lastProcessedBlock;
-    logger9.info("Subgraph catch-up starting", {
+    logger10.info("Subgraph catch-up starting", {
       subgraph: subgraphName,
       from: startBlock,
       to: chainTip,
@@ -3381,7 +3714,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
     while (currentHeight <= chainTip) {
       if (!isCatchUpLeader()) {
-        logger9.info("Lost catch-up leadership, stopping catch-up", {
+        logger10.info("Lost catch-up leadership, stopping catch-up", {
           subgraph: subgraphName,
           processed
         });
@@ -3389,7 +3722,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       }
       const currentRow = await getSubgraph(targetDb, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
-        logger9.info("Subgraph status changed, stopping catch-up", {
+        logger10.info("Subgraph status changed, stopping catch-up", {
           subgraph: subgraphName,
           status: currentRow?.status ?? "deleted"
         });
@@ -3418,7 +3751,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           blockData = (await source.loadBlockRange(height, height)).get(height);
         }
         if (!blockData) {
-          logger9.warn("Block missing during catch-up, deferring to next tick", {
+          logger10.warn("Block missing during catch-up, deferring to next tick", {
             subgraph: subgraphName,
             blockHeight: height
           });
@@ -3438,12 +3771,12 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           });
         } catch (err) {
           if (err instanceof ReorgEpochChangedError) {
-            logger9.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            logger10.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
             stopCatchup = true;
             break;
           }
           const errorMsg = err instanceof Error ? err.message : String(err);
-          logger9.error("Block processing failed persistently during catch-up", {
+          logger10.error("Block processing failed persistently during catch-up", {
             subgraph: subgraphName,
             blockHeight: height,
             error: errorMsg
@@ -3462,7 +3795,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           }
         }
         if (processed % LOG_INTERVAL2 === 0) {
-          logger9.info("Subgraph catch-up progress", {
+          logger10.info("Subgraph catch-up progress", {
             subgraph: subgraphName,
             processed,
             total: totalBlocks,
@@ -3478,7 +3811,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       currentHeight = batchEnd + 1;
     }
     await stats.flush(targetDb);
-    logger9.info("Subgraph catch-up complete", {
+    logger10.info("Subgraph catch-up complete", {
       subgraph: subgraphName,
       processed
     });
@@ -3495,14 +3828,14 @@ import {
   listSubgraphs,
   resolveSubgraphRawClient
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { logger as logger11 } from "@secondlayer/shared/logger";
 import { sql as sql4 } from "kysely";
 async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
   const targetDb = getTargetDb4();
   const activeSubgraphs = (await listSubgraphs(targetDb)).filter((v) => v.status === "active");
   if (activeSubgraphs.length === 0)
     return;
-  logger10.info("Propagating reorg to subgraphs", {
+  logger11.info("Propagating reorg to subgraphs", {
     blockHeight,
     subgraphCount: activeSubgraphs.length
   });
@@ -3519,7 +3852,7 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
         });
       });
     } catch (err) {
-      logger10.error("Subgraph reorg handling failed", {
+      logger11.error("Subgraph reorg handling failed", {
         subgraph: sg.name,
         blockHeight,
         error: getErrorMessage4(err)
@@ -3557,7 +3890,7 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       await tx.unsafe(`DELETE FROM "${schemaName}"."_journal" WHERE block_height >= $1`, [blockHeight]);
     });
   } else {
-    logger10.warn("Subgraph has no revert journal — falling back to height delete (accumulator rows may lose history)", { subgraph: sg.name, blockHeight });
+    logger11.warn("Subgraph has no revert journal — falling back to height delete (accumulator rows may lose history)", { subgraph: sg.name, blockHeight });
     for (const tableName of tableNames) {
       await client.unsafe(`DELETE FROM "${schemaName}"."${tableName}" WHERE "_block_height" >= $1`, [blockHeight]);
     }
@@ -3600,7 +3933,7 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       }).as("row_pk"),
       eb2.val("pending").as("status")
     ]).where("subgraph_name", "=", sg.name).where("table_name", "=", tableName).where("status", "=", "active")).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute().catch((err) => {
-      logger10.error("Failed to emit revert event for subscriptions", {
+      logger11.error("Failed to emit revert event for subscriptions", {
         event: "reorg_revert_emit_dropped",
         subgraph: sg.name,
         table: tableName,
@@ -3609,14 +3942,14 @@ async function reorgOneSubgraph(sg, schema, blockHeight, loadSubgraphDef) {
       });
     });
   }
-  logger10.info("Subgraph reorg cleanup done", {
+  logger11.info("Subgraph reorg cleanup done", {
     subgraph: sg.name,
     blockHeight,
     tablesAffected: Object.keys(revertedByTable).length
   });
   const def = await loadSubgraphDef(sg);
   await processBlock(def, sg.name, blockHeight, { reorgRewind: true });
-  logger10.info("Subgraph reorg reprocessed", {
+  logger11.info("Subgraph reorg reprocessed", {
     subgraph: sg.name,
     blockHeight
   });
@@ -3646,7 +3979,7 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger12 } from "@secondlayer/shared/logger";
+import { logger as logger13 } from "@secondlayer/shared/logger";
 import {
   listen,
   sourceListenerUrl,
@@ -3656,7 +3989,7 @@ import {
 // src/runtime/streams-reorg-poll.ts
 import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
 import { IndexHttpClient as IndexHttpClient2 } from "@secondlayer/shared/index-http";
-import { logger as logger11 } from "@secondlayer/shared/logger";
+import { logger as logger12 } from "@secondlayer/shared/logger";
 var POLL_MS = Number(process.env.SUBGRAPH_REORG_POLL_MS) || 15000;
 var STARTUP_MARGIN_MS = 60 * 60 * 1000;
 async function pollReorgsOnce(http2, cursor, onReorg, handled) {
@@ -3664,13 +3997,13 @@ async function pollReorgsOnce(http2, cursor, onReorg, handled) {
   const sorted = [...reorgs].sort((a, b) => a.fork_point_height - b.fork_point_height);
   for (const r of sorted) {
     if (handled && r.id && handled.has(r.id)) {
-      logger11.info("Streams reorg already handled — skipping", {
+      logger12.info("Streams reorg already handled — skipping", {
         forkPointHeight: r.fork_point_height,
         reorgId: r.id
       });
       continue;
     }
-    logger11.info("Streams reorg — rewinding", {
+    logger12.info("Streams reorg — rewinding", {
       forkPointHeight: r.fork_point_height
     });
     await onReorg(r.fork_point_height);
@@ -3698,7 +4031,7 @@ function startStreamsReorgPoll(onReorg) {
     try {
       since = await pollReorgsOnce(http2, since, onReorg, handled);
     } catch (err) {
-      logger11.error("Streams reorg poll failed", {
+      logger12.error("Streams reorg poll failed", {
         error: getErrorMessage5(err)
       });
     }
@@ -3706,7 +4039,7 @@ function startStreamsReorgPoll(onReorg) {
       timer = setTimeout(tick, POLL_MS);
   };
   timer = setTimeout(tick, POLL_MS);
-  logger11.info("Streams reorg poll started", { pollMs: POLL_MS });
+  logger12.info("Streams reorg poll started", { pollMs: POLL_MS });
   return () => {
     running = false;
     if (timer)
@@ -3737,7 +4070,7 @@ async function catchUpAll(subgraphs, db, concurrency) {
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger12.error("Subgraph catch-up failed", {
+        logger13.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -3777,7 +4110,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger12.info("Subgraph handler reloaded", {
+    logger13.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -3811,7 +4144,7 @@ async function synthesizeLegacyReindexOperations() {
         fromBlock: sg.reindex_from_block == null ? undefined : Number(sg.reindex_from_block),
         toBlock: sg.reindex_to_block == null ? undefined : Number(sg.reindex_to_block)
       });
-      logger12.info("Queued legacy reindex resume operation", {
+      logger13.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -3874,7 +4207,7 @@ async function startSubgraphOperationRunner(opts) {
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger12.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger13.info("Starting subgraph operation runner", { concurrency, lockedBy });
   try {
     const stranded = await db.selectFrom("subgraphs").select(["id", "name", "account_id"]).where("status", "=", "reindexing").where("reindex_from_block", "is not", null).where("reindex_to_block", "is not", null).where(({ not, exists, selectFrom }) => not(exists(selectFrom("subgraph_operations").select("id").whereRef("subgraph_id", "=", "subgraphs.id").where("status", "in", ["queued", "running"])))).execute();
     for (const row of stranded) {
@@ -3885,14 +4218,14 @@ async function startSubgraphOperationRunner(opts) {
           accountId: row.account_id,
           kind: "reindex"
         });
-        logger12.info("Re-enqueued stranded reindex", { subgraph: row.name });
+        logger13.info("Re-enqueued stranded reindex", { subgraph: row.name });
       } catch (err) {
         if (!isActiveSubgraphOperationConflict(err))
           throw err;
       }
     }
   } catch (err) {
-    logger12.warn("Stranded-reindex sweep failed", {
+    logger13.warn("Stranded-reindex sweep failed", {
       error: getErrorMessage6(err)
     });
   }
@@ -3903,7 +4236,7 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger12.warn("Subgraph operation heartbeat failed", {
+        logger13.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -3915,7 +4248,7 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger12.warn("Subgraph operation cancel poll failed", {
+        logger13.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
           error: getErrorMessage6(err)
         });
@@ -3932,14 +4265,14 @@ async function startSubgraphOperationRunner(opts) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "user-cancelled") {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
-          logger12.info("Subgraph operation cancelled", {
+          logger13.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger12.info("Subgraph operation interrupted", {
+          logger13.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3947,7 +4280,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger12.info("Subgraph operation completed", {
+        logger13.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3955,7 +4288,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger12.info("Subgraph operation interrupted by shutdown", {
+          logger13.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3966,7 +4299,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
-        logger12.error("Subgraph operation failed", {
+        logger13.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           error: getErrorMessage6(err)
@@ -4013,13 +4346,13 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger12.info("Subgraph operation runner stopped");
+    logger13.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger12.info("Starting subgraph processor", { concurrency });
+  logger13.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
@@ -4045,7 +4378,7 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger12.error("Subgraph reorg handling failed", {
+      logger13.error("Subgraph reorg handling failed", {
         error: getErrorMessage6(err)
       });
     }
@@ -4054,7 +4387,7 @@ async function startSubgraphProcessor(opts) {
     runCatchUp();
   }, POLL_INTERVAL_MS);
   const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll((forkHeight) => handleSubgraphReorg(forkHeight, loadSubgraphDefinition)) : undefined;
-  logger12.info("Subgraph processor ready");
+  logger13.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
@@ -4063,13 +4396,13 @@ async function startSubgraphProcessor(opts) {
     await stopReorgListening();
     stopStreamsReorgPoll?.();
     await stopOperations();
-    logger12.info("Subgraph processor stopped");
+    logger13.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { assertDbSplit, getDb } from "@secondlayer/shared/db";
-import { logger as logger13 } from "@secondlayer/shared/logger";
+import { logger as logger14 } from "@secondlayer/shared/logger";
 import { sql as sql5 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
@@ -4077,7 +4410,7 @@ async function writeHeartbeat() {
   try {
     await getDb().insertInto("service_heartbeats").values({ name: SERVICE_NAME }).onConflict((oc) => oc.column("name").doUpdateSet({ updated_at: sql5`now()` })).execute();
   } catch (err) {
-    logger13.warn("subgraph-processor heartbeat write failed", {
+    logger14.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -4089,7 +4422,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger13.info("Shutting down subgraph processor...");
+  logger14.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -4097,5 +4430,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=2FEADCB8BDBF199464756E2164756E21
+//# debugId=93DDC9090FFF48C664756E2164756E21
 //# sourceMappingURL=service.js.map