@secondlayer/shared 11.10.1 → 11.11.1

package/dist/src/queue/listener.js

@@ -1,10 +1,969 @@
 // src/queue/listener.ts
+import postgres2 from "postgres";
+
+// src/db/index.ts
+import { Kysely } from "kysely";
+import { PostgresJSDialect } from "kysely-postgres-js";
 import postgres from "postgres";
+
+// src/env.ts
+import { z } from "zod";
+var networksSchema = z.string().transform((val) => {
+  const networks = val.split(",").map((n) => n.trim()).filter(Boolean);
+  const valid = ["mainnet", "testnet"];
+  for (const n of networks) {
+    if (!valid.includes(n)) {
+      throw new Error(`Invalid network: ${n}. Must be one of: ${valid.join(", ")}`);
+    }
+  }
+  return networks;
+});
+var envSchema = z.object({
+  DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
+  SOURCE_DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
+  TARGET_DATABASE_URL: z.preprocess((val) => typeof val === "string" && val.length === 0 ? undefined : val, z.string().url().optional()),
+  NETWORK: z.enum(["mainnet", "testnet"]).optional(),
+  NETWORKS: networksSchema.optional(),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development")
+});
+var cachedEnv = null;
+function getEnv() {
+  if (cachedEnv) {
+    return cachedEnv;
+  }
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    console.error("❌ Invalid environment configuration:");
+    console.error(z.treeifyError(result.error));
+    throw new Error("Invalid environment configuration");
+  }
+  let enabledNetworks;
+  if (result.data.NETWORKS && result.data.NETWORKS.length > 0) {
+    enabledNetworks = result.data.NETWORKS;
+  } else if (result.data.NETWORK) {
+    enabledNetworks = [result.data.NETWORK];
+  } else {
+    enabledNetworks = ["mainnet"];
+  }
+  cachedEnv = { ...result.data, enabledNetworks };
+  return cachedEnv;
+}
+function isProductionEnv() {
+  return process.env["NODE_ENV"] === "production";
+}
+function isPox4DecoderEnabled(env = process.env) {
+  return env.POX4_DECODER_ENABLED !== "false";
+}
+function isPox5DecoderEnabled(env = process.env) {
+  return env.POX5_DECODER_ENABLED !== "false";
+}
+function isSbtcDecoderEnabled(env = process.env) {
+  return env.SBTC_DECODER_ENABLED !== "false";
+}
+function isBnsDecoderEnabled(env = process.env) {
+  return env.BNS_DECODER_ENABLED === "true";
+}
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+class Logger {
+  _level;
+  _isProduction;
+  _initialized = false;
+  init() {
+    if (this._initialized)
+      return;
+    this._initialized = true;
+    try {
+      const env = getEnv();
+      this._level = env.LOG_LEVEL;
+      this._isProduction = env.NODE_ENV === "production";
+    } catch {
+      this._level = "info";
+      this._isProduction = false;
+    }
+  }
+  get level() {
+    this.init();
+    return this._level;
+  }
+  get isProduction() {
+    this.init();
+    return this._isProduction;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  formatMessage(level, message, meta) {
+    const timestamp = new Date().toISOString();
+    if (this.isProduction) {
+      return JSON.stringify({
+        timestamp,
+        level,
+        message,
+        ...meta
+      });
+    }
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.formatMessage("debug", message, meta));
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      console.info(this.formatMessage("info", message, meta));
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.formatMessage("warn", message, meta));
+    }
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message, meta));
+    }
+  }
+}
+var logger = new Logger;
+
+// src/mode.ts
+var VALID_MODES = [
+  "oss",
+  "platform",
+  "archive"
+];
+function declaredMode() {
+  const raw = process.env.INSTANCE_MODE?.trim().toLowerCase();
+  if (raw && VALID_MODES.includes(raw)) {
+    return raw;
+  }
+  return "oss";
+}
+function getInstanceMode() {
+  const declared = declaredMode();
+  return declared === "archive" ? "platform" : declared;
+}
+function getDeclaredInstanceMode() {
+  return declaredMode();
+}
+function isMeteredReads() {
+  const override = process.env.METERED_READS?.trim().toLowerCase();
+  if (override === "true")
+    return true;
+  if (override === "false")
+    return false;
+  return getInstanceMode() === "platform";
+}
+function isPlatformMode() {
+  return getInstanceMode() === "platform";
+}
+function isOssMode() {
+  return getInstanceMode() === "oss";
+}
+
+// src/db/index.ts
+import { sql as sql2 } from "kysely";
+
+// src/db/source-read-columns.ts
+var SOURCE_READ_COLUMNS = {
+  blocks: [
+    "burn_block_hash",
+    "burn_block_height",
+    "canonical",
+    "hash",
+    "height",
+    "parent_hash",
+    "timestamp"
+  ],
+  decoded_events: [
+    "amount",
+    "asset_identifier",
+    "block_height",
+    "canonical",
+    "contract_id",
+    "cursor",
+    "event_index",
+    "event_type",
+    "memo",
+    "payload",
+    "recipient",
+    "sender",
+    "tx_id",
+    "tx_index",
+    "value"
+  ],
+  transactions: [
+    "block_height",
+    "contract_id",
+    "function_args",
+    "function_name",
+    "raw_result",
+    "raw_tx",
+    "sender",
+    "status",
+    "tx_id",
+    "tx_index",
+    "type"
+  ],
+  mempool_transactions: [
+    "contract_id",
+    "function_args",
+    "function_name",
+    "raw_tx",
+    "received_at",
+    "sender",
+    "seq",
+    "tx_id",
+    "type"
+  ],
+  pox4_calls: [
+    "aggregated_amount_ustx",
+    "aggregated_signer_index",
+    "amount_ustx",
+    "auth_allowed",
+    "auth_id",
+    "auth_period",
+    "auth_topic",
+    "block_height",
+    "block_time",
+    "burn_block_height",
+    "caller",
+    "canonical",
+    "cursor",
+    "delegate_to",
+    "end_cycle",
+    "function_name",
+    "lock_period",
+    "max_amount",
+    "pox_addr_btc",
+    "pox_addr_hashbytes",
+    "pox_addr_version",
+    "result_ok",
+    "reward_cycle",
+    "signer_key",
+    "signer_signature",
+    "source_cursor",
+    "stacker",
+    "start_cycle",
+    "tx_id",
+    "tx_index"
+  ],
+  pox5_events: [
+    "amount_sats",
+    "amount_ustx",
+    "block_height",
+    "block_time",
+    "bond_index",
+    "canonical",
+    "cursor",
+    "data",
+    "event_index",
+    "first_reward_cycle",
+    "is_l1_lock",
+    "reward_cycle",
+    "signer",
+    "signer_key",
+    "signer_manager",
+    "staker",
+    "topic",
+    "tx_id",
+    "tx_index",
+    "unlock_burn_height",
+    "unlock_cycle"
+  ],
+  sbtc_events: [
+    "amount",
+    "bitcoin_txid",
+    "block_height",
+    "block_time",
+    "burn_hash",
+    "burn_height",
+    "canonical",
+    "cursor",
+    "event_index",
+    "fee",
+    "governance_contract_type",
+    "governance_new_contract",
+    "max_fee",
+    "output_index",
+    "recipient_btc_hashbytes",
+    "recipient_btc_version",
+    "request_id",
+    "sender",
+    "signer_address",
+    "signer_aggregate_pubkey",
+    "signer_bitmap",
+    "signer_keys_count",
+    "signer_threshold",
+    "sweep_txid",
+    "topic",
+    "tx_id",
+    "tx_index"
+  ],
+  sbtc_token_events: [
+    "amount",
+    "block_height",
+    "block_time",
+    "canonical",
+    "cursor",
+    "event_index",
+    "event_type",
+    "memo",
+    "recipient",
+    "sender",
+    "tx_id",
+    "tx_index"
+  ],
+  bns_name_events: [
+    "block_height",
+    "block_time",
+    "bns_id",
+    "canonical",
+    "cursor",
+    "event_index",
+    "fqn",
+    "hashed_salted_fqn_preorder",
+    "imported_at",
+    "name",
+    "namespace",
+    "owner",
+    "preordered_by",
+    "registered_at",
+    "renewal_height",
+    "stx_burn",
+    "topic",
+    "tx_id",
+    "tx_index"
+  ],
+  bns_namespace_events: [
+    "block_height",
+    "block_time",
+    "canonical",
+    "cursor",
+    "event_index",
+    "launched_at",
+    "lifetime",
+    "manager",
+    "manager_frozen",
+    "manager_transfers_disabled",
+    "namespace",
+    "price_frozen",
+    "price_function",
+    "revealed_at",
+    "status",
+    "tx_id",
+    "tx_index"
+  ],
+  bns_marketplace_events: [
+    "action",
+    "block_height",
+    "block_time",
+    "bns_id",
+    "canonical",
+    "commission",
+    "cursor",
+    "event_index",
+    "price_ustx",
+    "tx_id",
+    "tx_index"
+  ],
+  bns_names: [
+    "bns_id",
+    "fqn",
+    "last_event_at",
+    "last_event_cursor",
+    "name",
+    "namespace",
+    "owner",
+    "registered_at",
+    "renewal_height"
+  ],
+  bns_namespaces: [
+    "last_event_at",
+    "last_event_cursor",
+    "launched_at",
+    "lifetime",
+    "manager",
+    "manager_frozen",
+    "name_count",
+    "namespace",
+    "price_frozen"
+  ],
+  burn_block_rewards: [
+    "amount_sats",
+    "burn_amount",
+    "burn_block_hash",
+    "burn_block_height",
+    "cursor",
+    "recipient_btc",
+    "reward_index"
+  ],
+  burn_block_reward_slots: [
+    "burn_block_hash",
+    "burn_block_height",
+    "cursor",
+    "holder_btc",
+    "slot_index"
+  ],
+  events: ["block_height", "data", "event_index", "tx_id", "type"],
+  chain_reorgs: ["detected_at"]
+};
+var SOURCE_READ_TYPES = {
+  blocks: {
+    burn_block_hash: { type: "text", nullable: true },
+    burn_block_height: { type: "int" },
+    canonical: { type: "boolean" },
+    hash: { type: "text" },
+    height: { type: "int" },
+    parent_hash: { type: "text" },
+    timestamp: { type: "int" }
+  },
+  decoded_events: {
+    amount: { type: "text", nullable: true },
+    asset_identifier: { type: "text", nullable: true },
+    block_height: { type: "int" },
+    canonical: { type: "boolean" },
+    contract_id: { type: "text", nullable: true },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    event_type: { type: "text" },
+    memo: { type: "text", nullable: true },
+    payload: { type: "jsonb", nullable: true },
+    recipient: { type: "text", nullable: true },
+    sender: { type: "text", nullable: true },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" },
+    value: { type: "text", nullable: true }
+  },
+  transactions: {
+    block_height: { type: "int" },
+    contract_id: { type: "text", nullable: true },
+    function_args: { type: "jsonb", nullable: true },
+    function_name: { type: "text", nullable: true },
+    raw_result: { type: "text", nullable: true },
+    raw_tx: { type: "text" },
+    sender: { type: "text" },
+    status: { type: "text" },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" },
+    type: { type: "text" }
+  },
+  mempool_transactions: {
+    contract_id: { type: "text", nullable: true },
+    function_args: { type: "jsonb", nullable: true },
+    function_name: { type: "text", nullable: true },
+    raw_tx: { type: "text" },
+    received_at: { type: "timestamp" },
+    sender: { type: "text" },
+    seq: { type: "text" },
+    tx_id: { type: "text" },
+    type: { type: "text" }
+  },
+  pox4_calls: {
+    aggregated_amount_ustx: { type: "text", nullable: true },
+    aggregated_signer_index: { type: "int", nullable: true },
+    amount_ustx: { type: "text", nullable: true },
+    auth_allowed: { type: "boolean", nullable: true },
+    auth_id: { type: "text", nullable: true },
+    auth_period: { type: "int", nullable: true },
+    auth_topic: { type: "text", nullable: true },
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    burn_block_height: { type: "int" },
+    caller: { type: "text" },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    delegate_to: { type: "text", nullable: true },
+    end_cycle: { type: "int", nullable: true },
+    function_name: { type: "text" },
+    lock_period: { type: "int", nullable: true },
+    max_amount: { type: "text", nullable: true },
+    pox_addr_btc: { type: "text", nullable: true },
+    pox_addr_hashbytes: { type: "text", nullable: true },
+    pox_addr_version: { type: "int", nullable: true },
+    result_ok: { type: "boolean" },
+    reward_cycle: { type: "int", nullable: true },
+    signer_key: { type: "text", nullable: true },
+    signer_signature: { type: "text", nullable: true },
+    source_cursor: { type: "text" },
+    stacker: { type: "text", nullable: true },
+    start_cycle: { type: "int", nullable: true },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  pox5_events: {
+    amount_sats: { type: "text", nullable: true },
+    amount_ustx: { type: "text", nullable: true },
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    bond_index: { type: "int", nullable: true },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    data: { type: "jsonb", nullable: true },
+    event_index: { type: "int" },
+    first_reward_cycle: { type: "int", nullable: true },
+    is_l1_lock: { type: "boolean", nullable: true },
+    reward_cycle: { type: "int", nullable: true },
+    signer: { type: "text", nullable: true },
+    signer_key: { type: "text", nullable: true },
+    signer_manager: { type: "text", nullable: true },
+    staker: { type: "text", nullable: true },
+    topic: { type: "text" },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" },
+    unlock_burn_height: { type: "int", nullable: true },
+    unlock_cycle: { type: "int", nullable: true }
+  },
+  sbtc_events: {
+    amount: { type: "text", nullable: true },
+    bitcoin_txid: { type: "text", nullable: true },
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    burn_hash: { type: "text", nullable: true },
+    burn_height: { type: "int", nullable: true },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    fee: { type: "text", nullable: true },
+    governance_contract_type: { type: "int", nullable: true },
+    governance_new_contract: { type: "text", nullable: true },
+    max_fee: { type: "text", nullable: true },
+    output_index: { type: "int", nullable: true },
+    recipient_btc_hashbytes: { type: "text", nullable: true },
+    recipient_btc_version: { type: "int", nullable: true },
+    request_id: { type: "int", nullable: true },
+    sender: { type: "text", nullable: true },
+    signer_address: { type: "text", nullable: true },
+    signer_aggregate_pubkey: { type: "text", nullable: true },
+    signer_bitmap: { type: "text", nullable: true },
+    signer_keys_count: { type: "int", nullable: true },
+    signer_threshold: { type: "int", nullable: true },
+    sweep_txid: { type: "text", nullable: true },
+    topic: { type: "text" },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  sbtc_token_events: {
+    amount: { type: "text" },
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    event_type: { type: "text" },
+    memo: { type: "text", nullable: true },
+    recipient: { type: "text", nullable: true },
+    sender: { type: "text", nullable: true },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  bns_name_events: {
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    bns_id: { type: "text" },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    fqn: { type: "text" },
+    hashed_salted_fqn_preorder: { type: "text", nullable: true },
+    imported_at: { type: "int", nullable: true },
+    name: { type: "text" },
+    namespace: { type: "text" },
+    owner: { type: "text", nullable: true },
+    preordered_by: { type: "text", nullable: true },
+    registered_at: { type: "int", nullable: true },
+    renewal_height: { type: "int", nullable: true },
+    stx_burn: { type: "text", nullable: true },
+    topic: { type: "text" },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  bns_namespace_events: {
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    canonical: { type: "boolean" },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    launched_at: { type: "int", nullable: true },
+    lifetime: { type: "int", nullable: true },
+    manager: { type: "text", nullable: true },
+    manager_frozen: { type: "boolean", nullable: true },
+    manager_transfers_disabled: { type: "boolean", nullable: true },
+    namespace: { type: "text" },
+    price_frozen: { type: "boolean", nullable: true },
+    price_function: { type: "text", nullable: true },
+    revealed_at: { type: "int", nullable: true },
+    status: { type: "text" },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  bns_marketplace_events: {
+    action: { type: "text" },
+    block_height: { type: "int" },
+    block_time: { type: "timestamp" },
+    bns_id: { type: "text" },
+    canonical: { type: "boolean" },
+    commission: { type: "text", nullable: true },
+    cursor: { type: "text" },
+    event_index: { type: "int" },
+    price_ustx: { type: "text", nullable: true },
+    tx_id: { type: "text" },
+    tx_index: { type: "int" }
+  },
+  bns_names: {
+    bns_id: { type: "text" },
+    fqn: { type: "text" },
+    last_event_at: { type: "timestamp" },
+    last_event_cursor: { type: "text" },
+    name: { type: "text" },
+    namespace: { type: "text" },
+    owner: { type: "text" },
+    registered_at: { type: "int", nullable: true },
+    renewal_height: { type: "int", nullable: true }
+  },
+  bns_namespaces: {
+    last_event_at: { type: "timestamp" },
+    last_event_cursor: { type: "text" },
+    launched_at: { type: "int", nullable: true },
+    lifetime: { type: "int", nullable: true },
+    manager: { type: "text", nullable: true },
+    manager_frozen: { type: "boolean" },
+    name_count: { type: "int" },
+    namespace: { type: "text" },
+    price_frozen: { type: "boolean" }
+  },
+  burn_block_rewards: {
+    amount_sats: { type: "text" },
+    burn_amount: { type: "text" },
+    burn_block_hash: { type: "text" },
+    burn_block_height: { type: "int" },
+    cursor: { type: "text" },
+    recipient_btc: { type: "text" },
+    reward_index: { type: "int" }
+  },
+  burn_block_reward_slots: {
+    burn_block_hash: { type: "text" },
+    burn_block_height: { type: "int" },
+    cursor: { type: "text" },
+    holder_btc: { type: "text" },
+    slot_index: { type: "int" }
+  },
+  events: {
+    block_height: { type: "int" },
+    data: { type: "jsonb" },
+    event_index: { type: "int" },
+    tx_id: { type: "text" },
+    type: { type: "text" }
+  },
+  chain_reorgs: {
+    detected_at: { type: "timestamp" }
+  }
+};
+var SOURCE_READ_PKS = {
+  blocks: ["height"],
+  decoded_events: ["cursor"],
+  transactions: ["tx_id"],
+  mempool_transactions: ["seq"],
+  pox4_calls: ["cursor"],
+  pox5_events: ["cursor"],
+  sbtc_events: ["cursor"],
+  sbtc_token_events: ["cursor"],
+  bns_name_events: ["cursor"],
+  bns_namespace_events: ["cursor"],
+  bns_marketplace_events: ["cursor"],
+  bns_names: ["fqn"],
+  bns_namespaces: ["namespace"],
+  burn_block_rewards: ["cursor"],
+  burn_block_reward_slots: ["cursor"],
+  events: ["tx_id", "event_index"],
+  chain_reorgs: null
+};
+// src/db/jsonb.ts
+import { sql } from "kysely";
+function jsonb(value) {
+  const escaped = JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''");
+  return sql`${sql.raw(`'${escaped}'::jsonb`)}`;
+}
+function parseJsonb(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value ?? {};
+}
+// src/db/migration-role.ts
+var currentRole = "both";
+function setMigrationRole(role) {
+  currentRole = role;
+}
+function getMigrationRole() {
+  return currentRole;
+}
+async function onControlPlane(fn) {
+  if (currentRole === "target" || currentRole === "both")
+    await fn();
+}
+async function onChainPlane(fn) {
+  if (currentRole === "source" || currentRole === "both")
+    await fn();
+}
+// src/db/table-plane.ts
+var TABLE_TO_DB = {
+  blocks: "source",
+  transactions: "source",
+  events: "source",
+  vm_events: "source",
+  transactions_archive: "source",
+  events_archive: "source",
+  vm_events_archive: "source",
+  dead_letter_events: "source",
+  mempool_transactions: "source",
+  index_progress: "source",
+  contracts: "source",
+  chain_reorgs: "source",
+  chain_read_cache: "source",
+  pending_fork_blocks: "source",
+  observer_journal: "source",
+  sync_scopes: "source",
+  stage_registry: "source",
+  stage_runs: "source",
+  stage_block_receipts: "source",
+  coverage_segments: "source",
+  stage_failures: "source",
+  decoded_events: "source",
+  decoder_checkpoints: "source",
+  pox4_calls: "source",
+  pox5_events: "source",
+  burn_block_rewards: "source",
+  burn_block_reward_slots: "source",
+  sbtc_events: "source",
+  sbtc_token_events: "source",
+  sbtc_settlements: "source",
+  bns_name_events: "source",
+  bns_namespace_events: "source",
+  bns_marketplace_events: "source",
+  bns_names: "source",
+  bns_namespaces: "source",
+  instances: "target",
+  accounts: "target",
+  api_keys: "target",
+  sessions: "target",
+  magic_links: "target",
+  account_spend_caps: "target",
+  processed_stripe_events: "target",
+  webhooks: "target",
+  webhook_outbox: "target",
+  webhook_deliveries: "target",
+  trigger_evaluator_state: "target",
+  subgraphs: "target",
+  subgraph_operations: "target",
+  subgraph_health_snapshots: "target",
+  subgraph_gaps: "target",
+  subgraph_violations: "target",
+  subgraph_processing_stats: "target",
+  account_credits: "target",
+  archive_fetches: "target",
+  usage_ledger: "target",
+  waitlists: "target",
+  waitlist_signups: "target",
+  service_heartbeats: "both"
+};
+
+// src/db/index.ts
+var DEFAULT_URL = "postgres://postgres:postgres@localhost:5432/secondlayer_dev";
+var pools = new Map;
+var poolSeq = 0;
+function maxPools() {
+  return Number.parseInt(process.env.DATABASE_MAX_POOLS ?? "25", 10);
+}
+function evictIfNeeded() {
+  if (pools.size <= maxPools())
+    return;
+  const protectedUrls = new Set([resolveSourceUrl(), resolveTargetUrl()]);
+  let lruUrl;
+  let lruEntry;
+  for (const [url, entry] of pools) {
+    if (protectedUrls.has(url))
+      continue;
+    if (!lruEntry || entry.lastUsed < lruEntry.lastUsed || entry.lastUsed === lruEntry.lastUsed && entry.seq < lruEntry.seq) {
+      lruUrl = url;
+      lruEntry = entry;
+    }
+  }
+  if (!lruUrl || !lruEntry)
+    return;
+  pools.delete(lruUrl);
+  const evicted = lruEntry;
+  evicted.db.destroy().catch(() => {}).then(() => evicted.rawClient.end({ timeout: 5 })).catch(() => {});
+}
+function applicationDatabaseUrl() {
+  return process.env.DATABASE_URL || DEFAULT_URL;
+}
+function resolveSourceUrl() {
+  if (!isPlatformMode())
+    return applicationDatabaseUrl();
+  return process.env.SOURCE_DATABASE_URL || process.env.DATABASE_URL || DEFAULT_URL;
+}
+function resolveTargetUrl() {
+  if (!isPlatformMode())
+    return applicationDatabaseUrl();
+  return process.env.TARGET_DATABASE_URL || process.env.DATABASE_URL || DEFAULT_URL;
+}
+function describeDbUrl(url) {
+  try {
+    const u = new URL(url);
+    return `${u.hostname}${u.port ? `:${u.port}` : ""}${u.pathname}`;
+  } catch {
+    return "invalid-url";
+  }
+}
+var warnedDefaultUrlFallthrough = false;
+function warnIfTestRunFallsThroughToDefault() {
+  if (warnedDefaultUrlFallthrough)
+    return;
+  if (process.env["NODE_ENV"] !== "test")
+    return;
+  if (process.env.DATABASE_URL || process.env.SOURCE_DATABASE_URL || process.env.TARGET_DATABASE_URL) {
+    return;
+  }
+  warnedDefaultUrlFallthrough = true;
+  console.warn(`⚠️  DATABASE_URL unset — falling through to the built-in DEFAULT_URL (${describeDbUrl(DEFAULT_URL)}). Database-backed tests will skip or hit the wrong Postgres. Copy .env.example to .env in this package (see \`bun run db\`).`);
+}
+warnIfTestRunFallsThroughToDefault();
+function getDbSplitStatus() {
+  const source = resolveSourceUrl();
+  const target = resolveTargetUrl();
+  const active = source !== target;
+  return {
+    mode: active ? "split" : "single",
+    active,
+    sourceDb: describeDbUrl(source),
+    targetDb: describeDbUrl(target)
+  };
+}
+function assertDbSplit() {
+  const isProd = isProductionEnv();
+  const wantsSplit = !!(process.env.SOURCE_DATABASE_URL || process.env.TARGET_DATABASE_URL);
+  const databaseUrlSet = !!process.env.DATABASE_URL;
+  const source = resolveSourceUrl();
+  const target = resolveTargetUrl();
+  if (wantsSplit && !databaseUrlSet && (source === DEFAULT_URL || target === DEFAULT_URL)) {
+    const which = source === DEFAULT_URL ? "SOURCE_DATABASE_URL" : "TARGET_DATABASE_URL";
+    const msg = `${which} unset and DATABASE_URL absent — resolving to built-in DEFAULT_URL; refusing to silently use the wrong database`;
+    if (isProd)
+      console.error(`❌ ${msg}`);
+    else
+      console.warn(`⚠️  ${msg}`);
+    return;
+  }
+  if (!wantsSplit) {
+    if (isProd) {
+      console.warn("⚠️  DB split dormant — all services share one Postgres failure domain (SOURCE_/TARGET_DATABASE_URL unset)");
+    }
+    return;
+  }
+  if (source === target) {
+    const msg = "DB split requested but SOURCE_DATABASE_URL === TARGET_DATABASE_URL (check for a typo or a stray DATABASE_URL fallback)";
+    if (isProd)
+      console.error(`❌ ${msg}`);
+    else
+      console.warn(`⚠️  ${msg}`);
+  }
+}
+function getOrCreatePool(url) {
+  const existing = pools.get(url);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    existing.seq = poolSeq++;
+    return existing;
+  }
+  const host = (() => {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return "";
+    }
+  })();
+  const isLocal = host === "localhost" || host === "127.0.0.1" || !host.includes(".");
+  const poolMax = Number.parseInt(process.env.DATABASE_POOL_MAX ?? "20", 10);
+  const idleTimeout = Number.parseInt(process.env.DATABASE_IDLE_TIMEOUT ?? "300", 10);
+  const rawClient = postgres(url, {
+    max: poolMax,
+    idle_timeout: idleTimeout,
+    ssl: isLocal ? undefined : {
+      rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0"
+    }
+  });
+  const db = new Kysely({
+    dialect: new PostgresJSDialect({ postgres: rawClient }),
+    log: (event) => {
+      if (event.level !== "error")
+        return;
+      const err = event.error;
+      if (err?.code !== "42P10")
+        return;
+      logger.warn("db.on_conflict_constraint_missing", {
+        code: err.code,
+        message: err.message,
+        sql: event.query.sql,
+        params: event.query.parameters
+      });
+    }
+  });
+  const entry = {
+    db,
+    rawClient,
+    lastUsed: Date.now(),
+    seq: poolSeq++
+  };
+  pools.set(url, entry);
+  evictIfNeeded();
+  return entry;
+}
+function getSourceDb() {
+  return getOrCreatePool(resolveSourceUrl()).db;
+}
+function getTargetDb() {
+  return getOrCreatePool(resolveTargetUrl()).db;
+}
+function getDb(connectionString) {
+  if (connectionString)
+    return getOrCreatePool(connectionString).db;
+  return getTargetDb();
+}
+function getRawClient(role = "target") {
+  const url = role === "source" ? resolveSourceUrl() : resolveTargetUrl();
+  return getOrCreatePool(url).rawClient;
+}
+function getRawClientFor(url) {
+  return getOrCreatePool(url).rawClient;
+}
+async function closeDb() {
+  for (const entry of pools.values()) {
+    await entry.db.destroy();
+    await entry.rawClient.end();
+  }
+  pools.clear();
+}
+// src/queue/listener.ts
 function sourceListenerUrl() {
-  return process.env.SOURCE_DATABASE_URL || process.env.DATABASE_URL;
+  return resolveSourceUrl();
 }
 function targetListenerUrl() {
-  return process.env.TARGET_DATABASE_URL || process.env.DATABASE_URL;
+  return resolveTargetUrl();
 }
 function resolveUrl(opts) {
   const url = opts?.connectionString || process.env.DATABASE_URL;
@@ -14,7 +973,7 @@ function resolveUrl(opts) {
   return url;
 }
 async function listen(channel, callback, opts) {
-  const client = postgres(resolveUrl(opts), {
+  const client = postgres2(resolveUrl(opts), {
     max: 1,
     onnotice: () => {}
   });
@@ -25,8 +984,27 @@ async function listen(channel, callback, opts) {
     await client.end();
   };
 }
+async function createWakeBus(channel, opts) {
+  let waiters = new Set;
+  const stopListening = await listen(channel, () => {
+    const pending = waiters;
+    waiters = new Set;
+    for (const resolve of pending)
+      resolve();
+  }, opts);
+  return {
+    wait: () => new Promise((resolve) => waiters.add(resolve)),
+    stop: async () => {
+      const pending = waiters;
+      waiters = new Set;
+      for (const resolve of pending)
+        resolve();
+      await stopListening();
+    }
+  };
+}
 async function notify(channel, payload, opts) {
-  const client = postgres(resolveUrl(opts), { max: 1 });
+  const client = postgres2(resolveUrl(opts), { max: 1 });
   try {
     if (payload) {
       await client`SELECT pg_notify(${channel}, ${payload})`;
@@ -38,11 +1016,12 @@ async function notify(channel, payload, opts) {
   }
 }
 export {
+  createWakeBus,
   listen,
   notify,
   sourceListenerUrl,
   targetListenerUrl
 };
 
-//# debugId=572FCF166DDCA86A64756E2164756E21
+//# debugId=3C6355491C0B100364756E2164756E21
 //# sourceMappingURL=listener.js.map