@secondlayer/subgraphs 3.7.3 → 3.8.0

package/dist/src/service.js

@@ -1217,6 +1217,37 @@ class PublicApiBlockSource {
     return map;
   }
 }
+
+class FallbackBlockSource {
+  primary;
+  fallback;
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+  async getTip() {
+    try {
+      return await this.primary.getTip();
+    } catch (err) {
+      logger3.warn("block source primary getTip failed — using DB tap", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return this.fallback.getTip();
+    }
+  }
+  async loadBlockRange(fromHeight, toHeight) {
+    try {
+      return await this.primary.loadBlockRange(fromHeight, toHeight);
+    } catch (err) {
+      logger3.warn("block source primary loadBlockRange failed — using DB tap", {
+        from: fromHeight,
+        to: toHeight,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return this.fallback.loadBlockRange(fromHeight, toHeight);
+    }
+  }
+}
 var postgresBlockSource = new PostgresBlockSource;
 function buildHttpClient() {
   const baseUrl = process.env.SUBGRAPH_INDEX_API_URL ?? process.env.STREAMS_API_URL ?? "http://api:3800";
@@ -1228,7 +1259,7 @@ function buildHttpClient() {
 }
 function resolveBlockSource(subgraph) {
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph && isStreamsIndexEligible(subgraph)) {
-    return new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph));
+    return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph)), postgresBlockSource);
   }
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
     logger3.debug("Subgraph not streams-index eligible, using DB tap", {
@@ -1737,6 +1768,65 @@ function escapeLiteralDefault(value) {
     return value ? "TRUE" : "FALSE";
   return `'${String(value).replace(/'/g, "''")}'`;
 }
+function tableNeedsTrgm(tableDef) {
+  return Object.values(tableDef.columns).some((col) => col.search);
+}
+function emitTableDDL(schemaName, tableName, tableDef) {
+  const qualifiedName = `${schemaName}.${tableName}`;
+  const statements = [];
+  const columnDefs = [
+    "_id BIGSERIAL PRIMARY KEY",
+    "_block_height BIGINT NOT NULL",
+    "_tx_id TEXT NOT NULL",
+    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
+  ];
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    const sqlType = TYPE_MAP[col.type];
+    const nullable = col.nullable ? "" : " NOT NULL";
+    let colDef = `${colName} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+    }
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
+    }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
+    }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
+    }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`);
+    }
+  }
+  return statements;
+}
+function emitForeignKeyDDL(schemaName, tableName, tableDef) {
+  return (tableDef.relations ?? []).map((rel) => {
+    const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
+    return `ALTER TABLE ${schemaName}.${tableName} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.join(", ")}) ` + `REFERENCES ${schemaName}.${rel.references} (${rel.referencedColumns.join(", ")})`;
+  });
+}
 function generateSubgraphSQL(def, schemaNameOverride) {
   const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
   const statements = [];
@@ -1746,58 +1836,10 @@ function generateSubgraphSQL(def, schemaNameOverride) {
   }
   statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
   for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    const qualifiedName = `${schemaName}.${tableName}`;
-    const columnDefs = [
-      "_id BIGSERIAL PRIMARY KEY",
-      "_block_height BIGINT NOT NULL",
-      "_tx_id TEXT NOT NULL",
-      "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
-    ];
-    for (const [colName, col] of Object.entries(tableDef.columns)) {
-      const sqlType = TYPE_MAP[col.type];
-      const nullable = col.nullable ? "" : " NOT NULL";
-      let colDef = `${colName} ${sqlType}${nullable}`;
-      if (col.default !== undefined) {
-        colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
-      }
-      columnDefs.push(colDef);
-    }
-    statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
-  ${columnDefs.join(`,
-  `)}
-)`);
-    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
-    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
-    for (const [colName, col] of Object.entries(tableDef.columns)) {
-      if (col.indexed) {
-        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
-      }
-    }
-    for (const [colName, col] of Object.entries(tableDef.columns)) {
-      if (col.search) {
-        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
-      }
-    }
-    if (tableDef.indexes) {
-      for (let i = 0;i < tableDef.indexes.length; i++) {
-        const cols = tableDef.indexes[i];
-        const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-        statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
-      }
-    }
-    if (tableDef.uniqueKeys) {
-      for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
-        const cols = tableDef.uniqueKeys[i];
-        const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
-        statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`);
-      }
-    }
+    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
   }
   for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    for (const rel of tableDef.relations ?? []) {
-      const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
-      statements.push(`ALTER TABLE ${schemaName}.${tableName} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.join(", ")}) ` + `REFERENCES ${schemaName}.${rel.references} (${rel.referencedColumns.join(", ")})`);
-    }
+    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
   }
   const hashInput = JSON.stringify({
     name: def.name,
@@ -2499,8 +2541,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,
@@ -2518,11 +2560,11 @@ import {
   pgSchemaName as pgSchemaName2,
   updateSubgraphStatus as updateSubgraphStatus3
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger15 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 import {
-  listen as listen2,
+  listen,
   sourceListenerUrl,
-  targetListenerUrl as targetListenerUrl4
+  targetListenerUrl as targetListenerUrl2
 } from "@secondlayer/shared/queue/listener";
 
 // src/runtime/catchup-leader.ts
@@ -2599,860 +2641,6 @@ function startStreamsReorgPoll(onReorg) {
   };
 }
 
-// src/runtime/subscription-plane.ts
-import { logger as logger14 } from "@secondlayer/shared/logger";
-
-// src/runtime/chain-reorg.ts
-import { getTargetDb as getTargetDb5 } from "@secondlayer/shared/db";
-import { logger as logger10 } 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();
-    logger10.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
-import {
-  getTargetDb as getTargetDb6
-} from "@secondlayer/shared/db";
-import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
-import { logger as logger12 } from "@secondlayer/shared/logger";
-import { listen, targetListenerUrl as targetListenerUrl2 } from "@secondlayer/shared/queue/listener";
-import { sql as sql4 } from "kysely";
-
-// src/runtime/formats/index.ts
-import { signSecondlayerWebhook } from "@secondlayer/shared/crypto/secondlayer-webhook";
-import { logger as logger11 } 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 buildBody(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:
-      logger11.warn("Unknown subscription format, falling back to standard-webhooks", {
-        format: sub.format,
-        subscriptionId: sub.id
-      });
-      return buildStandardWebhooks(outboxRow, signingSecret);
-  }
-}
-function buildForFormat(outboxRow, sub, signingSecret) {
-  const result = buildBody(outboxRow, sub, signingSecret);
-  const sigHeaders = signSecondlayerWebhook(outboxRow.id, result.body);
-  if (sigHeaders) {
-    result.headers = { ...result.headers, ...sigHeaders };
-  }
-  return result;
-}
-
-// 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)";
-    logger12.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();
-      logger12.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 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) {
-          logger12.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;
-  logger12.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;
-      logger12.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 = targetListenerUrl2();
-  const stopNew = await listen("subscriptions:new_outbox", () => {
-    if (!state.running)
-      return;
-    claimAndDrain(db, state, emitterId).catch((err) => logger12.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) => logger12.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) => logger12.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) => logger12.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();
-    logger12.info("[emitter] stopped", { id: emitterId });
-  };
-}
-
-// src/runtime/subscription-leader.ts
-import {
-  SUBSCRIPTION_EVALUATOR_LOCK_KEY,
-  createPostgresLeaderBackend as createPostgresLeaderBackend2,
-  withLeaderLock as withLeaderLock2
-} from "@secondlayer/shared/leader";
-import { targetListenerUrl as targetListenerUrl3 } from "@secondlayer/shared/queue/listener";
-
-// 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, replayId) {
-  const base = `chain:${subscriptionId}:${txId}:${eventIndex}:${blockHash}`;
-  return replayId ? `replay:${replayId}:${base}` : base;
-}
-function applyRow(meta, blockHeight, blockHash, txId, eventIndex, event, replayId) {
-  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, replayId),
-    ...replayId ? { is_replay: true } : {}
-  };
-}
-async function emitChainOutbox(db, matches, keyMeta, blockHeight, blockHash, opts) {
-  const replayId = opts?.replayId;
-  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
-      }, replayId));
-    } 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
-        }, replayId));
-      }
-    }
-  }
-  if (rows.length === 0)
-    return 0;
-  const result = await db.insertInto("subscription_outbox").values(rows).onConflict((oc) => oc.columns(["subscription_id", "dedup_key"]).doNothing()).executeTakeFirst();
-  return Number(result.numInsertedOrUpdatedRows ?? 0);
-}
-
-// 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 });
-  return () => {
-    running = false;
-    if (timer)
-      clearTimeout(timer);
-  };
-}
-
-// src/runtime/subscription-leader.ts
-var evaluatorLeader = false;
-function isEvaluatorLeader() {
-  return evaluatorLeader;
-}
-function gateChainReorgOnLeader(handler, isLeader = isEvaluatorLeader) {
-  return async (forkHeight) => {
-    if (!isLeader())
-      return;
-    await handler(forkHeight);
-  };
-}
-function startTriggerEvaluatorLeader(opts = {}) {
-  const startWork = opts.startWork ?? startTriggerEvaluator;
-  return withLeaderLock2(SUBSCRIPTION_EVALUATOR_LOCK_KEY, async () => {
-    evaluatorLeader = true;
-    const stop = await startWork();
-    return () => {
-      evaluatorLeader = false;
-      stop();
-    };
-  }, {
-    pollMs: opts.pollMs,
-    heartbeatMs: opts.heartbeatMs,
-    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend2(targetListenerUrl3()))
-  });
-}
-
-// src/runtime/subscription-plane.ts
-async function startSubscriptionPlane() {
-  const streamsIndex = process.env.SUBGRAPH_SOURCE === "streams-index";
-  const stopChainReorgPoll = streamsIndex ? startStreamsReorgPoll(gateChainReorgOnLeader((forkHeight) => handleChainReorg(forkHeight))) : undefined;
-  const stopTriggerEvaluator = streamsIndex ? startTriggerEvaluatorLeader() : undefined;
-  const stopEmitter = await startEmitter();
-  logger14.info("Subscription plane ready", { streamsIndex });
-  return async () => {
-    stopChainReorgPoll?.();
-    await stopTriggerEvaluator?.();
-    await stopEmitter();
-  };
-}
-
 // src/runtime/processor.ts
 var CHANNEL_NEW_BLOCK = "indexer:new_block";
 var CHANNEL_SUBGRAPH_OPERATIONS = "subgraph_operations:new";
