@secondlayer/subgraphs 3.7.4 → 3.8.0

package/dist/src/runtime/emitter.js

@@ -0,0 +1,773 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/runtime/emitter.ts
+import { randomUUID } from "node:crypto";
+import {
+  getTargetDb
+} from "@secondlayer/shared/db";
+import { getSubscriptionSigningSecret } from "@secondlayer/shared/db/queries/subscriptions";
+import { logger as logger2 } from "@secondlayer/shared/logger";
+import { listen, targetListenerUrl } from "@secondlayer/shared/queue/listener";
+import { sql as sql2 } from "kysely";
+
+// src/runtime/formats/index.ts
+import { signSecondlayerWebhook } from "@secondlayer/shared/crypto/secondlayer-webhook";
+import { logger } 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:
+      logger.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/subscription-state.ts
+import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
+import { sql } from "kysely";
+
+// src/runtime/emitter-matcher.ts
+function isPrimitive(v) {
+  const t = typeof v;
+  return t === "string" || t === "number" || t === "boolean";
+}
+function coerceBigInt(v) {
+  if (typeof v === "bigint")
+    return v;
+  if (typeof v === "number") {
+    if (!Number.isFinite(v))
+      return null;
+    if (!Number.isInteger(v))
+      return null;
+    return BigInt(v);
+  }
+  if (typeof v === "string" && /^-?\d+$/.test(v)) {
+    try {
+      return BigInt(v);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function coerceFloat(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 compareNumeric(a, b) {
+  const ba = coerceBigInt(a);
+  const bb = coerceBigInt(b);
+  if (ba !== null && bb !== null) {
+    if (ba === bb)
+      return 0;
+    return ba > bb ? 1 : -1;
+  }
+  const fa = coerceFloat(a);
+  const fb = coerceFloat(b);
+  if (fa === null || fb === null)
+    return null;
+  if (fa === fb)
+    return 0;
+  return fa > fb ? 1 : -1;
+}
+function matchClause(rowValue, clause) {
+  const rowIsPrimitive = isPrimitive(rowValue) || typeof rowValue === "bigint";
+  if (isPrimitive(clause)) {
+    if (!rowIsPrimitive)
+      return false;
+    if (typeof clause === "number" || typeof rowValue === "number" || typeof rowValue === "bigint") {
+      const cmp = compareNumeric(rowValue, clause);
+      if (cmp !== null)
+        return cmp === 0;
+    }
+    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": {
+      if (!rowIsPrimitive)
+        return false;
+      const cmp = compareNumeric(rowValue, c[op]);
+      if (cmp === null)
+        return false;
+      if (op === "gt")
+        return cmp > 0;
+      if (op === "gte")
+        return cmp >= 0;
+      if (op === "lt")
+        return cmp < 0;
+      return cmp <= 0;
+    }
+    case "in": {
+      const list = c.in;
+      if (!Array.isArray(list))
+        return false;
+      if (!rowIsPrimitive)
+        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;
+      if (sub.kind !== "subgraph" || !sub.subgraph_name || !sub.table_name)
+        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 sql`
+		SELECT * FROM subscriptions WHERE status = 'active'
+	`.execute(db);
+  matcher.setAll(rows.rows);
+  return matcher.size();
+}
+
+// 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 postToSubscription(url, body, headers, timeoutMs) {
+  if (isPrivateEgress(url) && !allowPrivateEgress()) {
+    logger2.warn("[emitter] refused private egress", { url });
+    return {
+      ok: false,
+      statusCode: null,
+      error: "refused private egress (set SECONDLAYER_ALLOW_PRIVATE_EGRESS=true to allow)",
+      durationMs: 0,
+      responseBody: null,
+      responseHeaders: null
+    };
+  }
+  const start = performance.now();
+  let statusCode = null;
+  let error = null;
+  let ok = false;
+  let responseBody = "";
+  let responseHeaders = {};
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    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);
+  }
+  return {
+    ok,
+    statusCode,
+    error,
+    durationMs: Math.round(performance.now() - start),
+    responseBody: responseBody || null,
+    responseHeaders
+  };
+}
+async function dispatchOne(db, outboxRow, sub) {
+  const { body, headers } = buildForFormat(outboxRow, sub, getSubscriptionSigningSecret(sub));
+  const r = await postToSubscription(sub.url, body, headers, sub.timeout_ms);
+  const attempt = outboxRow.attempt + 1;
+  await db.insertInto("subscription_deliveries").values({
+    outbox_id: outboxRow.id,
+    subscription_id: outboxRow.subscription_id,
+    attempt,
+    status_code: r.statusCode,
+    response_headers: r.responseHeaders,
+    response_body: r.responseBody,
+    error_message: r.error,
+    duration_ms: r.durationMs
+  }).execute();
+  return {
+    ok: r.ok,
+    statusCode: r.statusCode,
+    error: r.error,
+    durationMs: r.durationMs
+  };
+}
+function buildTestOutboxRow(sub) {
+  const now = new Date;
+  return {
+    id: randomUUID(),
+    subscription_id: sub.id,
+    kind: sub.kind,
+    subgraph_name: sub.subgraph_name ?? null,
+    table_name: sub.table_name ?? null,
+    block_height: 0,
+    tx_id: null,
+    row_pk: null,
+    event_type: sub.kind === "chain" ? "chain.test.apply" : `${sub.subgraph_name ?? "subgraph"}.${sub.table_name ?? "test"}.created`,
+    payload: {
+      test: true,
+      message: "Secondlayer test delivery",
+      subscription_id: sub.id,
+      sent_at: now.toISOString()
+    },
+    dedup_key: `test:${sub.id}:${now.getTime()}`,
+    attempt: 0,
+    next_attempt_at: now,
+    status: "pending",
+    is_replay: false,
+    delivered_at: null,
+    failed_at: null,
+    locked_by: null,
+    locked_until: null,
+    created_at: now
+  };
+}
+async function deliverTestEvent(db, sub) {
+  const testRow = buildTestOutboxRow(sub);
+  const { body, headers } = buildForFormat(testRow, sub, getSubscriptionSigningSecret(sub));
+  const r = await postToSubscription(sub.url, body, headers, sub.timeout_ms);
+  const inserted = await db.insertInto("subscription_deliveries").values({
+    outbox_id: null,
+    subscription_id: sub.id,
+    attempt: 1,
+    status_code: r.statusCode,
+    response_headers: r.responseHeaders,
+    response_body: r.responseBody,
+    error_message: r.error,
+    duration_ms: r.durationMs
+  }).returning("id").executeTakeFirstOrThrow();
+  return {
+    ok: r.ok,
+    statusCode: r.statusCode,
+    error: r.error,
+    durationMs: r.durationMs,
+    deliveryId: inserted.id
+  };
+}
+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 sql2`
+			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();
+      logger2.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 sql2`
+					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 ${sql2.lit(liveLimit)}
+				`.execute(tx);
+      const replay = await sql2`
+					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 ${sql2.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) {
+          logger2.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 sql2`
+		DELETE FROM subscription_outbox
+		WHERE status = 'delivered' AND delivered_at < NOW() - interval '7 days'
+	`.execute(db);
+  await sql2`
+		DELETE FROM subscription_deliveries
+		WHERE dispatched_at < NOW() - interval '30 days'
+	`.execute(db);
+  await sql2`
+		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 = getTargetDb();
+  const state = {
+    running: true,
+    inFlightBySub: new Map,
+    claimInFlight: false
+  };
+  const pollIntervalMs = opts?.pollIntervalMs ?? 120000;
+  const retentionIntervalMs = opts?.retentionIntervalMs ?? 60 * 60000;
+  logger2.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;
+      logger2.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) => logger2.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) => logger2.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) => logger2.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) => logger2.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();
+    logger2.info("[emitter] stopped", { id: emitterId });
+  };
+}
+export {
+  startEmitter,
+  deliverTestEvent
+};
+
+//# debugId=1CD71540D1B0DBC964756E2164756E21
+//# sourceMappingURL=emitter.js.map