@secondlayer/subgraphs 1.0.0-alpha.0 → 1.0.0-beta.1

package/dist/src/service.js

@@ -168,7 +168,7 @@ class SubgraphContext {
   }
   async flush() {
     if (this.ops.length === 0)
-      return 0;
+      return { count: 0, writes: [] };
     const opsToFlush = [...this.ops];
     this.ops.length = 0;
     const statements = this.buildStatements(opsToFlush);
@@ -183,7 +183,21 @@ class SubgraphContext {
         }
       });
     }
-    return opsToFlush.length;
+    const writes = opsToFlush.map((op, rowIndex) => {
+      const blockHeight = op.data._block_height ?? this.block.height;
+      const txId = op.data._tx_id ?? this._tx.txId;
+      const baseRow = op.kind === "update" ? { ...op.data, ...op.set ?? {} } : { ...op.data };
+      delete baseRow._upsert_keys;
+      delete baseRow._upsert_fallback_keys;
+      delete baseRow._upsert_fallback_set;
+      return {
+        op: op.kind,
+        table: op.table,
+        row: jsonSafe(baseRow),
+        pk: { blockHeight, txId, rowIndex }
+      };
+    });
+    return { count: opsToFlush.length, writes };
   }
   prepareInsert(op) {
     const upsertKeys = op.data._upsert_keys;
@@ -276,6 +290,13 @@ class SubgraphContext {
     }
   }
 }
