@secondlayer/subgraphs 3.7.2 → 3.7.4

package/dist/src/service.js

@@ -1242,6 +1242,11 @@ function resolveBlockSource(subgraph) {
 import { createHash } from "node:crypto";
 import { logger as logger4 } from "@secondlayer/shared/logger";
 var loggedKillSwitch = false;
+var OP_VERB = {
+  insert: "created",
+  update: "updated",
+  delete: "deleted"
+};
 function isEmitOutboxEnabled() {
   return process.env.SECONDLAYER_EMIT_OUTBOX !== "false";
 }
@@ -1269,12 +1274,10 @@ async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block
     return 0;
   const rows = [];
   for (const write of manifest.writes) {
-    if (write.op !== "insert")
-      continue;
     const subs = matcher.match(subgraphName, write.table, write.row);
     if (subs.length === 0)
       continue;
-    const eventType = `${subgraphName}.${write.table}.created`;
+    const eventType = `${subgraphName}.${write.table}.${OP_VERB[write.op]}`;
     for (const s of subs) {
       rows.push({
         subscription_id: s.id,
@@ -1460,13 +1463,6 @@ class SubscriptionMatcher {
 
 // src/runtime/subscription-state.ts
 var matcher = new SubscriptionMatcher;
-async function refreshMatcher(db) {
-  const rows = await sql2`
-		SELECT * FROM subscriptions WHERE status = 'active'
-	`.execute(db);
-  matcher.setAll(rows.rows);
-  return matcher.size();
-}
 
 // src/runtime/block-processor.ts
 var routeCache = new Map;
@@ -2496,8 +2492,8 @@ import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { getErrorMessage as getErrorMessage6 } from "@secondlayer/shared";
-import { getTargetDb as getTargetDb8 } from "@secondlayer/shared/db";
+import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
+import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
 import {
   cancelSubgraphOperation,
   claimSubgraphOperation,
@@ -2515,607 +2511,56 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger14 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 import {
-  listen as listen2,
+  listen,
   sourceListenerUrl,
   targetListenerUrl as targetListenerUrl2
 } from "@secondlayer/shared/queue/listener";
 
-// src/runtime/chain-reorg.ts
-import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
-import { logger as logger9 } from "@secondlayer/shared/logger";
-var MAX_ORPHANED_PER_SUB = 500;
-async function handleChainReorg(forkHeight, db = getTargetDb5()) {
-  await db.deleteFrom("subscription_outbox").where("kind", "=", "chain").where("block_height", ">=", forkHeight).where("status", "=", "pending").where("event_type", "like", "chain.%.apply").execute();
-  const delivered = await db.selectFrom("subscription_outbox").select(["subscription_id", "tx_id", "payload"]).where("kind", "=", "chain").where("block_height", ">=", forkHeight).where("status", "=", "delivered").where("event_type", "like", "chain.%.apply").orderBy("block_height").orderBy("id").execute();
-  const bySub = new Map;
-  for (const row of delivered) {
-    const list = bySub.get(row.subscription_id) ?? [];
-    const payload = row.payload;
-    list.push({ tx_id: row.tx_id, event: payload?.event ?? null });
-    bySub.set(row.subscription_id, list);
-  }
-  if (bySub.size > 0) {
-    const rows = [];
-    for (const [subscriptionId, entries] of bySub) {
-      const truncated = entries.length > MAX_ORPHANED_PER_SUB;
-      const payload = {
-        action: "rollback",
-        fork_point_height: forkHeight,
-        orphaned: truncated ? entries.slice(0, MAX_ORPHANED_PER_SUB) : entries,
-        truncated
-      };
-      rows.push({
-        subscription_id: subscriptionId,
-        kind: "chain",
-        subgraph_name: null,
-        table_name: null,
-        block_height: forkHeight,
-        tx_id: null,
-        row_pk: { fork_point_height: forkHeight },
-        event_type: "chain.reorg.rollback",
-        payload,
-        dedup_key: `chainreorg:${subscriptionId}:${forkHeight}`
-      });
-    }
-    await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
-    logger9.info("Chain reorg — emitted rollbacks", {
-      forkPointHeight: forkHeight,
-      subscriptions: bySub.size
-    });
-  }
-  await db.transaction().execute(async (trx) => {
-    const cur = await trx.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).forUpdate().executeTakeFirst();
-    if (cur && Number(cur.last_processed_block) >= forkHeight) {
-      await trx.updateTable("trigger_evaluator_state").set({ last_processed_block: forkHeight - 1, updated_at: new Date }).where("id", "=", true).execute();
-    }
-  });
-}
-
-// src/runtime/emitter.ts
+// src/runtime/catchup-leader.ts
 import {
-  getTargetDb as getTargetDb6
-} from "@secondlayer/shared/db";
-import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger11 } from "@secondlayer/shared/logger";
-import { listen, targetListenerUrl } from "@secondlayer/shared/queue/listener";
-import { sql as sql4 } from "kysely";
-
-// src/runtime/formats/index.ts
-import { logger as logger10 } from "@secondlayer/shared/logger";
-
-// src/runtime/formats/cloudevents.ts
-function buildCloudEvents(outboxRow, _sub) {
-  const event = {
-    specversion: "1.0",
-    type: outboxRow.event_type,
-    source: `secondlayer:${outboxRow.subgraph_name}`,
-    id: outboxRow.id,
-    time: new Date(outboxRow.created_at).toISOString(),
-    datacontenttype: "application/json",
-    data: outboxRow.payload
-  };
-  return {
-    body: JSON.stringify(event),
-    headers: {
-      "content-type": "application/cloudevents+json; charset=utf-8"
-    }
-  };
-}
-
-// src/runtime/formats/cloudflare.ts
-import { decryptSecret } from "@secondlayer/shared/crypto/secrets";
-function resolveBearer(sub) {
-  const cfg = sub.auth_config;
-  if (cfg.tokenEnc) {
-    return decryptSecret(Buffer.from(cfg.tokenEnc, "base64"));
-  }
-  return cfg.token ?? null;
-}
-function buildCloudflare(outboxRow, sub) {
-  const body = JSON.stringify({
-    params: {
-      ...outboxRow.payload,
-      _type: outboxRow.event_type,
-      _outboxId: outboxRow.id
-    }
-  });
-  const headers = {
-    "content-type": "application/json"
-  };
-  const token = resolveBearer(sub);
-  if (token)
-    headers.authorization = `Bearer ${token}`;
-  return { body, headers };
-}
-
-// src/runtime/formats/inngest.ts
-var INNGEST_VERSION = "2026-04-23.v1";
-function buildInngest(outboxRow) {
-  const event = {
-    name: outboxRow.event_type,
-    data: outboxRow.payload,
-    id: outboxRow.id,
-    ts: new Date(outboxRow.created_at).getTime(),
-    v: INNGEST_VERSION
-  };
-  return {
-    body: JSON.stringify([event]),
-    headers: {
-      "content-type": "application/json"
-    }
-  };
-}
-
-// src/runtime/formats/raw.ts
-function buildRaw(outboxRow, sub) {
-  const cfg = sub.auth_config;
-  const headers = {
-    "content-type": cfg.contentType ?? "application/json",
-    ...cfg.headers ?? {}
-  };
-  if (cfg.authType === "bearer" && cfg.token) {
-    headers.authorization = `Bearer ${cfg.token}`;
-  } else if (cfg.authType === "basic" && cfg.basicAuth) {
-    headers.authorization = `Basic ${cfg.basicAuth}`;
-  }
-  return {
-    body: JSON.stringify(outboxRow.payload),
-    headers
-  };
-}
-
-// src/runtime/formats/standard-webhooks.ts
-import { sign } from "@secondlayer/shared/crypto/standard-webhooks";
-function buildStandardWebhooks(outboxRow, signingSecret) {
-  const nowSeconds = Math.floor(Date.now() / 1000);
-  const payload = {
-    type: outboxRow.event_type,
-    timestamp: new Date(nowSeconds * 1000).toISOString(),
-    data: outboxRow.payload
-  };
-  const body = JSON.stringify(payload);
-  const sigHeaders = sign(body, signingSecret, {
-    id: outboxRow.id,
-    timestampSeconds: nowSeconds
-  });
-  return {
-    body,
-    headers: {
-      "content-type": "application/json",
-      ...sigHeaders
-    }
-  };
-}
-
-// src/runtime/formats/trigger.ts
-import { decryptSecret as decryptSecret2 } from "@secondlayer/shared/crypto/secrets";
-function resolveBearer2(sub) {
-  const cfg = sub.auth_config;
-  if (cfg.tokenEnc) {
-    return decryptSecret2(Buffer.from(cfg.tokenEnc, "base64"));
-  }
-  return cfg.token ?? null;
-}
-function buildTrigger(outboxRow, sub) {
-  const body = JSON.stringify({
-    payload: outboxRow.payload,
-    options: {
-      idempotencyKey: outboxRow.id
-    }
-  });
-  const headers = {
-    "content-type": "application/json"
-  };
-  const token = resolveBearer2(sub);
-  if (token)
-    headers.authorization = `Bearer ${token}`;
-  return { body, headers };
-}
-
-// src/runtime/formats/index.ts
-function buildForFormat(outboxRow, sub, signingSecret) {
-  switch (sub.format) {
-    case "inngest":
-      return buildInngest(outboxRow);
-    case "trigger":
-      return buildTrigger(outboxRow, sub);
-    case "cloudflare":
-      return buildCloudflare(outboxRow, sub);
-    case "cloudevents":
-      return buildCloudEvents(outboxRow, sub);
-    case "raw":
-      return buildRaw(outboxRow, sub);
-    case "standard-webhooks":
-      return buildStandardWebhooks(outboxRow, signingSecret);
-    default:
-      logger10.warn("Unknown subscription format, falling back to standard-webhooks", {
-        format: sub.format,
-        subscriptionId: sub.id
-      });
-      return buildStandardWebhooks(outboxRow, signingSecret);
-  }
-}
-
-// src/runtime/emitter.ts
-var BATCH_SIZE = 50;
-var LIVE_SHARE = 0.9;
-var BACKOFF_SECONDS = [30, 120, 600, 3600, 21600, 86400, 259200];
-var CIRCUIT_THRESHOLD = 20;
-var LOCK_WINDOW_MS = 60000;
-function nextDelaySeconds(attempt) {
-  return BACKOFF_SECONDS[Math.min(attempt, BACKOFF_SECONDS.length - 1)];
-}
-var PRIVATE_V4_PATTERNS = [
-  /^127\./,
-  /^10\./,
-  /^172\.(1[6-9]|2\d|3[01])\./,
-  /^192\.168\./,
-  /^169\.254\./,
-  /^0\./,
-  /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./
-];
-function isPrivateEgress(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return true;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    return true;
-  }
-  const raw = parsed.hostname.toLowerCase();
-  const host = raw.startsWith("[") && raw.endsWith("]") ? raw.slice(1, -1) : raw;
-  if (host === "localhost" || host === "0.0.0.0")
-    return true;
-  if (host === "::" || host === "::1")
-    return true;
-  if (/^f[cd][0-9a-f]{2}:/.test(host))
-    return true;
-  if (/^fe[89ab][0-9a-f]:/.test(host))
-    return true;
-  const mapped = host.match(/^::ffff:(.+)$/);
-  if (mapped) {
-    const inner = mapped[1];
-    if (/^\d+\.\d+\.\d+\.\d+$/.test(inner)) {
-      for (const p of PRIVATE_V4_PATTERNS)
-        if (p.test(inner))
-          return true;
-    }
-    const hex = inner.match(/^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
-    if (hex) {
-      const a = Number.parseInt(hex[1], 16);
-      const b = Number.parseInt(hex[2], 16);
-      const dotted = `${a >> 8 & 255}.${a & 255}.${b >> 8 & 255}.${b & 255}`;
-      for (const p of PRIVATE_V4_PATTERNS)
-        if (p.test(dotted))
-          return true;
-    }
-  }
-  for (const p of PRIVATE_V4_PATTERNS) {
-    if (p.test(host))
-      return true;
-  }
-  return false;
-}
-function allowPrivateEgress() {
-  return process.env.SECONDLAYER_ALLOW_PRIVATE_EGRESS === "true";
-}
-async function dispatchOne(db, outboxRow, sub) {
-  const { body, headers } = buildForFormat(outboxRow, sub, getSubscriptionSigningSecret(sub));
-  const start = performance.now();
-  let statusCode = null;
-  let error = null;
-  let ok = false;
-  let responseBody = "";
-  let responseHeaders = {};
-  if (isPrivateEgress(sub.url) && !allowPrivateEgress()) {
-    error = "refused private egress (set SECONDLAYER_ALLOW_PRIVATE_EGRESS=true to allow)";
-    logger11.warn("[emitter] refused private egress", {
-      subscription: sub.name,
-      url: sub.url
-    });
-    const durationMs2 = 0;
-    const attempt2 = outboxRow.attempt + 1;
-    await db.insertInto("subscription_deliveries").values({
-      outbox_id: outboxRow.id,
-      subscription_id: outboxRow.subscription_id,
-      attempt: attempt2,
-      status_code: null,
-      response_headers: null,
-      response_body: null,
-      error_message: error,
-      duration_ms: durationMs2
-    }).execute();
-    return { ok: false, statusCode: null, error, durationMs: durationMs2 };
-  }
-  try {
-    const res = await fetch(sub.url, {
-      method: "POST",
-      headers,
-      body,
-      signal: AbortSignal.timeout(sub.timeout_ms)
-    });
-    statusCode = res.status;
-    ok = res.ok;
-    const buf = await res.arrayBuffer();
-    const truncated = buf.byteLength > 8192 ? buf.slice(0, 8192) : buf;
-    responseBody = Buffer.from(truncated).toString("utf8");
-    responseHeaders = Object.fromEntries(res.headers.entries());
-  } catch (err) {
-    error = err instanceof Error ? err.message : String(err);
-  }
-  const durationMs = Math.round(performance.now() - start);
-  const attempt = outboxRow.attempt + 1;
-  await db.insertInto("subscription_deliveries").values({
-    outbox_id: outboxRow.id,
-    subscription_id: outboxRow.subscription_id,
-    attempt,
-    status_code: statusCode,
-    response_headers: responseHeaders,
-    response_body: responseBody || null,
-    error_message: error,
-    duration_ms: durationMs
-  }).execute();
-  return { ok, statusCode, error, durationMs };
-}
-async function settleDelivered(db, outboxRow) {
-  await db.transaction().execute(async (tx) => {
-    await tx.updateTable("subscription_outbox").set({
-      status: "delivered",
-      delivered_at: new Date,
-      attempt: outboxRow.attempt + 1,
-      locked_by: null,
-      locked_until: null
-    }).where("id", "=", outboxRow.id).execute();
-    await tx.updateTable("subscriptions").set({
-      last_delivery_at: new Date,
-      last_success_at: new Date,
-      circuit_failures: 0,
-      last_error: null,
-      updated_at: new Date
-    }).where("id", "=", outboxRow.subscription_id).execute();
-  });
-}
-async function settleFailed(db, outboxRow, sub, errText) {
-  const attempt = outboxRow.attempt + 1;
-  const isDead = attempt >= sub.max_retries;
-  const nextAt = isDead ? null : new Date(Date.now() + nextDelaySeconds(outboxRow.attempt) * 1000);
-  await db.transaction().execute(async (tx) => {
-    await tx.updateTable("subscription_outbox").set({
-      attempt,
-      next_attempt_at: nextAt ?? new Date,
-      status: isDead ? "dead" : "pending",
-      failed_at: isDead ? new Date : null,
-      locked_by: null,
-      locked_until: null
-    }).where("id", "=", outboxRow.id).execute();
-    const incResult = await sql4`
-			UPDATE subscriptions
-			SET circuit_failures = circuit_failures + 1,
-				last_delivery_at = NOW(),
-				last_error = ${errText.slice(0, 500)},
-				updated_at = NOW()
-			WHERE id = ${sub.id}
-			RETURNING circuit_failures
-		`.execute(tx);
-    const newFailures = incResult.rows[0]?.circuit_failures ?? sub.circuit_failures + 1;
-    const shouldTripCircuit = newFailures >= CIRCUIT_THRESHOLD;
-    if (shouldTripCircuit) {
-      await tx.updateTable("subscriptions").set({
-        status: "paused",
-        circuit_opened_at: new Date,
-        updated_at: new Date
-      }).where("id", "=", sub.id).execute();
-      logger11.warn("Subscription circuit tripped — paused after consecutive failures", {
-        subscription: sub.name,
-        failures: newFailures
-      });
-    }
+  SUBGRAPH_CATCHUP_LOCK_KEY,
+  createPostgresLeaderBackend,
+  withLeaderLock
+} from "@secondlayer/shared/leader";
+import { targetListenerUrl } from "@secondlayer/shared/queue/listener";
+var catchUpLeader = false;
+function isCatchUpLeader() {
+  return catchUpLeader;
+}
+function startCatchUpLeader(opts = {}) {
+  return withLeaderLock(SUBGRAPH_CATCHUP_LOCK_KEY, async () => {
+    catchUpLeader = true;
+    await opts.onAcquire?.();
+    return () => {
+      catchUpLeader = false;
+    };
+  }, {
+    pollMs: opts.pollMs,
+    heartbeatMs: opts.heartbeatMs,
+    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend(targetListenerUrl()))
   });
 }
-async function claimAndDrain(db, state, emitterId) {
-  if (state.claimInFlight)
-    return 0;
-  state.claimInFlight = true;
-  try {
-    const liveLimit = Math.max(1, Math.round(BATCH_SIZE * LIVE_SHARE));
-    const replayLimit = BATCH_SIZE - liveLimit;
-    const claimed = await db.transaction().execute(async (tx) => {
-      const live = await sql4`
-					SELECT * FROM subscription_outbox
-					WHERE status = 'pending'
-						AND next_attempt_at <= NOW()
-						AND is_replay = FALSE
-					ORDER BY next_attempt_at ASC
-					FOR UPDATE SKIP LOCKED
-					LIMIT ${sql4.lit(liveLimit)}
-				`.execute(tx);
-      const replay = await sql4`
-					SELECT * FROM subscription_outbox
-					WHERE status = 'pending'
-						AND next_attempt_at <= NOW()
-						AND is_replay = TRUE
-					ORDER BY next_attempt_at ASC
-					FOR UPDATE SKIP LOCKED
-					LIMIT ${sql4.lit(replayLimit)}
-				`.execute(tx);
-      const combined = [...live.rows, ...replay.rows];
-      if (combined.length === 0)
-        return [];
-      const now = new Date;
-      const lockUntil = new Date(now.getTime() + LOCK_WINDOW_MS);
-      await tx.updateTable("subscription_outbox").set({
-        locked_by: emitterId,
-        locked_until: lockUntil,
-        next_attempt_at: lockUntil
-      }).where("id", "in", combined.map((r) => r.id)).execute();
-      return combined;
-    });
-    if (claimed.length === 0)
-      return 0;
-    const bySubId = new Map;
-    for (const row of claimed) {
-      const arr = bySubId.get(row.subscription_id);
-      if (arr)
-        arr.push(row);
-      else
-        bySubId.set(row.subscription_id, [row]);
-    }
-    const subIds = Array.from(bySubId.keys());
-    const subs = await db.selectFrom("subscriptions").selectAll().where("id", "in", subIds).execute();
-    const subById = new Map(subs.map((s) => [s.id, s]));
-    await Promise.all(subIds.map((subId) => drainForSub(db, state, subById.get(subId), bySubId.get(subId))));
-    return claimed.length;
-  } finally {
-    state.claimInFlight = false;
-  }
-}
-async function drainForSub(db, state, sub, rows) {
-  const cap = sub.concurrency || 4;
-  const counter = () => state.inFlightBySub.get(sub.id) ?? 0;
-  const inc = () => state.inFlightBySub.set(sub.id, counter() + 1);
-  const dec = () => state.inFlightBySub.set(sub.id, Math.max(0, counter() - 1));
-  const queue = [...rows];
-  const workers = [];
-  const slots = Math.min(cap, queue.length);
-  for (let i = 0;i < slots; i++) {
-    workers.push((async () => {
-      while (state.running && queue.length > 0) {
-        const row = queue.shift();
-        if (!row)
-          break;
-        inc();
-        try {
-          const result = await dispatchOne(db, row, sub);
-          if (result.ok) {
-            await settleDelivered(db, row);
-          } else {
-            const err = result.error ?? `HTTP ${result.statusCode ?? "?"}`;
-            await settleFailed(db, row, sub, err);
-          }
-        } catch (err) {
-          logger11.error("Emitter dispatch crashed", {
-            outboxId: row.id,
-            error: err instanceof Error ? err.message : String(err)
-          });
-          await settleFailed(db, row, sub, err instanceof Error ? err.message : String(err));
-        } finally {
-          dec();
-        }
-      }
-    })());
-  }
-  await Promise.all(workers);
-}
-async function runRetention(db) {
-  await sql4`
-		DELETE FROM subscription_outbox
-		WHERE status = 'delivered' AND delivered_at < NOW() - interval '7 days'
-	`.execute(db);
-  await sql4`
-		DELETE FROM subscription_deliveries
-		WHERE dispatched_at < NOW() - interval '30 days'
-	`.execute(db);
-  await sql4`
-		DELETE FROM subscription_outbox
-		WHERE status = 'dead' AND failed_at < NOW() - interval '90 days'
-	`.execute(db);
-}
-async function startEmitter(opts) {
-  const emitterId = `emitter-${Math.random().toString(36).slice(2, 10)}`;
-  const db = getTargetDb6();
-  const state = {
-    running: true,
-    inFlightBySub: new Map,
-    claimInFlight: false
-  };
-  const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
-  const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
-  logger11.info("[emitter] started", { id: emitterId });
-  const MATCHER_BOOT_ATTEMPTS = 5;
-  let lastErr = null;
-  for (let i = 0;i < MATCHER_BOOT_ATTEMPTS; i++) {
-    try {
-      await refreshMatcher(db);
-      lastErr = null;
-      break;
-    } catch (err) {
-      lastErr = err;
-      const delayMs = 500 * 2 ** i;
-      logger11.warn("[emitter] matcher refresh failed, retrying", {
-        attempt: i + 1,
-        delayMs,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      await new Promise((r) => setTimeout(r, delayMs));
-    }
-  }
-  if (lastErr) {
-    throw new Error(`[emitter] matcher refresh failed ${MATCHER_BOOT_ATTEMPTS}×; aborting boot: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
-  }
-  const listenUrl = targetListenerUrl();
-  const stopNew = await listen("subscriptions:new_outbox", () => {
-    if (!state.running)
-      return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger11.error("[emitter] claim failed", {
-      error: err instanceof Error ? err.message : String(err)
-    }));
-  }, { connectionString: listenUrl });
-  const stopChanged = await listen("subscriptions:changed", () => {
-    if (!state.running)
-      return;
-    refreshMatcher(db).catch((err) => logger11.error("[emitter] matcher refresh failed", {
-      error: err instanceof Error ? err.message : String(err)
-    }));
-  }, { connectionString: listenUrl });
-  const poll = setInterval(() => {
-    if (!state.running)
-      return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger11.error("[emitter] poll claim failed", {
-      error: err instanceof Error ? err.message : String(err)
-    }));
-  }, pollIntervalMs);
-  claimAndDrain(db, state, emitterId);
-  const retention = setInterval(() => {
-    if (!state.running)
-      return;
-    runRetention(db).catch((err) => logger11.error("[emitter] retention failed", {
-      error: err instanceof Error ? err.message : String(err)
-    }));
-  }, retentionIntervalMs);
-  return async () => {
-    state.running = false;
-    clearInterval(poll);
-    clearInterval(retention);
-    await stopNew();
-    await stopChanged();
-    logger11.info("[emitter] stopped", { id: emitterId });
-  };
-}
 
 // src/runtime/streams-reorg-poll.ts
 import { getErrorMessage as getErrorMessage4 } from "@secondlayer/shared";
 import { IndexHttpClient as IndexHttpClient2 } from "@secondlayer/shared/index-http";
-import { logger as logger12 } from "@secondlayer/shared/logger";
+import { logger as logger9 } 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(http, cursor, handleReorg, loadDef, handleChainReorg2) {
+async function pollReorgsOnce(http, cursor, onReorg) {
   const { reorgs, next_since } = await http.listReorgs(cursor);
   const sorted = [...reorgs].sort((a, b) => a.fork_point_height - b.fork_point_height);
   for (const r of sorted) {
-    logger12.info("Streams reorg — rewinding subgraphs", {
+    logger9.info("Streams reorg — rewinding", {
       forkPointHeight: r.fork_point_height
     });
-    await handleReorg(r.fork_point_height, loadDef);
-    if (handleChainReorg2)
-      await handleChainReorg2(r.fork_point_height);
+    await onReorg(r.fork_point_height);
   }
   return next_since ?? cursor;
 }
-function startStreamsReorgPoll(handleReorg, loadDef, handleChainReorg2) {
+function startStreamsReorgPoll(onReorg) {
   const baseUrl = process.env.SUBGRAPH_INDEX_API_URL ?? process.env.STREAMS_API_URL ?? "http://api:3800";
   const http = new IndexHttpClient2({
     indexBaseUrl: baseUrl,
@@ -3129,9 +2574,9 @@ function startStreamsReorgPoll(handleReorg, loadDef, handleChainReorg2) {
     if (!running)
       return;
     try {
-      since = await pollReorgsOnce(http, since, handleReorg, loadDef, handleChainReorg2);
+      since = await pollReorgsOnce(http, since, onReorg);
     } catch (err) {
-      logger12.error("Streams reorg poll failed", {
+      logger9.error("Streams reorg poll failed", {
         error: getErrorMessage4(err)
       });
     }
@@ -3139,222 +2584,7 @@ function startStreamsReorgPoll(handleReorg, loadDef, handleChainReorg2) {
       timer = setTimeout(tick, POLL_MS);
   };
   timer = setTimeout(tick, POLL_MS);
-  logger12.info("Streams reorg poll started", { pollMs: POLL_MS });
-  return () => {
-    running = false;
-    if (timer)
-      clearTimeout(timer);
-  };
-}
-
-// src/runtime/trigger-evaluator-loop.ts
-import { getErrorMessage as getErrorMessage5 } from "@secondlayer/shared";
-import { getTargetDb as getTargetDb7 } from "@secondlayer/shared/db";
-import { listActiveChainSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger13 } from "@secondlayer/shared/logger";
-
-// src/runtime/trigger-evaluator.ts
-import { resolveTraitContractIds as resolveTraitContractIds2 } from "@secondlayer/shared/db/queries/contracts";
-var TX_LEVEL_TRIGGER_TYPES = new Set(["contract_call", "contract_deploy"]);
-function sourceKey(subscriptionId, triggerIndex) {
-  return `${subscriptionId}#${triggerIndex}`;
-}
-function toAmount(v) {
-  return v === undefined ? undefined : BigInt(v);
-}
-function chainTriggerToFilter(trigger) {
-  const t = trigger;
-  const filter = { ...trigger };
-  const minAmount = toAmount(t.minAmount);
-  const maxAmount = toAmount(t.maxAmount);
-  if (minAmount !== undefined)
-    filter.minAmount = minAmount;
-  if (maxAmount !== undefined)
-    filter.maxAmount = maxAmount;
-  return filter;
-}
-function triggersOf(sub) {
-  return sub.triggers ?? [];
-}
-function buildSourcesMap(chainSubs) {
-  const sources = {};
-  const keyMeta = new Map;
-  for (const sub of chainSubs) {
-    triggersOf(sub).forEach((trigger, triggerIndex) => {
-      const key2 = sourceKey(sub.id, triggerIndex);
-      sources[key2] = chainTriggerToFilter(trigger);
-      keyMeta.set(key2, {
-        subscriptionId: sub.id,
-        triggerIndex,
-        triggerType: trigger.type
-      });
-    });
-  }
-  return { sources, keyMeta };
-}
-function referencedEventTypes(chainSubs) {
-  const filterTypes = new Set;
-  for (const sub of chainSubs) {
-    for (const trigger of triggersOf(sub))
-      filterTypes.add(trigger.type);
-  }
-  return indexEventTypesForFilterTypes([...filterTypes]);
-}
-function referencedTraits(chainSubs) {
-  const traits = new Set;
-  for (const sub of chainSubs) {
-    for (const trigger of triggersOf(sub)) {
-      const trait = trigger.trait;
-      if (trait)
-        traits.add(trait);
-    }
-  }
-  return [...traits];
-}
-async function buildTraitContracts(db, chainSubs, asOfBlock) {
-  const resolved = new Map;
-  for (const trait of referencedTraits(chainSubs)) {
-    const ids = await resolveTraitContractIds2(db, trait, asOfBlock);
-    resolved.set(trait, new Set(ids));
-  }
-  return resolved;
-}
-function evaluateBlock(block, sources, traitContracts) {
-  return matchSources(sources, block.txs, block.events, traitContracts);
-}
-function chainDedupKey(subscriptionId, txId, eventIndex, blockHash) {
-  return `chain:${subscriptionId}:${txId}:${eventIndex}:${blockHash}`;
-}
-function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event) {
-  const payload = {
-    action: "apply",
-    block_hash: blockHash,
-    block_height: blockHeight,
-    tx_id: txId,
-    canonical: true,
-    trigger: meta.triggerType,
-    event
-  };
-  return {
-    subscription_id: meta.subscriptionId,
-    kind: "chain",
-    subgraph_name: null,
-    table_name: null,
-    block_height: blockHeight,
-    tx_id: txId,
-    row_pk: { tx_id: txId, event_index: eventIndex },
-    event_type: `chain.${meta.triggerType}.apply`,
-    payload,
-    dedup_key: chainDedupKey(meta.subscriptionId, txId, eventIndex, blockHash)
-  };
-}
-async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash) {
-  const rows = [];
-  for (const match of matches) {
-    const meta = keyMeta.get(match.sourceName);
-    if (!meta)
-      continue;
-    const txId = match.tx.tx_id;
-    if (TX_LEVEL_TRIGGER_TYPES.has(meta.triggerType)) {
-      rows.push(applyRow(meta, blockHeight, blockHash, txId, -1, {
-        tx_id: txId,
-        type: match.tx.type,
-        sender: match.tx.sender,
-        status: match.tx.status,
-        contract_id: match.tx.contract_id ?? null,
-        function_name: match.tx.function_name ?? null,
-        function_args: match.tx.function_args ?? null,
-        result_hex: match.tx.raw_result ?? null
-      }));
-    } else {
-      for (const event of match.events) {
-        rows.push(applyRow(meta, blockHeight, blockHash, txId, event.event_index, {
-          tx_id: txId,
-          type: event.type,
-          event_index: event.event_index,
-          data: event.data
-        }));
-      }
-    }
-  }
-  if (rows.length === 0)
-    return 0;
-  await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
-  return rows.length;
-}
-
-// src/runtime/trigger-evaluator-loop.ts
-var POLL_MS2 = Number(process.env.TRIGGER_EVALUATOR_POLL_MS) || 5000;
-var BATCH = Number(process.env.TRIGGER_EVALUATOR_BATCH) || 200;
-var MAX_BLOCKS_PER_TICK = Number(process.env.TRIGGER_EVALUATOR_MAX_BLOCKS) || 2000;
-async function readCursor(db) {
-  const row = await db.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).executeTakeFirst();
-  return row ? Number(row.last_processed_block) : 0;
-}
-async function advanceCursor(db, to) {
-  await db.transaction().execute(async (trx) => {
-    const cur = await trx.selectFrom("trigger_evaluator_state").select("last_processed_block").where("id", "=", true).forUpdate().executeTakeFirst();
-    if (cur && Number(cur.last_processed_block) < to) {
-      await trx.updateTable("trigger_evaluator_state").set({ last_processed_block: to, updated_at: new Date }).where("id", "=", true).execute();
-    }
-  });
-}
-async function runEvaluatorOnce(db = getTargetDb7()) {
-  const chainSubs = await listActiveChainSubscriptions(db);
-  const source = new PublicApiBlockSource(buildHttpClient(), referencedEventTypes(chainSubs));
-  const tip = await source.getTip();
-  if (tip <= 0)
-    return 0;
-  const cursor = await readCursor(db);
-  if (cursor === 0 || chainSubs.length === 0) {
-    await advanceCursor(db, tip);
-    return 0;
-  }
-  if (cursor >= tip)
-    return 0;
-  const { sources, keyMeta } = buildSourcesMap(chainSubs);
-  const target = Math.min(tip, cursor + MAX_BLOCKS_PER_TICK);
-  let emitted = 0;
-  for (let from = cursor + 1;from <= target; from = from + BATCH) {
-    const to = Math.min(from + BATCH - 1, target);
-    const blocks = await source.loadBlockRange(from, to);
-    const traitContracts = await buildTraitContracts(db, chainSubs, to);
-    for (let h = from;h <= to; h++) {
-      const bd = blocks.get(h);
-      if (!bd)
-        continue;
-      const matches = evaluateBlock(bd, sources, traitContracts);
-      if (matches.length === 0)
-        continue;
-      emitted += await emitChainOutbox(db, matches, keyMeta, h, bd.block.hash);
-    }
-    await advanceCursor(db, to);
-  }
-  return emitted;
-}
-function startTriggerEvaluator() {
-  let running = true;
-  let timer;
-  const tick = async () => {
-    if (!running)
-      return;
-    try {
-      const emitted = await runEvaluatorOnce();
-      if (emitted > 0) {
-        logger13.info("Trigger evaluator emitted chain deliveries", {
-          count: emitted
-        });
-      }
-    } catch (err) {
-      logger13.error("Trigger evaluator tick failed", {
-        error: getErrorMessage5(err)
-      });
-    }
-    if (running)
-      timer = setTimeout(tick, POLL_MS2);
-  };
-  timer = setTimeout(tick, POLL_MS2);
-  logger13.info("Trigger evaluator started", { pollMs: POLL_MS2 });
+  logger9.info("Streams reorg poll started", { pollMs: POLL_MS });
   return () => {
     running = false;
     if (timer)
@@ -3381,11 +2611,11 @@ async function catchUpAll(subgraphs, db, concurrency) {
         const def = await loadSubgraphDefinition(sg);
         await catchUpSubgraph(def, sg.name);
       } catch (err) {
-        const msg = getErrorMessage6(err);
+        const msg = getErrorMessage5(err);
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus3(db, sg.name, "error");
         }
-        logger14.error("Subgraph catch-up failed", {
+        logger10.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -3425,7 +2655,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger14.info("Subgraph handler reloaded", {
+    logger10.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -3444,7 +2674,7 @@ function cleanupCaches(active) {
   }
 }
 async function synthesizeLegacyReindexOperations() {
-  const db = getTargetDb8();
+  const db = getTargetDb5();
   const stale = (await listSubgraphs2(db)).filter((sg) => sg.status === "reindexing");
   for (const sg of stale) {
     const active = await findActiveSubgraphOperation(db, sg.id);
@@ -3459,7 +2689,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)
       });
-      logger14.info("Queued legacy reindex resume operation", {
+      logger10.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -3473,7 +2703,7 @@ async function runSubgraphOperation(operation, signal) {
   if (operation.cancel_requested) {
     return 0;
   }
-  const db = getTargetDb8();
+  const db = getTargetDb5();
   const subgraph = await db.selectFrom("subgraphs").selectAll().where("id", "=", operation.subgraph_id).executeTakeFirst();
   if (!subgraph)
     throw new Error(`Subgraph not found: ${operation.subgraph_id}`);
@@ -3509,13 +2739,13 @@ async function runSubgraphOperation(operation, signal) {
 }
 async function startSubgraphOperationRunner(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_OPERATION_CONCURRENCY;
-  const db = getTargetDb8();
+  const db = getTargetDb5();
   const lockedBy = `${hostname()}:${process.pid}:${randomUUID()}`;
   const active = new Map;
   const activeRuns = new Map;
   let running = true;
   let draining = false;
-  logger14.info("Starting subgraph operation runner", { concurrency, lockedBy });
+  logger10.info("Starting subgraph operation runner", { concurrency, lockedBy });
   const startOperation = (operation) => {
     const controller = new AbortController;
     active.set(operation.id, controller);
@@ -3523,9 +2753,9 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger14.warn("Subgraph operation heartbeat failed", {
+        logger10.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
-          error: getErrorMessage6(err)
+          error: getErrorMessage5(err)
         });
       });
     }, HEARTBEAT_INTERVAL_MS);
@@ -3535,9 +2765,9 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger14.warn("Subgraph operation cancel poll failed", {
+        logger10.warn("Subgraph operation cancel poll failed", {
           operationId: operation.id,
-          error: getErrorMessage6(err)
+          error: getErrorMessage5(err)
         });
       });
     }, CANCEL_POLL_INTERVAL_MS);
@@ -3552,14 +2782,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);
-          logger14.info("Subgraph operation cancelled", {
+          logger10.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger14.info("Subgraph operation interrupted", {
+          logger10.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3567,7 +2797,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger14.info("Subgraph operation completed", {
+        logger10.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3575,7 +2805,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger14.info("Subgraph operation interrupted by shutdown", {
+          logger10.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3585,11 +2815,11 @@ async function startSubgraphOperationRunner(opts) {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
           return;
         }
-        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
-        logger14.error("Subgraph operation failed", {
+        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage5(err), processed);
+        logger10.error("Subgraph operation failed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
-          error: getErrorMessage6(err)
+          error: getErrorMessage5(err)
         });
       } finally {
         clearInterval(heartbeat);
@@ -3619,7 +2849,7 @@ async function startSubgraphOperationRunner(opts) {
   };
   await synthesizeLegacyReindexOperations();
   await drain();
-  const stopListening = await listen2(CHANNEL_SUBGRAPH_OPERATIONS, () => {
+  const stopListening = await listen(CHANNEL_SUBGRAPH_OPERATIONS, () => {
     drain();
   }, { connectionString: targetListenerUrl2() });
   const pollInterval = setInterval(() => {
@@ -3633,28 +2863,29 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger14.info("Subgraph operation runner stopped");
+    logger10.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger14.info("Starting subgraph processor", { concurrency });
+  logger10.info("Starting subgraph processor", { concurrency });
   const stopOperations = await startSubgraphOperationRunner({
     concurrency: Number.parseInt(process.env.SUBGRAPH_OPERATION_CONCURRENCY ?? String(DEFAULT_OPERATION_CONCURRENCY))
   });
-  const targetDb = getTargetDb8();
-  const activeSubgraphs = (await listSubgraphs2(targetDb)).filter((v) => v.status === "active");
-  await catchUpAll(activeSubgraphs, targetDb, concurrency);
-  const stopListening = await listen2(CHANNEL_NEW_BLOCK, async () => {
-    if (!running)
+  const runCatchUp = async () => {
+    if (!running || !isCatchUpLeader())
       return;
-    const db = getTargetDb8();
+    const db = getTargetDb5();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     await catchUpAll(subgraphs, db, concurrency);
+  };
+  const stopCatchUpLeader = startCatchUpLeader({ onAcquire: runCatchUp });
+  const stopListening = await listen(CHANNEL_NEW_BLOCK, async () => {
+    await runCatchUp();
   }, { connectionString: sourceListenerUrl() });
-  const stopReorgListening = await listen2("subgraph_reorg", async (payload) => {
+  const stopReorgListening = await listen("subgraph_reorg", async (payload) => {
     if (!running)
       return;
     try {
@@ -3664,47 +2895,39 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger14.error("Subgraph reorg handling failed", {
-        error: getErrorMessage6(err)
+      logger10.error("Subgraph reorg handling failed", {
+        error: getErrorMessage5(err)
       });
     }
   }, { connectionString: sourceListenerUrl() });
-  const pollInterval = setInterval(async () => {
-    if (!running)
-      return;
-    const db = getTargetDb8();
-    const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
-    cleanupCaches(subgraphs);
-    await catchUpAll(subgraphs, db, concurrency);
+  const pollInterval = setInterval(() => {
+    runCatchUp();
   }, POLL_INTERVAL_MS);
-  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll(handleSubgraphReorg, loadSubgraphDefinition, (forkHeight) => handleChainReorg(forkHeight)) : undefined;
-  const stopTriggerEvaluator = process.env.SUBGRAPH_SOURCE === "streams-index" ? startTriggerEvaluator() : undefined;
-  const stopEmitter = await startEmitter();
-  logger14.info("Subgraph processor ready");
+  const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll((forkHeight) => handleSubgraphReorg(forkHeight, loadSubgraphDefinition)) : undefined;
+  logger10.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
+    await stopCatchUpLeader();
     await stopListening();
     await stopReorgListening();
     stopStreamsReorgPoll?.();
-    stopTriggerEvaluator?.();
     await stopOperations();
-    await stopEmitter();
-    logger14.info("Subgraph processor stopped");
+    logger10.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { assertDbSplit, getDb } from "@secondlayer/shared/db";
-import { logger as logger15 } from "@secondlayer/shared/logger";
-import { sql as sql5 } from "kysely";
+import { logger as logger11 } from "@secondlayer/shared/logger";
+import { sql as sql4 } from "kysely";
 var HEARTBEAT_INTERVAL_MS2 = 30000;
 var SERVICE_NAME = "subgraph-processor";
 async function writeHeartbeat() {
   try {
-    await getDb().insertInto("service_heartbeats").values({ name: SERVICE_NAME }).onConflict((oc) => oc.column("name").doUpdateSet({ updated_at: sql5`now()` })).execute();
+    await getDb().insertInto("service_heartbeats").values({ name: SERVICE_NAME }).onConflict((oc) => oc.column("name").doUpdateSet({ updated_at: sql4`now()` })).execute();
   } catch (err) {
-    logger15.warn("subgraph-processor heartbeat write failed", {
+    logger11.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3716,7 +2939,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger15.info("Shutting down subgraph processor...");
+  logger11.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -3724,5 +2947,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=831057288D2A0BE564756E2164756E21
+//# debugId=FAA88387F9E565F664756E2164756E21
 //# sourceMappingURL=service.js.map