@@ -3472,11 +2660,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");
         }
-        logger15.error("Subgraph catch-up failed", {
+        logger10.error("Subgraph catch-up failed", {
           subgraph: sg.name,
           error: msg
         });
@@ -3516,7 +2704,7 @@ async function loadSubgraphDefinition(sg) {
   definitionCache.set(sg.name, def);
   if (prevVersion && prevVersion !== sg.version) {
     invalidateSubgraphRoute(sg.name);
-    logger15.info("Subgraph handler reloaded", {
+    logger10.info("Subgraph handler reloaded", {
       subgraph: sg.name,
       from: prevVersion,
       to: sg.version
@@ -3535,7 +2723,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);
@@ -3550,7 +2738,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)
       });
-      logger15.info("Queued legacy reindex resume operation", {
+      logger10.info("Queued legacy reindex resume operation", {
         subgraph: sg.name
       });
     } catch (err) {
@@ -3564,7 +2752,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}`);
@@ -3600,13 +2788,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;
-  logger15.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);
@@ -3614,9 +2802,9 @@ async function startSubgraphOperationRunner(opts) {
       if (!running)
         return;
       heartbeatSubgraphOperation(db, operation.id, lockedBy).catch((err) => {
-        logger15.warn("Subgraph operation heartbeat failed", {
+        logger10.warn("Subgraph operation heartbeat failed", {
           operationId: operation.id,
-          error: getErrorMessage6(err)
+          error: getErrorMessage5(err)
         });
       });
     }, HEARTBEAT_INTERVAL_MS);
@@ -3626,9 +2814,9 @@ async function startSubgraphOperationRunner(opts) {
           controller.abort("user-cancelled");
         }
       }).catch((err) => {
-        logger15.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);
@@ -3643,14 +2831,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);
-          logger15.info("Subgraph operation cancelled", {
+          logger10.info("Subgraph operation cancelled", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
           return;
         }
         if (controller.signal.aborted) {
-          logger15.info("Subgraph operation interrupted", {
+          logger10.info("Subgraph operation interrupted", {
             operationId: operation.id,
             subgraph: operation.subgraph_name,
             reason
@@ -3658,7 +2846,7 @@ async function startSubgraphOperationRunner(opts) {
           return;
         }
         await completeSubgraphOperation(db, operation.id, lockedBy, processed);
-        logger15.info("Subgraph operation completed", {
+        logger10.info("Subgraph operation completed", {
           operationId: operation.id,
           subgraph: operation.subgraph_name,
           processed
@@ -3666,7 +2854,7 @@ async function startSubgraphOperationRunner(opts) {
       } catch (err) {
         const reason = String(controller.signal.reason ?? "");
         if (controller.signal.aborted && reason === "shutdown") {
-          logger15.info("Subgraph operation interrupted by shutdown", {
+          logger10.info("Subgraph operation interrupted by shutdown", {
             operationId: operation.id,
             subgraph: operation.subgraph_name
           });
@@ -3676,11 +2864,11 @@ async function startSubgraphOperationRunner(opts) {
           await cancelSubgraphOperation(db, operation.id, lockedBy, processed);
           return;
         }
-        await failSubgraphOperation(db, operation.id, lockedBy, getErrorMessage6(err), processed);
-        logger15.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);
@@ -3710,9 +2898,9 @@ async function startSubgraphOperationRunner(opts) {
   };
   await synthesizeLegacyReindexOperations();
   await drain();
-  const stopListening = await listen2(CHANNEL_SUBGRAPH_OPERATIONS, () => {
+  const stopListening = await listen(CHANNEL_SUBGRAPH_OPERATIONS, () => {
     drain();
-  }, { connectionString: targetListenerUrl4() });
+  }, { connectionString: targetListenerUrl2() });
   const pollInterval = setInterval(() => {
     drain();
   }, POLL_INTERVAL_MS);
@@ -3724,29 +2912,29 @@ async function startSubgraphOperationRunner(opts) {
       controller.abort("shutdown");
     }
     await Promise.allSettled(activeRuns.values());
-    logger15.info("Subgraph operation runner stopped");
+    logger10.info("Subgraph operation runner stopped");
   };
 }
 async function startSubgraphProcessor(opts) {
   const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
   let running = true;
-  logger15.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 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 listen2(CHANNEL_NEW_BLOCK, async () => {
+  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 {
@@ -3756,8 +2944,8 @@ async function startSubgraphProcessor(opts) {
         await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
       }
     } catch (err) {
-      logger15.error("Subgraph reorg handling failed", {
-        error: getErrorMessage6(err)
+      logger10.error("Subgraph reorg handling failed", {
+        error: getErrorMessage5(err)
       });
     }
   }, { connectionString: sourceListenerUrl() });
@@ -3765,8 +2953,7 @@ async function startSubgraphProcessor(opts) {
     runCatchUp();
   }, POLL_INTERVAL_MS);
   const stopStreamsReorgPoll = process.env.SUBGRAPH_SOURCE === "streams-index" ? startStreamsReorgPoll((forkHeight) => handleSubgraphReorg(forkHeight, loadSubgraphDefinition)) : undefined;
-  const stopSubscriptionPlane = await startSubscriptionPlane();
-  logger15.info("Subgraph processor ready");
+  logger10.info("Subgraph processor ready");
   return async () => {
     running = false;
     clearInterval(pollInterval);
@@ -3774,23 +2961,22 @@ async function startSubgraphProcessor(opts) {
     await stopListening();
     await stopReorgListening();
     stopStreamsReorgPoll?.();
-    await stopSubscriptionPlane();
     await stopOperations();
-    logger15.info("Subgraph processor stopped");
+    logger10.info("Subgraph processor stopped");
   };
 }
 
 // src/service.ts
 import { assertDbSplit, getDb } from "@secondlayer/shared/db";
-import { logger as logger16 } 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) {
-    logger16.warn("subgraph-processor heartbeat write failed", {
+    logger11.warn("subgraph-processor heartbeat write failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3802,7 +2988,7 @@ var processor = await startSubgraphProcessor({
 await writeHeartbeat();
 var heartbeatInterval = setInterval(writeHeartbeat, HEARTBEAT_INTERVAL_MS2);
 var shutdown = async () => {
-  logger16.info("Shutting down subgraph processor...");
+  logger11.info("Shutting down subgraph processor...");
   clearInterval(heartbeatInterval);
   await processor();
   process.exit(0);
@@ -3810,5 +2996,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=6699532419F8689F64756E2164756E21
+//# debugId=9428CDEA9E276AF264756E2164756E21
 //# sourceMappingURL=service.js.map