hood-alerts 0.1.0

package/dist/chunk-Z4DJPESQ.js

@@ -0,0 +1,1216 @@
+import {
+  createEventSources,
+  createLiquidityReader,
+  createTokenMetaReader
+} from "./chunk-CBNZ6AZT.js";
+import {
+  checkRateLimit,
+  createRpcReputationProvider,
+  matchRules,
+  rateLimitKey
+} from "./chunk-Y2M3USWZ.js";
+import {
+  createPriceOracle
+} from "./chunk-6JQK5G3Z.js";
+import {
+  createCaptureNotifier,
+  createDiscordBotNotifier,
+  createDiscordWebhookNotifier,
+  renderAlert
+} from "./chunk-SOBZ2FPP.js";
+import {
+  createCommandRouter,
+  createDiscordInteractionHandler,
+  createLogger,
+  createTelegramBot
+} from "./chunk-32GS6XVE.js";
+import {
+  createTelegramClient,
+  createTelegramNotifier
+} from "./chunk-NBMINJ5E.js";
+import {
+  createEntitlementGate
+} from "./chunk-RSTLW7XH.js";
+import {
+  chainEntitlementProviders,
+  createStaticEntitlementProvider,
+  createUsdgEntitlementProvider
+} from "./chunk-W2GUAWUR.js";
+import {
+  parseSubscription
+} from "./chunk-VC5MKEY2.js";
+
+// src/service/config.ts
+import { z } from "zod";
+var bool = (defaultValue) => z.string().optional().transform((value) => {
+  if (value === void 0 || value.trim() === "") return defaultValue;
+  return /^(1|true|yes|on)$/i.test(value.trim());
+});
+var int = (defaultValue, min, max) => z.string().optional().transform((value) => value === void 0 || value.trim() === "" ? defaultValue : Number(value)).refine((value) => Number.isFinite(value) && value >= min && value <= max, {
+  message: `must be a number between ${min} and ${max}`
+});
+var bigintValue = (defaultValue) => z.string().optional().transform((value) => value === void 0 || value.trim() === "" ? defaultValue : BigInt(value.trim()));
+var csv = z.string().optional().transform(
+  (value) => (value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean)
+);
+var addressValue = z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 0x-prefixed address").optional();
+var envSchema = z.object({
+  NETWORK: z.enum(["mainnet", "testnet"]).optional().default("mainnet"),
+  ROBINHOOD_RPC_URL: z.string().url().optional(),
+  DB_PATH: z.string().optional().default("./data/hood-alerts.sqlite"),
+  PORT: int(8080, 1, 65535),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).optional().default("info"),
+  DRY_RUN: bool(false),
+  TELEGRAM_BOT_TOKEN: z.string().optional(),
+  DISCORD_BOT_TOKEN: z.string().optional(),
+  DISCORD_APPLICATION_ID: z.string().optional(),
+  DISCORD_PUBLIC_KEY: z.string().optional(),
+  DISCORD_INTERACTIONS_PATH: z.string().optional().default("/discord/interactions"),
+  POLL_INTERVAL_MS: int(3e3, 250, 6e5),
+  FLUSH_INTERVAL_MS: int(1e3, 100, 6e5),
+  CONFIRMATIONS: bigintValue(2n),
+  CHUNK_SIZE: bigintValue(2000n),
+  INITIAL_LOOKBACK_BLOCKS: bigintValue(5000n),
+  WHALE_MIN_USD: int(1e3, 0, 1e9),
+  WHALE_POOL_LIMIT: int(400, 1, 5e3),
+  FLUSH_BATCH_SIZE: int(50, 1, 1e3),
+  MAX_DELIVERY_ATTEMPTS: int(6, 1, 50),
+  RETRY_BACKOFF_MS: int(3e4, 100, 36e5),
+  OUTBOX_RETENTION_HOURS: int(72, 1, 8760),
+  ENTITLEMENTS: z.enum(["static", "usdg", "both"]).optional().default("static"),
+  PREMIUM_SUBSCRIBERS: csv,
+  ALL_PREMIUM: bool(false),
+  USDG_RECEIVER: addressValue,
+  PREMIUM_PRICE_USDG: int(25, 1, 1e6),
+  PREMIUM_PERIOD_DAYS: int(30, 1, 3650),
+  PAYMENTS_FROM_BLOCK: bigintValue(0n),
+  UPGRADE_INSTRUCTIONS: z.string().optional()
+});
+function loadConfig(env = process.env) {
+  const parsed = envSchema.safeParse(env);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "env"}: ${issue.message}`).join("\n  ");
+    throw new Error(`hood-alerts: invalid configuration
+  ${detail}`);
+  }
+  const value = parsed.data;
+  if (value.ENTITLEMENTS !== "static" && !value.USDG_RECEIVER) {
+    throw new Error(
+      "hood-alerts: ENTITLEMENTS=usdg (or both) needs USDG_RECEIVER, the address subscribers pay."
+    );
+  }
+  if (value.DISCORD_APPLICATION_ID && !value.DISCORD_PUBLIC_KEY) {
+    throw new Error(
+      "hood-alerts: DISCORD_APPLICATION_ID is set but DISCORD_PUBLIC_KEY is not. Interactions cannot be verified without it."
+    );
+  }
+  return {
+    network: value.NETWORK,
+    rpcUrl: value.ROBINHOOD_RPC_URL,
+    dbPath: value.DB_PATH,
+    port: value.PORT,
+    logLevel: value.LOG_LEVEL,
+    dryRun: value.DRY_RUN,
+    telegramBotToken: value.TELEGRAM_BOT_TOKEN,
+    discordBotToken: value.DISCORD_BOT_TOKEN,
+    discordApplicationId: value.DISCORD_APPLICATION_ID,
+    discordPublicKey: value.DISCORD_PUBLIC_KEY,
+    discordInteractionsPath: value.DISCORD_INTERACTIONS_PATH,
+    pollIntervalMs: value.POLL_INTERVAL_MS,
+    flushIntervalMs: value.FLUSH_INTERVAL_MS,
+    confirmations: value.CONFIRMATIONS,
+    chunkSize: value.CHUNK_SIZE,
+    initialLookbackBlocks: value.INITIAL_LOOKBACK_BLOCKS,
+    whaleMinUsd: value.WHALE_MIN_USD,
+    whalePoolLimit: value.WHALE_POOL_LIMIT,
+    flushBatchSize: value.FLUSH_BATCH_SIZE,
+    maxDeliveryAttempts: value.MAX_DELIVERY_ATTEMPTS,
+    retryBackoffMs: value.RETRY_BACKOFF_MS,
+    outboxRetentionHours: value.OUTBOX_RETENTION_HOURS,
+    entitlements: value.ENTITLEMENTS,
+    premiumSubscribers: value.PREMIUM_SUBSCRIBERS,
+    allPremium: value.ALL_PREMIUM,
+    usdgReceiver: value.USDG_RECEIVER,
+    premiumPriceUsdg: value.PREMIUM_PRICE_USDG,
+    premiumPeriodDays: value.PREMIUM_PERIOD_DAYS,
+    paymentsFromBlock: value.PAYMENTS_FROM_BLOCK,
+    upgradeInstructions: value.UPGRADE_INSTRUCTIONS
+  };
+}
+
+// src/service/codec.ts
+var BIGINT_TAG = "$bigint";
+function encode(value) {
+  return JSON.stringify(
+    value,
+    (_key, raw) => typeof raw === "bigint" ? { [BIGINT_TAG]: raw.toString() } : raw
+  );
+}
+function decode(text) {
+  return JSON.parse(text, (_key, raw) => {
+    if (typeof raw === "object" && raw !== null && Object.keys(raw).length === 1 && typeof raw[BIGINT_TAG] === "string") {
+      return BigInt(raw[BIGINT_TAG]);
+    }
+    return raw;
+  });
+}
+function encodeEvent(event) {
+  return encode(event);
+}
+function decodeEvent(text) {
+  return decode(text);
+}
+
+// src/service/store.ts
+import { createRequire } from "module";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { getAddress } from "viem";
+var requireFromHere = createRequire(
+  import.meta.url ?? `${process.cwd()}/`
+);
+var { DatabaseSync } = requireFromHere("node:sqlite");
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS subscriptions (
+  id            TEXT PRIMARY KEY,
+  subscriber_id TEXT NOT NULL,
+  platform      TEXT NOT NULL,
+  target        TEXT NOT NULL,
+  enabled       INTEGER NOT NULL DEFAULT 1,
+  rules         TEXT NOT NULL,
+  created_at    INTEGER NOT NULL,
+  updated_at    INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_subscriber ON subscriptions(subscriber_id);
+
+CREATE TABLE IF NOT EXISTS cursors (
+  source_id  TEXT PRIMARY KEY,
+  next_block TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS outbox (
+  id              TEXT PRIMARY KEY,
+  subscription_id TEXT NOT NULL,
+  subscriber_id   TEXT NOT NULL,
+  rule_id         TEXT NOT NULL,
+  event_id        TEXT NOT NULL,
+  event_json      TEXT NOT NULL,
+  platform        TEXT NOT NULL,
+  target          TEXT NOT NULL,
+  status          TEXT NOT NULL,
+  not_before      INTEGER NOT NULL,
+  attempts        INTEGER NOT NULL DEFAULT 0,
+  last_error      TEXT,
+  created_at      INTEGER NOT NULL,
+  updated_at      INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_outbox_due ON outbox(status, not_before);
+CREATE INDEX IF NOT EXISTS idx_outbox_event ON outbox(event_id);
+
+CREATE TABLE IF NOT EXISTS deliveries (
+  key           TEXT NOT NULL,
+  subscriber_id TEXT NOT NULL,
+  at            INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_deliveries_key ON deliveries(key, at);
+CREATE INDEX IF NOT EXISTS idx_deliveries_subscriber ON deliveries(subscriber_id, at);
+
+CREATE TABLE IF NOT EXISTS pools (
+  pool          TEXT PRIMARY KEY,
+  token         TEXT NOT NULL,
+  quote_token   TEXT NOT NULL,
+  launchpad     TEXT NOT NULL,
+  created_block TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_pools_token ON pools(token);
+CREATE INDEX IF NOT EXISTS idx_pools_created ON pools(created_block);
+
+CREATE TABLE IF NOT EXISTS wallet_links (
+  subscriber_id TEXT PRIMARY KEY,
+  address       TEXT NOT NULL,
+  linked_at     INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS link_nonces (
+  subscriber_id TEXT PRIMARY KEY,
+  nonce         TEXT NOT NULL,
+  issued_at     INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+`;
+var AlertStore = class _AlertStore {
+  db;
+  clock;
+  constructor(path, clock = () => Date.now()) {
+    if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+    this.db = new DatabaseSync(path);
+    this.clock = clock;
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec(SCHEMA);
+  }
+  /** Deterministic outbox key. The whole dedupe guarantee rests on this. */
+  static deliveryKey(eventId, subscriptionId, ruleId) {
+    return `${eventId}|${subscriptionId}|${ruleId}`;
+  }
+  // ---- cursors -----------------------------------------------------------
+  /** The next unprocessed block for a source, or `null` when never persisted. */
+  getCursor(sourceId) {
+    const row = this.db.prepare("SELECT next_block FROM cursors WHERE source_id = ?").get(sourceId);
+    return row ? BigInt(row.next_block) : null;
+  }
+  /** Persist the next unprocessed block. Call only after the range is enqueued. */
+  setCursor(sourceId, nextBlock) {
+    this.db.prepare(
+      `INSERT INTO cursors (source_id, next_block, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(source_id) DO UPDATE SET next_block = excluded.next_block, updated_at = excluded.updated_at`
+    ).run(sourceId, nextBlock.toString(), this.clock());
+  }
+  /** Every persisted cursor, for `/metrics` and for operator inspection. */
+  listCursors() {
+    const rows = this.db.prepare("SELECT source_id, next_block FROM cursors ORDER BY source_id").all();
+    return rows.map((row) => ({ sourceId: row.source_id, nextBlock: BigInt(row.next_block) }));
+  }
+  // ---- subscriptions -----------------------------------------------------
+  /** Insert or replace a subscription. */
+  saveSubscription(subscription) {
+    const now = this.clock();
+    this.db.prepare(
+      `INSERT INTO subscriptions (id, subscriber_id, platform, target, enabled, rules, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           subscriber_id = excluded.subscriber_id,
+           platform = excluded.platform,
+           target = excluded.target,
+           enabled = excluded.enabled,
+           rules = excluded.rules,
+           updated_at = excluded.updated_at`
+    ).run(
+      subscription.id,
+      subscription.subscriberId,
+      subscription.platform,
+      subscription.target,
+      subscription.enabled ? 1 : 0,
+      encode(subscription.rules),
+      subscription.createdAtMs,
+      now
+    );
+  }
+  hydrate(row) {
+    return parseSubscription({
+      id: row.id,
+      subscriberId: row.subscriber_id,
+      platform: row.platform,
+      target: row.target,
+      enabled: row.enabled === 1,
+      rules: decode(row.rules),
+      createdAtMs: row.created_at
+    });
+  }
+  /** One subscription by id. */
+  getSubscription(id) {
+    const row = this.db.prepare("SELECT * FROM subscriptions WHERE id = ?").get(id);
+    return row ? this.hydrate(row) : null;
+  }
+  /** Every subscription owned by a subscriber. */
+  listSubscriptionsFor(subscriberId) {
+    const rows = this.db.prepare("SELECT * FROM subscriptions WHERE subscriber_id = ? ORDER BY created_at").all(subscriberId);
+    return rows.map((row) => this.hydrate(row));
+  }
+  /** Every enabled subscription, for the dispatch fan-out. */
+  listEnabledSubscriptions() {
+    const rows = this.db.prepare("SELECT * FROM subscriptions WHERE enabled = 1 ORDER BY created_at").all();
+    return rows.map((row) => this.hydrate(row));
+  }
+  /** Remove a subscription. Returns `true` when a row was deleted. */
+  deleteSubscription(id) {
+    const result = this.db.prepare("DELETE FROM subscriptions WHERE id = ?").run(id);
+    return Number(result.changes) > 0;
+  }
+  /** Every token on any enabled subscription's watchlist, deduped. */
+  watchlistTokens() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const subscription of this.listEnabledSubscriptions()) {
+      for (const rule of subscription.rules) {
+        for (const token of rule.tokens) seen.add(token.toLowerCase());
+      }
+    }
+    return [...seen].map((token) => getAddress(token));
+  }
+  // ---- outbox ------------------------------------------------------------
+  /**
+   * Queue a delivery.
+   *
+   * @returns `true` when this call created the row, `false` when it already
+   * existed (a replayed block range, a duplicate log). The boolean is the
+   * dedupe signal the dispatcher counts.
+   */
+  enqueue(row) {
+    const now = this.clock();
+    try {
+      this.db.prepare(
+        `INSERT INTO outbox (id, subscription_id, subscriber_id, rule_id, event_id, event_json,
+                               platform, target, status, not_before, attempts, last_error, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, NULL, ?, ?)`
+      ).run(
+        row.id,
+        row.subscriptionId,
+        row.subscriberId,
+        row.ruleId,
+        row.eventId,
+        row.eventJson,
+        row.platform,
+        row.target,
+        row.notBeforeMs,
+        now,
+        now
+      );
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (/UNIQUE|PRIMARY KEY/i.test(message)) return false;
+      throw error;
+    }
+  }
+  static toOutboxRow(raw) {
+    return {
+      id: raw.id,
+      subscriptionId: raw.subscription_id,
+      subscriberId: raw.subscriber_id,
+      ruleId: raw.rule_id,
+      eventId: raw.event_id,
+      eventJson: raw.event_json,
+      platform: raw.platform,
+      target: raw.target,
+      status: raw.status,
+      notBeforeMs: raw.not_before,
+      attempts: raw.attempts,
+      lastError: raw.last_error,
+      createdAtMs: raw.created_at,
+      updatedAtMs: raw.updated_at
+    };
+  }
+  /**
+   * Claim due deliveries, moving them to `sending` in one transaction so a
+   * second flush pass cannot pick up the same rows.
+   */
+  claimDue(nowMs, limit) {
+    const rows = this.db.prepare(
+      `SELECT * FROM outbox
+         WHERE status IN ('pending', 'failed') AND not_before <= ?
+         ORDER BY not_before, created_at
+         LIMIT ?`
+    ).all(nowMs, limit);
+    if (rows.length === 0) return [];
+    const update = this.db.prepare(`UPDATE outbox SET status = 'sending', updated_at = ? WHERE id = ?`);
+    this.db.exec("BEGIN");
+    try {
+      for (const row of rows) update.run(nowMs, row.id);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    return rows.map((row) => _AlertStore.toOutboxRow(row));
+  }
+  /** Mark a delivery sent. */
+  markSent(id) {
+    this.db.prepare(`UPDATE outbox SET status = 'sent', last_error = NULL, updated_at = ? WHERE id = ?`).run(this.clock(), id);
+  }
+  /** Record a retryable failure and schedule the next attempt. */
+  markFailed(id, attempts, error, nextAttemptAtMs) {
+    this.db.prepare(
+      `UPDATE outbox SET status = 'failed', attempts = ?, last_error = ?, not_before = ?, updated_at = ? WHERE id = ?`
+    ).run(attempts, error, nextAttemptAtMs, this.clock(), id);
+  }
+  /** Give up on a delivery (permanent rejection, or attempts exhausted). */
+  markDead(id, attempts, error) {
+    this.db.prepare(`UPDATE outbox SET status = 'dead', attempts = ?, last_error = ?, updated_at = ? WHERE id = ?`).run(attempts, error, this.clock(), id);
+  }
+  /**
+   * Return rows abandoned mid-flight by a crash to the queue.
+   *
+   * @returns how many rows were recovered.
+   */
+  recoverInFlight() {
+    const result = this.db.prepare(`UPDATE outbox SET status = 'pending', updated_at = ? WHERE status = 'sending'`).run(this.clock());
+    return Number(result.changes);
+  }
+  /** Delete delivered rows older than `beforeMs`, keeping the file bounded. */
+  pruneOutbox(beforeMs) {
+    const result = this.db.prepare(`DELETE FROM outbox WHERE status = 'sent' AND updated_at < ?`).run(beforeMs);
+    return Number(result.changes);
+  }
+  /** Delete delivery history older than `beforeMs`. */
+  pruneDeliveries(beforeMs) {
+    const result = this.db.prepare("DELETE FROM deliveries WHERE at < ?").run(beforeMs);
+    return Number(result.changes);
+  }
+  // ---- rate limiting and throughput --------------------------------------
+  /** A {@link RateLimitStore} backed by the `deliveries` table. */
+  rateLimitStore() {
+    return {
+      countSince: async (key, sinceMs) => {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE key = ? AND at >= ?").get(key, sinceMs);
+        return Number(row.n);
+      },
+      lastAt: async (key) => {
+        const row = this.db.prepare("SELECT MAX(at) AS last FROM deliveries WHERE key = ?").get(key);
+        return row.last ?? null;
+      },
+      record: async (key, subscriberId, atMs) => {
+        this.recordDelivery(key, subscriberId, atMs);
+      },
+      countForSubscriberSince: async (subscriberId, sinceMs) => {
+        return this.countDeliveriesForSubscriber(subscriberId, sinceMs);
+      }
+    };
+  }
+  /** Record a delivery for both rate limiting and throughput accounting. */
+  recordDelivery(key, subscriberId, atMs) {
+    this.db.prepare("INSERT INTO deliveries (key, subscriber_id, at) VALUES (?, ?, ?)").run(key, subscriberId, atMs);
+  }
+  /** How many alerts a subscriber received since `sinceMs`. */
+  countDeliveriesForSubscriber(subscriberId, sinceMs) {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE subscriber_id = ? AND at >= ?").get(subscriberId, sinceMs);
+    return Number(row.n);
+  }
+  // ---- pool registry -----------------------------------------------------
+  /** A {@link PoolRegistry} backed by the `pools` table. */
+  poolRegistry() {
+    return {
+      record: async (entry) => {
+        this.db.prepare(
+          `INSERT INTO pools (pool, token, quote_token, launchpad, created_block) VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(pool) DO UPDATE SET
+               token = excluded.token, quote_token = excluded.quote_token,
+               launchpad = excluded.launchpad, created_block = excluded.created_block`
+        ).run(
+          getAddress(entry.pool),
+          getAddress(entry.token),
+          getAddress(entry.quoteToken),
+          entry.launchpad,
+          entry.createdBlock.toString()
+        );
+      },
+      active: async (limit, pinned = []) => {
+        const picked = /* @__PURE__ */ new Map();
+        if (pinned.length > 0) {
+          const placeholders = pinned.map(() => "?").join(",");
+          const rows2 = this.db.prepare(`SELECT * FROM pools WHERE lower(token) IN (${placeholders})`).all(...pinned.map((token) => token.toLowerCase()));
+          for (const row of rows2) {
+            const entry = _AlertStore.toPoolEntry(row);
+            picked.set(entry.pool.toLowerCase(), entry);
+          }
+        }
+        const rows = this.db.prepare(
+          // created_block is stored as text to keep bigint precision, so it
+          // is ordered numerically by length first, then lexically.
+          "SELECT * FROM pools ORDER BY length(created_block) DESC, created_block DESC LIMIT ?"
+        ).all(limit);
+        for (const row of rows) {
+          if (picked.size >= limit + pinned.length) break;
+          const entry = _AlertStore.toPoolEntry(row);
+          if (!picked.has(entry.pool.toLowerCase())) picked.set(entry.pool.toLowerCase(), entry);
+        }
+        return [...picked.values()];
+      },
+      originOf: async (token) => {
+        const row = this.db.prepare("SELECT launchpad FROM pools WHERE lower(token) = ? LIMIT 1").get(token.toLowerCase());
+        return row ? row.launchpad : null;
+      },
+      poolsFor: async (token) => {
+        const rows = this.db.prepare("SELECT * FROM pools WHERE lower(token) = ?").all(token.toLowerCase());
+        return rows.map((row) => _AlertStore.toPoolEntry(row));
+      },
+      size: async () => {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM pools").get();
+        return Number(row.n);
+      }
+    };
+  }
+  static toPoolEntry(row) {
+    return {
+      pool: getAddress(row["pool"]),
+      token: getAddress(row["token"]),
+      quoteToken: getAddress(row["quote_token"]),
+      launchpad: row["launchpad"],
+      createdBlock: BigInt(row["created_block"])
+    };
+  }
+  // ---- wallet links ------------------------------------------------------
+  /** Store a signature-verified wallet link. */
+  linkWallet(subscriberId, address) {
+    this.db.prepare(
+      `INSERT INTO wallet_links (subscriber_id, address, linked_at) VALUES (?, ?, ?)
+         ON CONFLICT(subscriber_id) DO UPDATE SET address = excluded.address, linked_at = excluded.linked_at`
+    ).run(subscriberId, getAddress(address), this.clock());
+  }
+  /** A {@link WalletLinkStore} view of the links table. */
+  walletLinks() {
+    return {
+      walletOf: async (subscriberId) => {
+        const row = this.db.prepare("SELECT address FROM wallet_links WHERE subscriber_id = ?").get(subscriberId);
+        return row ? getAddress(row.address) : null;
+      }
+    };
+  }
+  /** Issue (or reissue) the nonce a subscriber must sign to link a wallet. */
+  issueLinkNonce(subscriberId, nonce) {
+    this.db.prepare(
+      `INSERT INTO link_nonces (subscriber_id, nonce, issued_at) VALUES (?, ?, ?)
+         ON CONFLICT(subscriber_id) DO UPDATE SET nonce = excluded.nonce, issued_at = excluded.issued_at`
+    ).run(subscriberId, nonce, this.clock());
+    return nonce;
+  }
+  /** The outstanding link nonce for a subscriber, or `null`. */
+  getLinkNonce(subscriberId) {
+    const row = this.db.prepare("SELECT nonce FROM link_nonces WHERE subscriber_id = ?").get(subscriberId);
+    return row?.nonce ?? null;
+  }
+  /** Consume a link nonce so a signature cannot be replayed. */
+  clearLinkNonce(subscriberId) {
+    this.db.prepare("DELETE FROM link_nonces WHERE subscriber_id = ?").run(subscriberId);
+  }
+  // ---- meta and metrics --------------------------------------------------
+  /** Read a free-form service setting. */
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  /** Write a free-form service setting. */
+  setMeta(key, value) {
+    this.db.prepare(
+      `INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+  /** Aggregate counters for `/metrics`. */
+  metrics() {
+    const outbox = { pending: 0, sending: 0, sent: 0, failed: 0, dead: 0 };
+    const statusRows = this.db.prepare("SELECT status, COUNT(*) AS n FROM outbox GROUP BY status").all();
+    for (const row of statusRows) outbox[row.status] = Number(row.n);
+    const subs = this.db.prepare("SELECT COUNT(*) AS total, SUM(enabled) AS enabled FROM subscriptions").get();
+    const pools = this.db.prepare("SELECT COUNT(*) AS n FROM pools").get();
+    const deliveries = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE at >= ?").get(this.clock() - 36e5);
+    return {
+      subscriptions: Number(subs.total),
+      enabledSubscriptions: Number(subs.enabled ?? 0),
+      outbox,
+      pools: Number(pools.n),
+      deliveriesLastHour: Number(deliveries.n),
+      cursors: this.listCursors()
+    };
+  }
+  /** Close the database. Safe to call twice. */
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+
+// src/service/dispatcher.ts
+function createDispatcher(options) {
+  const {
+    store,
+    sources,
+    gate,
+    rateLimits,
+    notifierFor,
+    getBlockNumber,
+    logger
+  } = options;
+  const confirmations = options.confirmations ?? 2n;
+  const chunkSize = options.chunkSize ?? 2000n;
+  const initialLookback = options.initialLookbackBlocks ?? 5000n;
+  const flushBatchSize = options.flushBatchSize ?? 50;
+  const maxAttempts = options.maxDeliveryAttempts ?? 6;
+  const retryBackoffMs = options.retryBackoffMs ?? 3e4;
+  const now = options.now ?? Date.now;
+  const evaluation = options.evaluation ?? {};
+  async function fanOut(event, subscriptions) {
+    let enqueued = 0;
+    let deduped = 0;
+    let suppressed = 0;
+    for (const subscription of subscriptions) {
+      const matches = await matchRules(subscription.rules, event, evaluation);
+      if (matches.length === 0) continue;
+      const { policy } = await gate.resolve(subscription.subscriberId);
+      for (const { rule } of matches) {
+        if (!policy.allowedKinds.includes(event.kind)) {
+          suppressed += 1;
+          continue;
+        }
+        const key = rateLimitKey(subscription.id, rule.id);
+        const limit = await checkRateLimit(rateLimits, key, rule.rateLimit, now());
+        if (!limit.allowed) {
+          suppressed += 1;
+          logger.debug("rate limited", { subscription: subscription.id, rule: rule.id, reason: limit.reason });
+          continue;
+        }
+        const usedThisHour = await rateLimits.countForSubscriberSince(
+          subscription.subscriberId,
+          now() - 36e5
+        );
+        const throughput = await gate.checkThroughput(subscription.subscriberId, usedThisHour);
+        if (!throughput.allowed) {
+          suppressed += 1;
+          logger.debug("throughput capped", {
+            subscriber: subscription.subscriberId,
+            reason: throughput.reason
+          });
+          continue;
+        }
+        const id = AlertStore.deliveryKey(event.id, subscription.id, rule.id);
+        const created = store.enqueue({
+          id,
+          subscriptionId: subscription.id,
+          subscriberId: subscription.subscriberId,
+          ruleId: rule.id,
+          eventId: event.id,
+          eventJson: encodeEvent(event),
+          platform: subscription.platform,
+          target: subscription.target,
+          notBeforeMs: now() + policy.deliveryDelayMs
+        });
+        if (!created) {
+          deduped += 1;
+          continue;
+        }
+        enqueued += 1;
+        await rateLimits.record(key, subscription.subscriberId, now());
+      }
+    }
+    return { enqueued, deduped, suppressed };
+  }
+  return {
+    recover() {
+      const recovered = store.recoverInFlight();
+      if (recovered > 0) logger.warn("recovered in-flight deliveries after restart", { recovered });
+      return recovered;
+    },
+    async pollOnce() {
+      const stats = {
+        ranges: [],
+        eventsDecoded: 0,
+        enqueued: 0,
+        deduped: 0,
+        suppressed: 0,
+        errors: []
+      };
+      const head = await getBlockNumber();
+      const safeHead = head > confirmations ? head - confirmations : 0n;
+      const subscriptions = store.listEnabledSubscriptions();
+      for (const source of sources) {
+        const persisted = store.getCursor(source.id);
+        const fallback = safeHead > initialLookback ? safeHead - initialLookback : source.startBlock;
+        const from = persisted ?? (fallback > source.startBlock ? fallback : source.startBlock);
+        if (from > safeHead) continue;
+        const to = from + chunkSize - 1n > safeHead ? safeHead : from + chunkSize - 1n;
+        try {
+          const events = await source.poll(from, to);
+          stats.eventsDecoded += events.length;
+          for (const event of events) {
+            const result = await fanOut(event, subscriptions);
+            stats.enqueued += result.enqueued;
+            stats.deduped += result.deduped;
+            stats.suppressed += result.suppressed;
+          }
+          store.setCursor(source.id, to + 1n);
+          stats.ranges.push({ sourceId: source.id, from, to });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          stats.errors.push({ sourceId: source.id, error: message });
+          logger.error("source poll failed, cursor not advanced", {
+            source: source.id,
+            from,
+            to,
+            error: message
+          });
+        }
+      }
+      return stats;
+    },
+    async flushOnce() {
+      const stats = { claimed: 0, sent: 0, retried: 0, dead: 0 };
+      const rows = store.claimDue(now(), flushBatchSize);
+      stats.claimed = rows.length;
+      for (const row of rows) {
+        const outcome = await deliver(row);
+        if (outcome === "sent") stats.sent += 1;
+        else if (outcome === "retry") stats.retried += 1;
+        else stats.dead += 1;
+      }
+      return stats;
+    }
+  };
+  async function deliver(row) {
+    const subscription = store.getSubscription(row.subscriptionId);
+    if (!subscription) {
+      store.markDead(row.id, row.attempts + 1, "subscription no longer exists");
+      return "dead";
+    }
+    const notifier = notifierFor(subscription);
+    if (!notifier) {
+      store.markDead(row.id, row.attempts + 1, `no notifier configured for platform ${row.platform}`);
+      return "dead";
+    }
+    let event;
+    try {
+      event = decodeEvent(row.eventJson);
+    } catch (error) {
+      store.markDead(row.id, row.attempts + 1, `corrupt event payload: ${String(error)}`);
+      return "dead";
+    }
+    const alert = renderAlert(event, {
+      ...options.render,
+      footer: options.render?.footer ?? `rule: ${row.ruleId}`
+    });
+    const result = await notifier.send(row.target, alert);
+    const attempts = row.attempts + 1;
+    if (result.ok) {
+      store.markSent(row.id);
+      logger.info("alert delivered", {
+        id: row.id,
+        platform: notifier.platform,
+        kind: event.kind,
+        token: event.token,
+        attempts: result.attempts
+      });
+      return "sent";
+    }
+    if (!result.retryable || attempts >= maxAttempts) {
+      store.markDead(row.id, attempts, result.error ?? "delivery failed");
+      logger.error("alert dead-lettered", {
+        id: row.id,
+        platform: notifier.platform,
+        attempts,
+        retryable: result.retryable,
+        error: result.error
+      });
+      return "dead";
+    }
+    const nextAttemptAt = now() + retryBackoffMs * 2 ** (attempts - 1);
+    store.markFailed(row.id, attempts, result.error ?? "delivery failed", nextAttemptAt);
+    logger.warn("alert delivery failed, will retry", {
+      id: row.id,
+      attempts,
+      nextAttemptAt,
+      error: result.error
+    });
+    return "retry";
+  }
+}
+
+// src/service/http.ts
+import { createServer } from "http";
+function json(res, status, body) {
+  const payload = JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  res.end(payload);
+}
+async function readBody(req, limitBytes) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    size += buffer.length;
+    if (size > limitBytes) return null;
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function renderMetrics(store, health, nowMs) {
+  const metrics = store.metrics();
+  const lines = [
+    "# HELP hood_alerts_subscriptions Subscriptions by state.",
+    "# TYPE hood_alerts_subscriptions gauge",
+    `hood_alerts_subscriptions{state="total"} ${metrics.subscriptions}`,
+    `hood_alerts_subscriptions{state="enabled"} ${metrics.enabledSubscriptions}`,
+    "# HELP hood_alerts_outbox Deliveries by outbox status.",
+    "# TYPE hood_alerts_outbox gauge"
+  ];
+  for (const [status, count] of Object.entries(metrics.outbox)) {
+    lines.push(`hood_alerts_outbox{status="${status}"} ${count}`);
+  }
+  lines.push(
+    "# HELP hood_alerts_deliveries_last_hour Alerts delivered in the last rolling hour.",
+    "# TYPE hood_alerts_deliveries_last_hour gauge",
+    `hood_alerts_deliveries_last_hour ${metrics.deliveriesLastHour}`,
+    "# HELP hood_alerts_pools Memecoin pools tracked for whale trades.",
+    "# TYPE hood_alerts_pools gauge",
+    `hood_alerts_pools ${metrics.pools}`,
+    "# HELP hood_alerts_cursor_block Next unprocessed block per source.",
+    "# TYPE hood_alerts_cursor_block gauge"
+  );
+  for (const cursor of metrics.cursors) {
+    lines.push(`hood_alerts_cursor_block{source="${cursor.sourceId}"} ${cursor.nextBlock}`);
+  }
+  lines.push(
+    "# HELP hood_alerts_head_block Chain head block last observed.",
+    "# TYPE hood_alerts_head_block gauge",
+    `hood_alerts_head_block ${health.headBlock ?? 0}`,
+    "# HELP hood_alerts_lag_blocks How far each source trails the chain head.",
+    "# TYPE hood_alerts_lag_blocks gauge"
+  );
+  if (health.headBlock !== null) {
+    for (const cursor of metrics.cursors) {
+      const lag = health.headBlock > cursor.nextBlock ? health.headBlock - cursor.nextBlock : 0n;
+      lines.push(`hood_alerts_lag_blocks{source="${cursor.sourceId}"} ${lag}`);
+    }
+  }
+  lines.push(
+    "# HELP hood_alerts_last_poll_age_seconds Seconds since the last successful poll.",
+    "# TYPE hood_alerts_last_poll_age_seconds gauge",
+    `hood_alerts_last_poll_age_seconds ${health.lastPollAtMs === null ? -1 : Math.round((nowMs - health.lastPollAtMs) / 1e3)}`,
+    "# HELP hood_alerts_uptime_seconds Process uptime.",
+    "# TYPE hood_alerts_uptime_seconds counter",
+    `hood_alerts_uptime_seconds ${Math.round((nowMs - health.startedAtMs) / 1e3)}`,
+    ""
+  );
+  return lines.join("\n");
+}
+function createHttpServer(options) {
+  const now = options.now ?? Date.now;
+  const stalenessMs = options.readinessStalenessMs ?? 12e4;
+  return createServer((req, res) => {
+    void (async () => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const path = url.pathname;
+      try {
+        if (req.method === "GET" && (path === "/health" || path === "/healthz")) {
+          const health = options.health();
+          json(res, 200, {
+            ok: true,
+            version: health.version,
+            uptimeSeconds: Math.round((now() - health.startedAtMs) / 1e3),
+            headBlock: health.headBlock,
+            lastPollAtMs: health.lastPollAtMs,
+            lastError: health.lastError,
+            platforms: health.platforms
+          });
+          return;
+        }
+        if (req.method === "GET" && path === "/ready") {
+          const health = options.health();
+          const fresh = health.lastPollAtMs !== null && now() - health.lastPollAtMs <= stalenessMs;
+          json(res, fresh ? 200 : 503, {
+            ready: fresh,
+            lastPollAtMs: health.lastPollAtMs,
+            lastError: health.lastError
+          });
+          return;
+        }
+        if (req.method === "GET" && path === "/metrics") {
+          const body = renderMetrics(options.store, options.health(), now());
+          res.writeHead(200, { "content-type": "text/plain; version=0.0.4; charset=utf-8" });
+          res.end(body);
+          return;
+        }
+        if (options.discord && req.method === "POST" && path === options.discord.path) {
+          const rawBody = await readBody(req, 256 * 1024);
+          if (rawBody === null) {
+            json(res, 413, { error: "request body too large" });
+            return;
+          }
+          const answer = await options.discord.handle({
+            signature: req.headers["x-signature-ed25519"] ?? null,
+            timestamp: req.headers["x-signature-timestamp"] ?? null,
+            rawBody
+          });
+          json(res, answer.status, answer.body);
+          return;
+        }
+        json(res, 404, { error: `no route for ${req.method ?? "GET"} ${path}` });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options.logger.error("http handler failed", { path, error: message });
+        if (!res.headersSent) json(res, 500, { error: "internal error" });
+        else res.end();
+      }
+    })();
+  });
+}
+
+// src/service/runner.ts
+import { createHoodClient } from "hoodchain";
+var VERSION = "0.1.0";
+function buildEntitlements(config, client, store) {
+  const staticProvider = createStaticEntitlementProvider({
+    premiumSubscribers: config.premiumSubscribers,
+    allPremium: config.allPremium
+  });
+  if (config.entitlements === "static") return staticProvider;
+  const usdgProvider = createUsdgEntitlementProvider({
+    client,
+    receiver: config.usdgReceiver,
+    pricePerPeriodUsdg: config.premiumPriceUsdg,
+    periodDays: config.premiumPeriodDays,
+    links: store.walletLinks(),
+    fromBlock: config.paymentsFromBlock
+  });
+  if (config.entitlements === "usdg") return usdgProvider;
+  return chainEntitlementProviders(staticProvider, usdgProvider);
+}
+function createService(options) {
+  const config = options.config;
+  const logger = options.logger ?? createLogger({ level: config.logLevel, base: { service: "hood-alerts" } });
+  const client = options.client ?? createHoodClient({
+    chain: config.network,
+    ...config.rpcUrl ? { rpcUrl: config.rpcUrl } : {}
+  });
+  const store = options.store ?? new AlertStore(config.dbPath);
+  const oracle = createPriceOracle(client);
+  const tokens = createTokenMetaReader(client);
+  const registry = store.poolRegistry();
+  const liquidity = createLiquidityReader(client, oracle, registry);
+  const reputation = createRpcReputationProvider(client, oracle);
+  const sources = createEventSources({
+    client,
+    oracle,
+    tokens,
+    registry,
+    pinnedTokens: async () => store.watchlistTokens(),
+    whaleMinUsd: config.whaleMinUsd,
+    whalePoolLimit: config.whalePoolLimit
+  });
+  const entitlements = buildEntitlements(config, client, store);
+  const gate = createEntitlementGate({ provider: entitlements });
+  const platforms = [];
+  let telegramNotifier = null;
+  let discordWebhookNotifier = null;
+  let discordBotNotifier = null;
+  const telegramClient = config.telegramBotToken ? createTelegramClient({ botToken: config.telegramBotToken }) : null;
+  if (config.dryRun) {
+    telegramNotifier = createCaptureNotifier(
+      "telegram",
+      (delivery) => logger.info("dry run: telegram alert", { target: delivery.target, text: delivery.alert.plain })
+    );
+    discordWebhookNotifier = createCaptureNotifier(
+      "discord",
+      (delivery) => logger.info("dry run: discord alert", { target: delivery.target, text: delivery.alert.plain })
+    );
+    discordBotNotifier = discordWebhookNotifier;
+    platforms.push("dry-run");
+  } else {
+    if (telegramClient) {
+      telegramNotifier = createTelegramNotifier({
+        botToken: config.telegramBotToken,
+        client: telegramClient
+      });
+      platforms.push("telegram");
+    }
+    discordWebhookNotifier = createDiscordWebhookNotifier({});
+    platforms.push("discord-webhook");
+    if (config.discordBotToken) {
+      discordBotNotifier = createDiscordBotNotifier({ botToken: config.discordBotToken });
+      platforms.push("discord-bot");
+    }
+  }
+  function notifierFor(subscription) {
+    if (subscription.platform === "telegram") return telegramNotifier;
+    if (subscription.target.startsWith("https://")) return discordWebhookNotifier;
+    return discordBotNotifier;
+  }
+  const dispatcher = createDispatcher({
+    store,
+    sources,
+    gate,
+    rateLimits: store.rateLimitStore(),
+    notifierFor,
+    getBlockNumber: () => client.public.getBlockNumber(),
+    logger,
+    evaluation: {
+      liquidityUsd: (event) => liquidity.tokenLiquidityUsd(event.token),
+      reputation: (deployer) => reputation.get(deployer),
+      isLpLocked: (positionId) => reputation.isLpLocked(positionId)
+    },
+    confirmations: config.confirmations,
+    chunkSize: config.chunkSize,
+    initialLookbackBlocks: config.initialLookbackBlocks,
+    flushBatchSize: config.flushBatchSize,
+    maxDeliveryAttempts: config.maxDeliveryAttempts,
+    retryBackoffMs: config.retryBackoffMs
+  });
+  const router = createCommandRouter({
+    store,
+    gate,
+    ...config.upgradeInstructions ? { upgradeInstructions: config.upgradeInstructions } : {}
+  });
+  let telegramBot = null;
+  if (telegramClient && !config.dryRun) {
+    telegramBot = createTelegramBot({
+      botToken: config.telegramBotToken,
+      client: telegramClient,
+      router,
+      logger: logger.child({ component: "telegram-bot" }),
+      offsetStore: {
+        get: () => {
+          const raw = store.getMeta("telegram:offset");
+          return raw === null ? null : Number(raw);
+        },
+        set: (offset) => store.setMeta("telegram:offset", String(offset))
+      }
+    });
+  }
+  const discordHandler = config.discordPublicKey ? createDiscordInteractionHandler({ router, publicKey: config.discordPublicKey }) : null;
+  const startedAtMs = Date.now();
+  let headBlock = null;
+  let lastPollAtMs = null;
+  let lastError = null;
+  const health = () => ({
+    headBlock,
+    lastPollAtMs,
+    lastError,
+    platforms,
+    version: VERSION,
+    startedAtMs
+  });
+  const server = createHttpServer({
+    store,
+    logger: logger.child({ component: "http" }),
+    health,
+    ...discordHandler ? { discord: { path: config.discordInteractionsPath, handle: discordHandler.handle } } : {}
+  });
+  let running = false;
+  const loops = [];
+  let stopping = null;
+  const waiters = /* @__PURE__ */ new Set();
+  function delay(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        waiters.delete(wake);
+        resolve();
+      }, ms);
+      const wake = () => {
+        clearTimeout(timer);
+        waiters.delete(wake);
+        resolve();
+      };
+      waiters.add(wake);
+    });
+  }
+  async function pollLoop() {
+    while (running) {
+      try {
+        headBlock = await client.public.getBlockNumber();
+        const stats = await dispatcher.pollOnce();
+        lastPollAtMs = Date.now();
+        lastError = stats.errors.length > 0 ? stats.errors[0]?.error ?? null : null;
+        if (stats.eventsDecoded > 0 || stats.enqueued > 0) {
+          logger.info("poll complete", {
+            head: headBlock,
+            events: stats.eventsDecoded,
+            enqueued: stats.enqueued,
+            deduped: stats.deduped,
+            suppressed: stats.suppressed,
+            errors: stats.errors.length
+          });
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+        logger.error("poll loop error", { error: lastError });
+      }
+      await delay(config.pollIntervalMs);
+    }
+  }
+  async function flushLoop() {
+    while (running) {
+      try {
+        const stats = await dispatcher.flushOnce();
+        if (stats.claimed > 0) logger.debug("flush complete", { ...stats });
+      } catch (error) {
+        logger.error("flush loop error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      await delay(config.flushIntervalMs);
+    }
+  }
+  async function pruneLoop() {
+    while (running) {
+      await delay(36e5);
+      if (!running) break;
+      try {
+        const cutoff = Date.now() - config.outboxRetentionHours * 36e5;
+        const outbox = store.pruneOutbox(cutoff);
+        const deliveries = store.pruneDeliveries(Date.now() - 25 * 36e5);
+        if (outbox > 0 || deliveries > 0) logger.info("pruned", { outbox, deliveries });
+      } catch (error) {
+        logger.error("prune failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return {
+    config,
+    store,
+    dispatcher,
+    logger,
+    health,
+    async start() {
+      if (running) return;
+      running = true;
+      dispatcher.recover();
+      await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(config.port, () => {
+          server.removeListener("error", onError);
+          resolve();
+        });
+      });
+      logger.info("service started", {
+        port: config.port,
+        network: config.network,
+        dryRun: config.dryRun,
+        platforms,
+        entitlements: config.entitlements,
+        sources: sources.map((source) => source.id)
+      });
+      loops.push(pollLoop(), flushLoop(), pruneLoop());
+      if (telegramBot) {
+        await telegramBot.publishCommands();
+        loops.push(telegramBot.start());
+      }
+    },
+    async stop() {
+      stopping ??= (async () => {
+        logger.info("service stopping");
+        running = false;
+        telegramBot?.stop();
+        for (const wake of [...waiters]) wake();
+        await new Promise((resolve) => {
+          server.close(() => resolve());
+          server.closeAllConnections?.();
+        });
+        await Promise.allSettled(loops);
+        store.close();
+        logger.info("service stopped");
+      })();
+      return stopping;
+    }
+  };
+}
+
+export {
+  loadConfig,
+  encode,
+  decode,
+  encodeEvent,
+  decodeEvent,
+  AlertStore,
+  createDispatcher,
+  renderMetrics,
+  createHttpServer,
+  VERSION,
+  createService
+};
+//# sourceMappingURL=chunk-Z4DJPESQ.js.map