+function jsonSafe(row) {
+  const out = {};
+  for (const [k, v] of Object.entries(row)) {
+    out[k] = typeof v === "bigint" ? v.toString() : v;
+  }
+  return out;
+}
 function escapeLiteral(value) {
   if (value === null || value === undefined)
     return "NULL";
@@ -857,12 +878,200 @@ import {
   recordSubgraphProcessed,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger3 } from "@secondlayer/shared/logger";
-import { sql as sql2 } from "kysely";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import { sql as sql3 } from "kysely";
 
 // src/schema/utils.ts
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
 
+// src/runtime/outbox-emit.ts
+import { createHash } from "node:crypto";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+var loggedKillSwitch = false;
+function isEmitOutboxEnabled() {
+  return process.env.SECONDLAYER_EMIT_OUTBOX !== "false";
+}
+function dedupKey(subgraphName, tableName, blockHeight, txId, rowIndex, row) {
+  const canonical = `${subgraphName}:${tableName}:${blockHeight}:${txId}:${rowIndex}:${stableStringify(row)}`;
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 32);
+}
+function stableStringify(obj) {
+  const keys = Object.keys(obj).sort();
+  return JSON.stringify(keys.reduce((acc, k) => {
+    acc[k] = obj[k];
+    return acc;
+  }, {}));
+}
+async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
+  if (!isEmitOutboxEnabled()) {
+    if (!loggedKillSwitch) {
+      logger3.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
+      loggedKillSwitch = true;
+    }
+    return 0;
+  }
+  loggedKillSwitch = false;
+  if (manifest.count === 0 || matcher.size() === 0)
+    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`;
+    for (const s of subs) {
+      rows.push({
+        subscription_id: s.id,
+        subgraph_name: subgraphName,
+        table_name: write.table,
+        block_height: blockHeight,
+        tx_id: write.pk.txId || null,
+        row_pk: write.pk,
+        event_type: eventType,
+        payload: write.row,
+        dedup_key: dedupKey(subgraphName, write.table, write.pk.blockHeight, write.pk.txId, write.pk.rowIndex, write.row)
+      });
+    }
+  }
+  if (rows.length === 0)
+    return 0;
+  await tx.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).execute();
+  return rows.length;
+}
+
+// src/runtime/subscription-state.ts
+import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
+import { sql as sql2 } from "kysely";
+
+// src/runtime/emitter-matcher.ts
+function isPrimitive(v) {
+  const t = typeof v;
+  return t === "string" || t === "number" || t === "boolean";
+}
+function coerceNumeric(v) {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "bigint")
+    return Number(v);
+  if (typeof v === "string" && v !== "" && !Number.isNaN(Number(v))) {
+    return Number(v);
+  }
+  return null;
+}
+function matchClause(rowValue, clause) {
+  if (isPrimitive(clause)) {
+    if (typeof clause === "number" || typeof rowValue === "number") {
+      const a = coerceNumeric(rowValue);
+      const b = coerceNumeric(clause);
+      if (a !== null && b !== null)
+        return a === b;
+    }
+    return rowValue === clause || String(rowValue) === String(clause);
+  }
+  if (clause === null || typeof clause !== "object" || Array.isArray(clause)) {
+    return false;
+  }
+  const keys = Object.keys(clause);
+  if (keys.length !== 1)
+    return false;
+  const op = keys[0];
+  const c = clause;
+  switch (op) {
+    case "eq":
+      return matchClause(rowValue, c.eq);
+    case "neq":
+      return !matchClause(rowValue, c.neq);
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const a = coerceNumeric(rowValue);
+      const b = coerceNumeric(c[op]);
+      if (a === null || b === null)
+        return false;
+      if (op === "gt")
+        return a > b;
+      if (op === "gte")
+        return a >= b;
+      if (op === "lt")
+        return a < b;
+      return a <= b;
+    }
+    case "in": {
+      const list = c.in;
+      if (!Array.isArray(list))
+        return false;
+      return list.some((item) => isPrimitive(item) && matchClause(rowValue, item));
+    }
+    default:
+      return false;
+  }
+}
+function matchesFilter(filter, row) {
+  if (!filter || Object.keys(filter).length === 0)
+    return true;
+  for (const [col, clause] of Object.entries(filter)) {
+    if (!matchClause(row[col], clause))
+      return false;
+  }
+  return true;
+}
+function key(subgraphName, tableName) {
+  return `${subgraphName}\x00${tableName}`;
+}
+
+class SubscriptionMatcher {
+  byKey = new Map;
+  byId = new Map;
+  setAll(subs) {
+    this.byKey.clear();
+    this.byId.clear();
+    for (const sub of subs) {
+      if (sub.status !== "active")
+        continue;
+      this.byId.set(sub.id, sub);
+      const k = key(sub.subgraph_name, sub.table_name);
+      const arr = this.byKey.get(k);
+      if (arr)
+        arr.push(sub);
+      else
+        this.byKey.set(k, [sub]);
+    }
+  }
+  match(subgraphName, tableName, row) {
+    const bucket = this.byKey.get(key(subgraphName, tableName));
+    if (!bucket)
+      return [];
+    const hits = [];
+    for (const sub of bucket) {
+      if (matchesFilter(sub.filter, row))
+        hits.push(sub);
+    }
+    return hits;
+  }
+  has(subgraphName, tableName) {
+    return this.byKey.has(key(subgraphName, tableName));
+  }
+  size() {
+    return this.byId.size;
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+}
+
+// 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 schemaNameCache = new Map;
 async function processBlock(subgraph, subgraphName, blockHeight, opts) {
@@ -886,7 +1095,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   } else {
     block = await sourceDb.selectFrom("blocks").selectAll().where("height", "=", blockHeight).executeTakeFirst();
     if (!block) {
-      logger3.warn("Block not found for subgraph processing", {
+      logger4.warn("Block not found for subgraph processing", {
         subgraph: subgraphName,
         blockHeight
       });
@@ -894,7 +1103,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
       return result;
     }
     if (!block.canonical) {
-      logger3.debug("Skipping non-canonical block", {
+      logger4.debug("Skipping non-canonical block", {
         subgraph: subgraphName,
         blockHeight
       });
@@ -941,7 +1150,10 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     result.errors = runResult.errors;
     if (ctx.pendingOps > 0) {
       const flushStart = performance.now();
-      await ctx.flush();
+      const manifest = await ctx.flush();
+      if (manifest.count > 0) {
+        await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+      }
       flushMs = performance.now() - flushStart;
     }
     if (!opts?.skipProgressUpdate) {
@@ -963,10 +1175,10 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     try {
       const tables = Object.keys(subgraph.schema);
       for (const table of tables) {
-        const { rows } = await sql2.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(targetDb);
+        const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(targetDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
-          logger3.warn("Subgraph table exceeds 10M rows (estimate)", {
+          logger4.warn("Subgraph table exceeds 10M rows (estimate)", {
             subgraph: subgraphName,
             table,
             count
@@ -1047,7 +1259,7 @@ import {
   recordGapBatch
 } from "@secondlayer/shared/db/queries/subgraph-gaps";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger4 } from "@secondlayer/shared/logger";
+import { logger as logger5 } from "@secondlayer/shared/logger";
 
 // src/runtime/batch-loader.ts
 async function loadBlockRange(db, fromHeight, toHeight) {
@@ -1146,7 +1358,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     const subgraphStart = Number(subgraphRow.start_block) || 1;
     const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
     const totalBlocks = chainTip - lastProcessedBlock;
-    logger4.info("Subgraph catch-up starting", {
+    logger5.info("Subgraph catch-up starting", {
       subgraph: subgraphName,
       from: startBlock,
       to: chainTip,
@@ -1161,7 +1373,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     while (currentHeight <= chainTip) {
       const currentRow = await getSubgraph(targetDb, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
-        logger4.info("Subgraph status changed, stopping catch-up", {
+        logger5.info("Subgraph status changed, stopping catch-up", {
           subgraph: subgraphName,
           status: currentRow?.status ?? "deleted"
         });
@@ -1188,7 +1400,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
             preloaded: blockData
           });
         } catch (err) {
-          logger4.error("Block processing error during catch-up", {
+          logger5.error("Block processing error during catch-up", {
             subgraph: subgraphName,
             blockHeight: height,
             error: err instanceof Error ? err.message : String(err)
@@ -1207,7 +1419,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           }
         }
         if (processed % LOG_INTERVAL === 0) {
-          logger4.info("Subgraph catch-up progress", {
+          logger5.info("Subgraph catch-up progress", {
             subgraph: subgraphName,
             processed,
             total: totalBlocks,
@@ -1219,7 +1431,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       if (batchFailedBlocks.length > 0) {
         const gaps = coalesceGaps(batchFailedBlocks);
         await recordGapBatch(targetDb, subgraphRow.id, subgraphName, gaps).catch((err) => {
-          logger4.warn("Failed to record subgraph gaps", {
+          logger5.warn("Failed to record subgraph gaps", {
             subgraph: subgraphName,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -1230,7 +1442,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       currentHeight = batchEnd + 1;
     }
     await stats.flush(targetDb);
-    logger4.info("Subgraph catch-up complete", {
+    logger5.info("Subgraph catch-up complete", {
       subgraph: subgraphName,
       processed
     });
@@ -1244,14 +1456,14 @@ async function catchUpSubgraph(subgraph, subgraphName) {
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
 import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import { listSubgraphs } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger5 } from "@secondlayer/shared/logger";
+import { logger as logger6 } from "@secondlayer/shared/logger";
 async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
   const targetDb = getTargetDb3();
   const client = getRawClient("target");
   const activeSubgraphs = (await listSubgraphs(targetDb)).filter((v) => v.status === "active");
   if (activeSubgraphs.length === 0)
     return;
-  logger5.info("Propagating reorg to subgraphs", {
+  logger6.info("Propagating reorg to subgraphs", {
     blockHeight,
     subgraphCount: activeSubgraphs.length
   });
@@ -1264,18 +1476,18 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
       for (const tableName of Object.keys(schema)) {
         await client.unsafe(`DELETE FROM "${schemaName}"."${tableName}" WHERE "_block_height" = $1`, [blockHeight]);
       }
-      logger5.info("Subgraph reorg cleanup done", {
+      logger6.info("Subgraph reorg cleanup done", {
         subgraph: sg.name,
         blockHeight
       });
       const def = await loadSubgraphDef(sg);
       await processBlock(def, sg.name, blockHeight);
-      logger5.info("Subgraph reorg reprocessed", {
+      logger6.info("Subgraph reorg reprocessed", {
         subgraph: sg.name,
         blockHeight
       });
     } catch (err) {
-      logger5.error("Subgraph reorg handling failed", {
+      logger6.error("Subgraph reorg handling failed", {
         subgraph: sg.name,
         blockHeight,
         error: getErrorMessage2(err)
@@ -1286,13 +1498,286 @@ async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
 
 // src/runtime/processor.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getTargetDb as getTargetDb4 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
 import {
   listSubgraphs as listSubgraphs2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger6 } from "@secondlayer/shared/logger";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+import { listen as listen2 } from "@secondlayer/shared/queue/listener";
+
+// src/runtime/emitter.ts
+import {
+  getTargetDb as getTargetDb4
+} from "@secondlayer/shared/db";
+import {
+  getSubscriptionSigningSecret
+} from "@secondlayer/shared/db/queries/subscriptions";
+import { logger as logger7 } from "@secondlayer/shared/logger";
 import { listen } from "@secondlayer/shared/queue/listener";
+import { sql as sql4 } from "kysely";
+
+// src/runtime/formats/standard-webhooks.ts
+import { sign } from "@secondlayer/shared/crypto/standard-webhooks";
+function buildStandardWebhooks(outboxRow, signingSecret) {
+  const payload = {
+    type: outboxRow.event_type,
+    timestamp: new Date(outboxRow.created_at).toISOString(),
+    data: outboxRow.payload
+  };
+  const body = JSON.stringify(payload);
+  const sigHeaders = sign(body, signingSecret, {
+    id: outboxRow.id,
+    timestampSeconds: Math.floor(new Date(outboxRow.created_at).getTime() / 1000)
+  });
+  return {
+    body,
+    headers: {
+      "content-type": "application/json",
+      ...sigHeaders
+    }
+  };
+}
+
+// src/runtime/emitter.ts
+var BATCH_SIZE = 50;
+var BACKOFF_SECONDS = [30, 120, 600, 3600, 21600, 86400, 259200];
+var CIRCUIT_THRESHOLD = 20;
+function nextDelaySeconds(attempt) {
+  return BACKOFF_SECONDS[Math.min(attempt, BACKOFF_SECONDS.length - 1)];
+}
+async function dispatchOne(db, outboxRow, sub) {
+  const { body, headers } = buildStandardWebhooks(outboxRow, getSubscriptionSigningSecret(sub));
+  const start = performance.now();
+  let statusCode = null;
+  let error = null;
+  let ok = false;
+  let responseBody = "";
+  let responseHeaders = {};
+  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 newFailures = sub.circuit_failures + 1;
+    const shouldTripCircuit = newFailures >= CIRCUIT_THRESHOLD;
+    await tx.updateTable("subscriptions").set({
+      last_delivery_at: new Date,
+      last_error: errText.slice(0, 500),
+      circuit_failures: newFailures,
+      ...shouldTripCircuit ? { status: "paused", circuit_opened_at: new Date } : {},
+      updated_at: new Date
+    }).where("id", "=", outboxRow.subscription_id).execute();
+    if (shouldTripCircuit) {
+      logger7.warn("Subscription circuit tripped — paused after consecutive failures", {
+        subscription: sub.name,
+        failures: newFailures
+      });
+    }
+  });
+}
+async function claimAndDrain(db, state, emitterId) {
+  if (state.claimInFlight)
+    return 0;
+  state.claimInFlight = true;
+  try {
+    const claimed = await db.transaction().execute(async (tx) => {
+      const rows = await sql4`
+					SELECT * FROM subscription_outbox
+					WHERE status = 'pending' AND next_attempt_at <= NOW()
+					ORDER BY next_attempt_at ASC
+					FOR UPDATE SKIP LOCKED
+					LIMIT ${sql4.lit(BATCH_SIZE)}
+				`.execute(tx);
+      if (rows.rows.length === 0)
+        return [];
+      const now = new Date;
+      const lockUntil = new Date(now.getTime() + 60000);
+      await tx.updateTable("subscription_outbox").set({ locked_by: emitterId, locked_until: lockUntil }).where("id", "in", rows.rows.map((r) => r.id)).execute();
+      return rows.rows;
+    });
+    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) {
+          logger7.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 = getTargetDb4();
+  const state = {
+    running: true,
+    inFlightBySub: new Map,
+    claimInFlight: false
+  };
+  const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
+  const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
+  logger7.info("[emitter] started", { id: emitterId });
+  await refreshMatcher(db).catch((err) => {
+    logger7.error("[emitter] initial matcher refresh failed", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+  const stopNew = await listen("subscriptions:new_outbox", () => {
+    if (!state.running)
+      return;
+    claimAndDrain(db, state, emitterId).catch((err) => logger7.error("[emitter] claim failed", {
+      error: err instanceof Error ? err.message : String(err)
+    }));
+  });
+  const stopChanged = await listen("subscriptions:changed", () => {
+    if (!state.running)
+      return;
+    refreshMatcher(db).catch((err) => logger7.error("[emitter] matcher refresh failed", {
+      error: err instanceof Error ? err.message : String(err)
+    }));
+  });
+  const poll = setInterval(() => {
+    if (!state.running)
+      return;
+    claimAndDrain(db, state, emitterId).catch((err) => logger7.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) => logger7.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();
+    logger7.info("[emitter] stopped", { id: emitterId });
+  };
+}
+
+// src/runtime/processor.ts
 var CHANNEL_NEW_BLOCK = "indexer:new_block";
 var DEFAULT_CONCURRENCY = 5;
 var POLL_INTERVAL_MS = 5000;
@@ -1326,7 +1811,7 @@ async function loadSubgraphDefinition(sg) {
   knownVersions.set(sg.name, sg.version);
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
-    logger6.info("Subgraph handler reloaded", {
+    logger8.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -1346,8 +1831,8 @@ function cleanupCaches(active) {
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger6.info("Starting subgraph processor", { concurrency });
-  const targetDb = getTargetDb4();
+  logger8.info("Starting subgraph processor", { concurrency });
+  const targetDb = getTargetDb5();
   const activeSubgraphs = (await listSubgraphs2(targetDb)).filter((v) => v.status === "active");
   for (const sg of activeSubgraphs) {
     try {
@@ -1358,16 +1843,16 @@ async function startSubgraphProcessor(opts) {
       if (isHandlerNotFoundError(err)) {
         await updateSubgraphStatus2(targetDb, sg.name, "error");
       }
-      logger6.error("Subgraph catch-up failed on startup", {
+      logger8.error("Subgraph catch-up failed on startup", {
         subgraph: sg.name,
         error: msg
       });
     }
   }
-  const stopListening = await listen(CHANNEL_NEW_BLOCK, async () => {
+  const stopListening = await listen2(CHANNEL_NEW_BLOCK, async () => {
     if (!running)
       return;
-    const db = getTargetDb4();
+    const db = getTargetDb5();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     for (const sg of subgraphs) {
@@ -1379,14 +1864,14 @@ async function startSubgraphProcessor(opts) {
         if (isHandlerNotFoundError(err)) {
           await updateSubgraphStatus2(db, sg.name, "error");
         }
-        logger6.error("Subgraph processing failed", {
+        logger8.error("Subgraph processing failed", {
           subgraph: sg.name,
           error: msg
         });
       }
     }
   }, { connectionString: sourceListenerUrl() });
-  const stopReorgListening = await listen("subgraph_reorg", async (payload) => {
+  const stopReorgListening = await listen2("subgraph_reorg", async (payload) => {
     if (!running)
       return;
     try {
@@ -1396,7 +1881,7 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger6.error("Subgraph reorg handling failed", {
+      logger8.error("Subgraph reorg handling failed", {
         error: getErrorMessage3(err)
       });
     }
@@ -1404,7 +1889,7 @@ async function startSubgraphProcessor(opts) {
   const pollInterval = setInterval(async () => {
     if (!running)
       return;
-    const db = getTargetDb4();
+    const db = getTargetDb5();
     const subgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
     cleanupCaches(subgraphs);
     for (const sg of subgraphs) {
@@ -1412,35 +1897,37 @@ async function startSubgraphProcessor(opts) {
         const def = await loadSubgraphDefinition(sg);
         await catchUpSubgraph(def, sg.name);
       } catch (err) {
-        logger6.error("Subgraph poll processing failed", {
+        logger8.error("Subgraph poll processing failed", {
           subgraph: sg.name,
           error: getErrorMessage3(err)
         });
       }
     }
   }, POLL_INTERVAL_MS);
-  logger6.info("Subgraph processor ready");
+  const stopEmitter = await startEmitter();
+  logger8.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
     await stopListening();
     await stopReorgListening();
-    logger6.info("Subgraph processor stopped");
+    await stopEmitter();
+    logger8.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
-import { logger as logger7 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 var processor = await startSubgraphProcessor({
   concurrency: Number.parseInt(process.env.SUBGRAPH_CONCURRENCY ?? "5")
 });
 var shutdown = async () => {
-  logger7.info("Shutting down subgraph processor...");
+  logger9.info("Shutting down subgraph processor...");
   await processor();
   process.exit(0);
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=403B5FB854EE82EB64756E2164756E21
+//# debugId=831A226FB3756A4564756E2164756E21
 //# sourceMappingURL=service.js.map