@fiber-pay/runtime 0.1.0-rc.1

package/dist/index.js

@@ -0,0 +1,3389 @@
+// src/service.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { FiberRpcClient as FiberRpcClient2 } from "@fiber-pay/sdk";
+
+// src/alerts/alert-manager.ts
+import { randomUUID } from "crypto";
+var AlertManager = class {
+  backends;
+  store;
+  listeners = [];
+  constructor(options) {
+    this.backends = options.backends;
+    this.store = options.store;
+  }
+  /** Register a listener that is called after every emitted alert. */
+  onEmit(listener) {
+    this.listeners.push(listener);
+  }
+  async start() {
+    for (const backend of this.backends) {
+      if (backend.start) {
+        await backend.start();
+      }
+    }
+  }
+  async stop() {
+    for (const backend of this.backends) {
+      if (backend.stop) {
+        await backend.stop();
+      }
+    }
+  }
+  async emit(input) {
+    const alert = {
+      id: randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: input.type,
+      priority: input.priority,
+      source: input.source,
+      data: input.data
+    };
+    this.store.addAlert(alert);
+    await Promise.allSettled(this.backends.map((backend) => backend.send(alert)));
+    for (const listener of this.listeners) {
+      listener(alert);
+    }
+    return alert;
+  }
+};
+
+// src/alerts/backends/file-jsonl.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var JsonlFileAlertBackend = class {
+  path;
+  constructor(path) {
+    this.path = path;
+    mkdirSync(dirname(path), { recursive: true });
+  }
+  async send(alert) {
+    appendFileSync(this.path, `${JSON.stringify(alert)}
+`, "utf-8");
+  }
+};
+
+// src/alerts/format.ts
+var ANSI_RESET = "\x1B[0m";
+var ANSI_BOLD = "\x1B[1m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_RED = "\x1B[31m";
+var ANSI_GREEN = "\x1B[32m";
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_BLUE = "\x1B[34m";
+var ANSI_MAGENTA = "\x1B[35m";
+var ANSI_CYAN = "\x1B[36m";
+function clip(value, max = 120) {
+  if (value.length <= max) {
+    return value;
+  }
+  return `${value.slice(0, max - 1)}\u2026`;
+}
+function readStringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toRecord(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  return value;
+}
+function summarizeAlertData(data, withColor) {
+  if (data === null || data === void 0) {
+    return "{}";
+  }
+  if (typeof data !== "object") {
+    return clip(String(data), 160);
+  }
+  const record = data;
+  const parts = [];
+  const eventType = readStringField(record, "type");
+  if (eventType) {
+    parts.push(`type=${eventType}`);
+  }
+  const channel = toRecord(record.channel);
+  const previousChannel = toRecord(record.previousChannel);
+  const channelId = readStringField(record, "channelId") ?? readStringField(channel ?? {}, "channel_id") ?? readStringField(previousChannel ?? {}, "channel_id");
+  if (channelId) {
+    parts.push(`channelId=${channelId}`);
+  }
+  const paymentHash = readStringField(record, "paymentHash");
+  if (paymentHash) {
+    parts.push(`paymentHash=${paymentHash}`);
+  }
+  const invoicePaymentHash = readStringField(record, "invoicePaymentHash");
+  if (invoicePaymentHash) {
+    parts.push(`invoicePaymentHash=${invoicePaymentHash}`);
+  }
+  const peerId = readStringField(record, "peerId") ?? readStringField(channel ?? {}, "peer_id");
+  if (peerId) {
+    parts.push(`peerId=${peerId}`);
+  }
+  const jobId = readStringField(record, "jobId");
+  if (jobId) {
+    parts.push(`jobId=${jobId}`);
+  }
+  const previousState = readStringField(record, "previousState");
+  const currentState = readStringField(record, "currentState");
+  if (previousState && currentState) {
+    parts.push(
+      colorize(`state=${previousState}->${currentState}`, `${ANSI_BOLD}${ANSI_YELLOW}`, withColor)
+    );
+  }
+  const channelState = toRecord(channel?.state);
+  const previousChannelState = toRecord(previousChannel?.state);
+  const currentStateName = readStringField(channelState ?? {}, "state_name");
+  const previousStateName = readStringField(previousChannelState ?? {}, "state_name");
+  if (!previousState && !currentState && previousStateName && currentStateName) {
+    parts.push(
+      colorize(`state=${previousStateName}->${currentStateName}`, `${ANSI_BOLD}${ANSI_YELLOW}`, withColor)
+    );
+  } else if (!previousState && !currentState && currentStateName) {
+    parts.push(colorize(`state=${currentStateName}`, `${ANSI_BOLD}${ANSI_YELLOW}`, withColor));
+  }
+  const reason = readStringField(record, "reason") ?? readStringField(record, "message");
+  if (reason) {
+    parts.push(`reason=${clip(reason, 80)}`);
+  }
+  const error = readStringField(record, "error");
+  if (error) {
+    parts.push(`error=${clip(error, 80)}`);
+  }
+  if (parts.length > 0) {
+    return parts.join(" ");
+  }
+  return clip(JSON.stringify(record), 160);
+}
+function shouldUseColor(mode) {
+  if (mode === "always") {
+    return true;
+  }
+  if (mode === "never") {
+    return false;
+  }
+  return process.env.NO_COLOR === void 0 && process.stdout.isTTY !== false;
+}
+function colorize(text, color, enabled) {
+  if (!enabled) {
+    return text;
+  }
+  return `${color}${text}${ANSI_RESET}`;
+}
+function formatRuntimeAlert(alert, options = {}) {
+  const colorMode = options.color ?? "auto";
+  const withColor = shouldUseColor(colorMode);
+  const priorityLabel = alert.priority.toUpperCase().padEnd(8, " ");
+  const priorityColor = alert.priority === "critical" ? ANSI_RED : alert.priority === "high" ? ANSI_YELLOW : alert.priority === "medium" ? ANSI_CYAN : ANSI_GREEN;
+  const typeColor = alert.type.startsWith("channel_") ? ANSI_BLUE : alert.type.startsWith("payment_") || alert.type.startsWith("incoming_") || alert.type.startsWith("outgoing_") ? ANSI_MAGENTA : ANSI_CYAN;
+  const prefixLabel = options.prefix ?? "[fiber-runtime]";
+  const prefix = colorize(prefixLabel, `${ANSI_BOLD}${ANSI_CYAN}`, withColor);
+  const ts = colorize(alert.timestamp, ANSI_DIM, withColor);
+  const priority = colorize(priorityLabel, `${ANSI_BOLD}${priorityColor}`, withColor);
+  const type = colorize(alert.type, `${ANSI_BOLD}${typeColor}`, withColor);
+  const data = colorize(summarizeAlertData(alert.data, withColor), ANSI_DIM, withColor);
+  return `${prefix} ${ts} ${priority} ${type} ${data}`;
+}
+
+// src/alerts/backends/stdout.ts
+var StdoutAlertBackend = class {
+  async send(alert) {
+    console.log(formatRuntimeAlert(alert));
+  }
+};
+
+// src/utils/async.ts
+function sleep(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/alerts/backends/webhook.ts
+var WebhookAlertBackend = class {
+  config;
+  constructor(config) {
+    this.config = {
+      timeoutMs: 5e3,
+      headers: {},
+      ...config
+    };
+  }
+  async send(alert) {
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+      try {
+        const response = await fetch(this.config.url, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...this.config.headers
+          },
+          body: JSON.stringify(alert),
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (response.ok) {
+          return;
+        }
+        lastError = new Error(`Webhook response status: ${response.status}`);
+      } catch (error) {
+        clearTimeout(timer);
+        lastError = error;
+      }
+      await sleep(100 * 2 ** attempt);
+    }
+    throw new Error(`Failed to deliver webhook alert: ${String(lastError)}`);
+  }
+};
+
+// src/alerts/backends/websocket.ts
+import { createHash } from "crypto";
+import http from "http";
+var WebsocketAlertBackend = class {
+  config;
+  clients = /* @__PURE__ */ new Set();
+  server;
+  constructor(config) {
+    this.config = config;
+  }
+  async start() {
+    if (this.server) {
+      return;
+    }
+    this.server = http.createServer((req, res) => {
+      if (req.url === "/health") {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+        return;
+      }
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+    });
+    this.server.on("upgrade", (request, socket) => {
+      const key = request.headers["sec-websocket-key"];
+      if (!key || typeof key !== "string") {
+        socket.destroy();
+        return;
+      }
+      const accept = createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+      const headers = [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${accept}`
+      ];
+      socket.write(`${headers.join("\r\n")}\r
+\r
+`);
+      this.clients.add(socket);
+      socket.on("close", () => this.clients.delete(socket));
+      socket.on("end", () => this.clients.delete(socket));
+      socket.on("error", () => this.clients.delete(socket));
+    });
+    await new Promise((resolve2, reject) => {
+      this.server?.once("error", reject);
+      this.server?.listen(this.config.port, this.config.host, () => {
+        this.server?.off("error", reject);
+        resolve2();
+      });
+    });
+  }
+  async send(alert) {
+    const payload = Buffer.from(JSON.stringify(alert), "utf8");
+    const frame = buildWebSocketFrame(payload);
+    for (const client of this.clients) {
+      try {
+        client.write(frame);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  async stop() {
+    for (const client of this.clients) {
+      client.destroy();
+    }
+    this.clients.clear();
+    if (!this.server) {
+      return;
+    }
+    const server = this.server;
+    this.server = void 0;
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
+  }
+};
+function buildWebSocketFrame(payload) {
+  const payloadLength = payload.length;
+  if (payloadLength < 126) {
+    return Buffer.concat([Buffer.from([129, payloadLength]), payload]);
+  }
+  if (payloadLength < 65536) {
+    const header2 = Buffer.alloc(4);
+    header2[0] = 129;
+    header2[1] = 126;
+    header2.writeUInt16BE(payloadLength, 2);
+    return Buffer.concat([header2, payload]);
+  }
+  const header = Buffer.alloc(10);
+  header[0] = 129;
+  header[1] = 127;
+  header.writeUInt32BE(0, 2);
+  header.writeUInt32BE(payloadLength, 6);
+  return Buffer.concat([header, payload]);
+}
+
+// src/config.ts
+import { resolve } from "path";
+
+// src/jobs/retry-policy.ts
+var defaultPaymentRetryPolicy = {
+  maxRetries: 3,
+  baseDelayMs: 2e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2,
+  jitterMs: 500
+};
+function shouldRetry(error, retryCount, policy) {
+  if (!error.retryable) return false;
+  if (retryCount >= policy.maxRetries) return false;
+  return true;
+}
+function computeRetryDelay(retryCount, policy) {
+  const base = policy.baseDelayMs * policy.backoffMultiplier ** retryCount;
+  const capped = Math.min(base, policy.maxDelayMs);
+  const jitter = Math.floor(Math.random() * policy.jitterMs);
+  return capped + jitter;
+}
+
+// src/config.ts
+var defaultRuntimeConfig = {
+  fiberRpcUrl: "http://127.0.0.1:8227",
+  channelPollIntervalMs: 3e3,
+  invoicePollIntervalMs: 2e3,
+  paymentPollIntervalMs: 1e3,
+  peerPollIntervalMs: 1e4,
+  healthPollIntervalMs: 5e3,
+  includeClosedChannels: true,
+  completedItemTtlSeconds: 86400,
+  requestTimeoutMs: 1e4,
+  alerts: [{ type: "stdout" }],
+  proxy: {
+    enabled: true,
+    listen: "127.0.0.1:8229"
+  },
+  storage: {
+    stateFilePath: resolve(process.cwd(), ".fiber-pay-runtime-state.json"),
+    flushIntervalMs: 3e4,
+    maxAlertHistory: 5e3
+  },
+  jobs: {
+    enabled: true,
+    dbPath: resolve(process.cwd(), ".fiber-pay-jobs.db"),
+    maxConcurrentJobs: 5,
+    schedulerIntervalMs: 500,
+    retryPolicy: defaultPaymentRetryPolicy
+  }
+};
+function createRuntimeConfig(input = {}) {
+  const config = {
+    ...defaultRuntimeConfig,
+    ...input,
+    proxy: {
+      ...defaultRuntimeConfig.proxy,
+      ...input.proxy
+    },
+    storage: {
+      ...defaultRuntimeConfig.storage,
+      ...input.storage
+    },
+    jobs: {
+      ...defaultRuntimeConfig.jobs,
+      ...input.jobs,
+      retryPolicy: {
+        ...defaultRuntimeConfig.jobs.retryPolicy,
+        ...input.jobs?.retryPolicy
+      }
+    },
+    alerts: input.alerts ?? defaultRuntimeConfig.alerts
+  };
+  if (!config.fiberRpcUrl) {
+    throw new Error("Runtime config requires fiberRpcUrl");
+  }
+  if (!config.proxy.listen) {
+    throw new Error("Runtime config requires proxy.listen");
+  }
+  if (config.channelPollIntervalMs <= 0 || config.invoicePollIntervalMs <= 0) {
+    throw new Error("Polling intervals must be > 0");
+  }
+  if (config.paymentPollIntervalMs <= 0 || config.peerPollIntervalMs <= 0) {
+    throw new Error("Polling intervals must be > 0");
+  }
+  if (config.healthPollIntervalMs <= 0) {
+    throw new Error("healthPollIntervalMs must be > 0");
+  }
+  if (config.completedItemTtlSeconds < 0) {
+    throw new Error("completedItemTtlSeconds must be >= 0");
+  }
+  if (config.storage.flushIntervalMs <= 0) {
+    throw new Error("storage.flushIntervalMs must be > 0");
+  }
+  if (config.storage.maxAlertHistory <= 0) {
+    throw new Error("storage.maxAlertHistory must be > 0");
+  }
+  if (!config.jobs.dbPath) {
+    throw new Error("jobs.dbPath is required");
+  }
+  if (config.jobs.maxConcurrentJobs <= 0) {
+    throw new Error("jobs.maxConcurrentJobs must be > 0");
+  }
+  if (config.jobs.schedulerIntervalMs <= 0) {
+    throw new Error("jobs.schedulerIntervalMs must be > 0");
+  }
+  if (config.jobs.retryPolicy.maxRetries < 0) {
+    throw new Error("jobs.retryPolicy.maxRetries must be >= 0");
+  }
+  if (config.jobs.retryPolicy.baseDelayMs < 0) {
+    throw new Error("jobs.retryPolicy.baseDelayMs must be >= 0");
+  }
+  if (config.jobs.retryPolicy.maxDelayMs < 0) {
+    throw new Error("jobs.retryPolicy.maxDelayMs must be >= 0");
+  }
+  return config;
+}
+function parseListenAddress(listen) {
+  const [host, portText] = listen.split(":");
+  const port = Number(portText);
+  if (!host || Number.isNaN(port) || port <= 0) {
+    throw new Error(`Invalid listen address: ${listen}`);
+  }
+  return { host, port };
+}
+
+// src/monitors/channel-monitor.ts
+import { ChannelState } from "@fiber-pay/sdk";
+
+// src/diff/channel-diff.ts
+function diffChannels(previous, current) {
+  const events = [];
+  const prevById = new Map(previous.map((channel) => [channel.channel_id, channel]));
+  const currById = new Map(current.map((channel) => [channel.channel_id, channel]));
+  for (const [channelId, channel] of currById.entries()) {
+    const previousChannel = prevById.get(channelId);
+    if (!previousChannel) {
+      events.push({ type: "channel_new", channel });
+      continue;
+    }
+    if (channel.state.state_name !== previousChannel.state.state_name) {
+      events.push({
+        type: "channel_state_changed",
+        channel,
+        previousState: previousChannel.state.state_name,
+        currentState: channel.state.state_name
+      });
+    }
+    if (channel.local_balance !== previousChannel.local_balance || channel.remote_balance !== previousChannel.remote_balance) {
+      events.push({
+        type: "channel_balance_changed",
+        channel,
+        localBalanceBefore: previousChannel.local_balance,
+        localBalanceAfter: channel.local_balance,
+        remoteBalanceBefore: previousChannel.remote_balance,
+        remoteBalanceAfter: channel.remote_balance
+      });
+    }
+    const previousPending = new Set(previousChannel.pending_tlcs.map((tlc) => tlc.id));
+    const newTlcCount = channel.pending_tlcs.filter((tlc) => !previousPending.has(tlc.id)).length;
+    if (newTlcCount > 0) {
+      events.push({
+        type: "channel_pending_tlc_added",
+        channel,
+        previousPendingTlcCount: previousChannel.pending_tlcs.length,
+        newPendingTlcCount: channel.pending_tlcs.length
+      });
+    }
+  }
+  for (const [channelId, previousChannel] of prevById.entries()) {
+    if (!currById.has(channelId)) {
+      events.push({
+        type: "channel_disappeared",
+        channelId,
+        previousChannel
+      });
+    }
+  }
+  return events;
+}
+
+// src/monitors/base-monitor.ts
+var BaseMonitor = class {
+  intervalMs;
+  hooks;
+  timer;
+  running = false;
+  constructor(intervalMs, hooks = {}) {
+    this.intervalMs = intervalMs;
+    this.hooks = hooks;
+  }
+  start() {
+    this.stop();
+    void this.runOnce();
+    this.timer = setInterval(() => {
+      void this.runOnce();
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  async runOnce() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    try {
+      await this.poll();
+      await this.hooks.onCycleSuccess?.(this.name);
+    } catch (error) {
+      await this.hooks.onCycleError?.(error, this.name);
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
+// src/monitors/channel-monitor.ts
+var ChannelMonitor = class extends BaseMonitor {
+  get name() {
+    return "channel-monitor";
+  }
+  client;
+  store;
+  alerts;
+  config;
+  constructor(options) {
+    super(options.config.intervalMs, options.hooks);
+    this.client = options.client;
+    this.store = options.store;
+    this.alerts = options.alerts;
+    this.config = options.config;
+  }
+  async poll() {
+    const previous = this.store.getChannelSnapshot();
+    const result = await this.client.listChannels({
+      include_closed: this.config.includeClosedChannels
+    });
+    const current = result.channels;
+    const changes = diffChannels(previous, current);
+    for (const change of changes) {
+      if (change.type === "channel_new" && change.channel.state.state_name === ChannelState.NegotiatingFunding) {
+        await this.alerts.emit({
+          type: "new_inbound_channel_request",
+          priority: "high",
+          source: this.name,
+          data: { channelId: change.channel.channel_id, channel: change.channel }
+        });
+      }
+      if (change.type === "channel_state_changed") {
+        await this.alerts.emit({
+          type: "channel_state_changed",
+          priority: getChannelStatePriority(change.currentState),
+          source: this.name,
+          data: {
+            channelId: change.channel.channel_id,
+            previousState: change.previousState,
+            currentState: change.currentState,
+            channel: change.channel
+          }
+        });
+      }
+      if (change.type === "channel_state_changed" && change.currentState === ChannelState.ChannelReady) {
+        await this.alerts.emit({
+          type: "channel_became_ready",
+          priority: "medium",
+          source: this.name,
+          data: change
+        });
+      }
+      if (change.type === "channel_state_changed" && (change.currentState === ChannelState.ShuttingDown || change.currentState === ChannelState.Closed)) {
+        await this.alerts.emit({
+          type: "channel_closing",
+          priority: "high",
+          source: this.name,
+          data: change
+        });
+      }
+      if (change.type === "channel_disappeared") {
+        await this.alerts.emit({
+          type: "channel_state_changed",
+          priority: "high",
+          source: this.name,
+          data: {
+            channelId: change.channelId,
+            previousState: change.previousChannel.state.state_name,
+            currentState: "DISAPPEARED",
+            channel: change.previousChannel
+          }
+        });
+        await this.alerts.emit({
+          type: "channel_closing",
+          priority: "high",
+          source: this.name,
+          data: change
+        });
+      }
+      if (change.type === "channel_balance_changed") {
+        await this.alerts.emit({
+          type: "channel_balance_changed",
+          priority: "low",
+          source: this.name,
+          data: change
+        });
+      }
+      if (change.type === "channel_pending_tlc_added") {
+        await this.alerts.emit({
+          type: "new_pending_tlc",
+          priority: "medium",
+          source: this.name,
+          data: change
+        });
+      }
+    }
+    this.store.setChannelSnapshot(current);
+  }
+};
+function getChannelStatePriority(stateName) {
+  const normalized = stateName.toUpperCase();
+  const closedState = String(ChannelState.Closed).toUpperCase();
+  const shuttingDownState = String(ChannelState.ShuttingDown).toUpperCase();
+  const readyState = String(ChannelState.ChannelReady).toUpperCase();
+  if (normalized === closedState || normalized === "CLOSED" || normalized === shuttingDownState || normalized === "SHUTTING_DOWN") {
+    return "high";
+  }
+  if (normalized === readyState || normalized === "CHANNEL_READY") {
+    return "medium";
+  }
+  return "low";
+}
+
+// src/monitors/health-monitor.ts
+var HealthMonitor = class extends BaseMonitor {
+  get name() {
+    return "health-monitor";
+  }
+  client;
+  alerts;
+  isOffline = false;
+  constructor(options) {
+    super(options.config.intervalMs, options.hooks);
+    this.client = options.client;
+    this.alerts = options.alerts;
+  }
+  async poll() {
+    let isHealthy = false;
+    let failureReason;
+    try {
+      isHealthy = await this.client.ping();
+    } catch (error) {
+      failureReason = error instanceof Error ? error.message : String(error);
+      isHealthy = false;
+    }
+    if (isHealthy && this.isOffline) {
+      this.isOffline = false;
+      await this.alerts.emit({
+        type: "node_online",
+        priority: "low",
+        source: this.name,
+        data: { message: "Fiber node RPC recovered" }
+      });
+      return;
+    }
+    if (!isHealthy && !this.isOffline) {
+      this.isOffline = true;
+      await this.alerts.emit({
+        type: "node_offline",
+        priority: "critical",
+        source: this.name,
+        data: {
+          message: failureReason ? `Fiber node ping failed: ${failureReason}` : "Fiber node ping returned false"
+        }
+      });
+    }
+  }
+};
+
+// src/monitors/tracker-utils.ts
+function isExpectedTrackerError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /not found|does not exist|no such|temporarily unavailable|connection refused|timed out|timeout/i.test(
+    message
+  );
+}
+
+// src/monitors/invoice-tracker.ts
+var InvoiceTracker = class extends BaseMonitor {
+  get name() {
+    return "invoice-tracker";
+  }
+  client;
+  store;
+  alerts;
+  config;
+  constructor(options) {
+    super(options.config.intervalMs, options.hooks);
+    this.client = options.client;
+    this.store = options.store;
+    this.alerts = options.alerts;
+    this.config = options.config;
+  }
+  async poll() {
+    const tracked = this.store.listTrackedInvoices();
+    for (const invoice of tracked) {
+      try {
+        const next = await this.client.getInvoice({ payment_hash: invoice.paymentHash });
+        const previousStatus = invoice.status;
+        const currentStatus = next.status;
+        if (currentStatus !== previousStatus) {
+          this.store.updateTrackedInvoice(invoice.paymentHash, currentStatus);
+          if (currentStatus === "Received" || currentStatus === "Paid") {
+            await this.alerts.emit({
+              type: "incoming_payment_received",
+              priority: "high",
+              source: this.name,
+              data: {
+                paymentHash: invoice.paymentHash,
+                previousStatus,
+                currentStatus,
+                invoice: next
+              }
+            });
+          }
+          if (currentStatus === "Expired") {
+            await this.alerts.emit({
+              type: "invoice_expired",
+              priority: "medium",
+              source: this.name,
+              data: {
+                paymentHash: invoice.paymentHash,
+                previousStatus,
+                currentStatus,
+                invoice: next
+              }
+            });
+          }
+          if (currentStatus === "Cancelled") {
+            await this.alerts.emit({
+              type: "invoice_cancelled",
+              priority: "medium",
+              source: this.name,
+              data: {
+                paymentHash: invoice.paymentHash,
+                previousStatus,
+                currentStatus,
+                invoice: next
+              }
+            });
+          }
+        }
+      } catch (error) {
+        if (isExpectedTrackerError(error)) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    this.store.pruneCompleted(this.config.completedItemTtlSeconds * 1e3);
+  }
+};
+
+// src/monitors/payment-tracker.ts
+var PaymentTracker = class extends BaseMonitor {
+  get name() {
+    return "payment-tracker";
+  }
+  client;
+  store;
+  alerts;
+  config;
+  constructor(options) {
+    super(options.config.intervalMs, options.hooks);
+    this.client = options.client;
+    this.store = options.store;
+    this.alerts = options.alerts;
+    this.config = options.config;
+  }
+  async poll() {
+    const tracked = this.store.listTrackedPayments();
+    for (const payment of tracked) {
+      try {
+        const next = await this.client.getPayment({ payment_hash: payment.paymentHash });
+        const previousStatus = payment.status;
+        const currentStatus = next.status;
+        if (currentStatus !== previousStatus) {
+          this.store.updateTrackedPayment(payment.paymentHash, currentStatus);
+          if (currentStatus === "Success") {
+            await this.alerts.emit({
+              type: "outgoing_payment_completed",
+              priority: "medium",
+              source: this.name,
+              data: {
+                paymentHash: payment.paymentHash,
+                previousStatus,
+                currentStatus,
+                payment: next
+              }
+            });
+          }
+          if (currentStatus === "Failed") {
+            await this.alerts.emit({
+              type: "outgoing_payment_failed",
+              priority: "high",
+              source: this.name,
+              data: {
+                paymentHash: payment.paymentHash,
+                previousStatus,
+                currentStatus,
+                payment: next
+              }
+            });
+          }
+        }
+      } catch (error) {
+        if (isExpectedTrackerError(error)) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    this.store.pruneCompleted(this.config.completedItemTtlSeconds * 1e3);
+  }
+};
+
+// src/diff/peer-diff.ts
+function diffPeers(previous, current) {
+  const events = [];
+  const prevById = new Map(previous.map((peer) => [peer.peer_id, peer]));
+  const currById = new Map(current.map((peer) => [peer.peer_id, peer]));
+  for (const [peerId, peer] of currById.entries()) {
+    if (!prevById.has(peerId)) {
+      events.push({ type: "peer_connected", peer });
+    }
+  }
+  for (const [peerId, peer] of prevById.entries()) {
+    if (!currById.has(peerId)) {
+      events.push({ type: "peer_disconnected", peer });
+    }
+  }
+  return events;
+}
+
+// src/monitors/peer-monitor.ts
+var PeerMonitor = class extends BaseMonitor {
+  get name() {
+    return "peer-monitor";
+  }
+  client;
+  store;
+  alerts;
+  constructor(options) {
+    super(options.config.intervalMs, options.hooks);
+    this.client = options.client;
+    this.store = options.store;
+    this.alerts = options.alerts;
+  }
+  async poll() {
+    const previous = this.store.getPeerSnapshot();
+    const result = await this.client.listPeers();
+    const current = result.peers;
+    const changes = diffPeers(previous, current);
+    for (const change of changes) {
+      if (change.type === "peer_connected") {
+        await this.alerts.emit({
+          type: "peer_connected",
+          priority: "low",
+          source: this.name,
+          data: { peer: change.peer }
+        });
+      }
+      if (change.type === "peer_disconnected") {
+        await this.alerts.emit({
+          type: "peer_disconnected",
+          priority: "low",
+          source: this.name,
+          data: { peer: change.peer }
+        });
+      }
+    }
+    this.store.setPeerSnapshot(current);
+  }
+};
+
+// src/proxy/rpc-proxy.ts
+import http2 from "http";
+
+// src/proxy/body.ts
+var MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+async function readRawBody(req) {
+  const chunks = [];
+  let totalBytes = 0;
+  return await new Promise((resolve2, reject) => {
+    req.on("data", (chunk) => {
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_REQUEST_BODY_BYTES) {
+        req.destroy();
+        reject(new PayloadTooLargeError());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve2(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+var PayloadTooLargeError = class extends Error {
+  constructor() {
+    super("Payload too large");
+    this.name = "PayloadTooLargeError";
+  }
+};
+function isPayloadTooLargeError(error) {
+  return error instanceof PayloadTooLargeError;
+}
+
+// src/proxy/http-utils.ts
+var CORS_HEADERS = {
+  "access-control-allow-origin": "*",
+  "access-control-allow-methods": "GET,POST,DELETE,OPTIONS",
+  "access-control-allow-headers": "Content-Type, Authorization"
+};
+var CORS_PREFLIGHT_HEADERS = {
+  ...CORS_HEADERS,
+  "access-control-max-age": "86400"
+};
+function writeJson(res, status, value) {
+  res.writeHead(status, {
+    "content-type": "application/json",
+    ...CORS_HEADERS
+  });
+  res.end(JSON.stringify(value));
+}
+function parseOptionalPositiveInteger(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return void 0;
+  }
+  return parsed;
+}
+
+// src/proxy/json.ts
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/proxy/jsonrpc-tracking.ts
+function collectJsonRpcMethods(requestBody) {
+  const methods = /* @__PURE__ */ new Map();
+  for (const item of normalizeJsonRpcRequest(requestBody)) {
+    if (item.id !== void 0 && typeof item.method === "string") {
+      methods.set(item.id, item.method);
+    }
+  }
+  return methods;
+}
+function captureTrackedHashes(methodById, responseBody, handlers) {
+  const responses = normalizeJsonRpcResponse(responseBody);
+  for (const message of responses) {
+    if (message.error || message.id === void 0) {
+      continue;
+    }
+    const method = methodById.get(message.id);
+    if (!method) {
+      continue;
+    }
+    if (method === "new_invoice") {
+      const paymentHash = extractInvoicePaymentHash(message.result);
+      if (paymentHash) {
+        handlers.onInvoiceTracked(paymentHash);
+      }
+    }
+    if (method === "send_payment") {
+      const paymentHash = extractPaymentHash(message.result);
+      if (paymentHash) {
+        handlers.onPaymentTracked(paymentHash);
+      }
+    }
+  }
+}
+function normalizeJsonRpcRequest(body) {
+  if (!body) {
+    return [];
+  }
+  if (Array.isArray(body)) {
+    return body.filter(isObject);
+  }
+  if (isObject(body)) {
+    return [body];
+  }
+  return [];
+}
+function normalizeJsonRpcResponse(body) {
+  if (!body) {
+    return [];
+  }
+  if (Array.isArray(body)) {
+    return body.filter(isObject);
+  }
+  if (isObject(body)) {
+    return [body];
+  }
+  return [];
+}
+function extractInvoicePaymentHash(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  const invoice = result.invoice;
+  if (!isObject(invoice)) {
+    return void 0;
+  }
+  const data = invoice.data;
+  if (!isObject(data)) {
+    return void 0;
+  }
+  return typeof data.payment_hash === "string" ? data.payment_hash : void 0;
+}
+function extractPaymentHash(result) {
+  if (!isObject(result)) {
+    return void 0;
+  }
+  return typeof result.payment_hash === "string" ? result.payment_hash : void 0;
+}
+
+// src/proxy/job-routes.ts
+async function handleJobPostEndpoint(pathname, req, res, deps) {
+  let rawBody;
+  try {
+    rawBody = await readRawBody(req);
+  } catch (error) {
+    if (isPayloadTooLargeError(error)) {
+      writeJson(res, 413, { error: "Request body too large" });
+      return;
+    }
+    writeJson(res, 400, { error: "Failed to read request body" });
+    return;
+  }
+  const body = tryParseJson(rawBody.toString("utf-8"));
+  if (!isObject(body)) {
+    writeJson(res, 400, { error: "Invalid JSON body" });
+    return;
+  }
+  if (pathname === "/jobs/payment") {
+    if (!deps.createPaymentJob) {
+      writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+      return;
+    }
+    const params = body.params;
+    if (!params) {
+      writeJson(res, 400, { error: "Missing params for payment job" });
+      return;
+    }
+    const options = body.options;
+    const job = await deps.createPaymentJob(params, options);
+    writeJson(res, 200, job);
+    return;
+  }
+  if (pathname === "/jobs/invoice") {
+    if (!deps.createInvoiceJob) {
+      writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+      return;
+    }
+    const params = body.params;
+    if (!params) {
+      writeJson(res, 400, { error: "Missing params for invoice job" });
+      return;
+    }
+    const options = body.options;
+    const job = await deps.createInvoiceJob(params, options);
+    writeJson(res, 200, job);
+    return;
+  }
+  if (pathname === "/jobs/channel") {
+    if (!deps.createChannelJob) {
+      writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+      return;
+    }
+    const params = body.params;
+    if (!params) {
+      writeJson(res, 400, { error: "Missing params for channel job" });
+      return;
+    }
+    const options = body.options;
+    const job = await deps.createChannelJob(params, options);
+    writeJson(res, 200, job);
+    return;
+  }
+  writeJson(res, 404, { error: "Unknown jobs endpoint" });
+}
+async function handleDeleteEndpoint(req, res, deps) {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (!url.pathname.startsWith("/jobs/")) {
+    writeJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+  if (!deps.cancelJob) {
+    writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+    return;
+  }
+  const segments = url.pathname.split("/").filter(Boolean);
+  const [, id] = segments;
+  if (!id) {
+    writeJson(res, 400, { error: "Missing job id" });
+    return;
+  }
+  try {
+    deps.cancelJob(id);
+    writeJson(res, 204, {});
+  } catch (error) {
+    writeJson(res, 404, { error: String(error) });
+  }
+}
+
+// src/alerts/types.ts
+var alertTypeValues = [
+  "channel_state_changed",
+  "new_inbound_channel_request",
+  "channel_became_ready",
+  "channel_closing",
+  "incoming_payment_received",
+  "invoice_expired",
+  "invoice_cancelled",
+  "outgoing_payment_completed",
+  "outgoing_payment_failed",
+  "channel_balance_changed",
+  "new_pending_tlc",
+  "peer_connected",
+  "peer_disconnected",
+  "node_offline",
+  "node_online",
+  "payment_job_started",
+  "payment_job_retrying",
+  "payment_job_succeeded",
+  "payment_job_failed",
+  "invoice_job_started",
+  "invoice_job_retrying",
+  "invoice_job_succeeded",
+  "invoice_job_failed",
+  "channel_job_started",
+  "channel_job_retrying",
+  "channel_job_succeeded",
+  "channel_job_failed"
+];
+var alertPriorityOrder = {
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+function isAlertPriority(value) {
+  return value === "critical" || value === "high" || value === "medium" || value === "low";
+}
+function isAlertType(value) {
+  return alertTypeValues.includes(value);
+}
+
+// src/proxy/monitor-routes.ts
+function handleMonitorEndpoint(req, res, deps) {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname === "/jobs") {
+    if (!deps.listJobs) {
+      writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+      return;
+    }
+    const state = url.searchParams.get("state") ?? void 0;
+    const type = url.searchParams.get("type");
+    const limit = parseOptionalPositiveInteger(url.searchParams.get("limit"));
+    const offset = parseOptionalPositiveInteger(url.searchParams.get("offset"));
+    writeJson(res, 200, {
+      jobs: deps.listJobs({
+        state,
+        type: type ?? void 0,
+        limit,
+        offset
+      })
+    });
+    return;
+  }
+  if (url.pathname.startsWith("/jobs/")) {
+    if (!deps.getJob) {
+      writeJson(res, 404, { error: "Jobs are not enabled in runtime config" });
+      return;
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    const [, id, sub] = segments;
+    if (!id) {
+      writeJson(res, 400, { error: "Missing job id" });
+      return;
+    }
+    if (sub === "events") {
+      if (!deps.listJobEvents) {
+        writeJson(res, 404, { error: "Job events not available" });
+        return;
+      }
+      writeJson(res, 200, { events: deps.listJobEvents(id) });
+      return;
+    }
+    const job = deps.getJob(id);
+    if (!job) {
+      writeJson(res, 404, { error: "Job not found" });
+      return;
+    }
+    writeJson(res, 200, job);
+    return;
+  }
+  if (url.pathname === "/monitor/list_tracked_invoices") {
+    writeJson(res, 200, { invoices: deps.listTrackedInvoices() });
+    return;
+  }
+  if (url.pathname === "/monitor/list_tracked_payments") {
+    writeJson(res, 200, { payments: deps.listTrackedPayments() });
+    return;
+  }
+  if (url.pathname === "/monitor/list_alerts") {
+    const limitRaw = url.searchParams.get("limit");
+    const minPriorityRaw = url.searchParams.get("min_priority");
+    const typeRaw = url.searchParams.get("type");
+    const sourceRaw = url.searchParams.get("source");
+    const limit = parseOptionalPositiveInteger(limitRaw);
+    if (limitRaw !== null && limit === void 0) {
+      writeJson(res, 400, {
+        error: "Invalid query parameter: limit must be a positive integer"
+      });
+      return;
+    }
+    if (minPriorityRaw && !isAlertPriority(minPriorityRaw)) {
+      writeJson(res, 400, {
+        error: "Invalid query parameter: min_priority must be one of critical|high|medium|low"
+      });
+      return;
+    }
+    if (typeRaw && !isAlertType(typeRaw)) {
+      writeJson(res, 400, {
+        error: "Invalid query parameter: type is not a known alert type"
+      });
+      return;
+    }
+    const minPriority = minPriorityRaw && isAlertPriority(minPriorityRaw) ? minPriorityRaw : void 0;
+    const type = typeRaw && isAlertType(typeRaw) ? typeRaw : void 0;
+    writeJson(res, 200, {
+      alerts: deps.listAlerts({
+        limit,
+        minPriority,
+        type,
+        source: sourceRaw ?? void 0
+      })
+    });
+    return;
+  }
+  if (url.pathname === "/monitor/status") {
+    writeJson(res, 200, deps.getStatus());
+    return;
+  }
+  writeJson(res, 404, { error: "Not found" });
+}
+
+// src/proxy/rpc-proxy.ts
+var RpcMonitorProxy = class {
+  config;
+  deps;
+  server;
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+  }
+  async start() {
+    if (this.server) {
+      return;
+    }
+    this.server = http2.createServer((req, res) => {
+      void this.handleRequest(req, res);
+    });
+    const { host, port } = parseListenAddress(this.config.listen);
+    await new Promise((resolve2, reject) => {
+      this.server?.once("error", reject);
+      this.server?.listen(port, host, () => {
+        this.server?.off("error", reject);
+        resolve2();
+      });
+    });
+  }
+  async stop() {
+    if (!this.server) {
+      return;
+    }
+    const server = this.server;
+    this.server = void 0;
+    await new Promise((resolve2) => {
+      server.close(() => resolve2());
+    });
+  }
+  async handleRequest(req, res) {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, CORS_PREFLIGHT_HEADERS);
+      res.end();
+      return;
+    }
+    if (req.method === "GET") {
+      handleMonitorEndpoint(req, res, this.deps);
+      return;
+    }
+    if (req.method === "DELETE") {
+      await handleDeleteEndpoint(req, res, this.deps);
+      return;
+    }
+    if (req.method !== "POST") {
+      writeJson(res, 405, { error: "Method not allowed" });
+      return;
+    }
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname.startsWith("/jobs/")) {
+      await handleJobPostEndpoint(url.pathname, req, res, this.deps);
+      return;
+    }
+    let requestBody;
+    try {
+      requestBody = await readRawBody(req);
+    } catch (error) {
+      if (isPayloadTooLargeError(error)) {
+        writeJson(res, 413, { error: "Request body too large" });
+        return;
+      }
+      writeJson(res, 400, { error: "Failed to read request body" });
+      return;
+    }
+    const requestJson = tryParseJson(requestBody.toString("utf-8"));
+    const methodById = collectJsonRpcMethods(requestJson);
+    let responseText = "";
+    let responseStatus = 500;
+    let responseHeaders = new Headers();
+    try {
+      const response = await fetch(this.config.targetUrl, {
+        method: "POST",
+        headers: {
+          "content-type": req.headers["content-type"] ?? "application/json",
+          ...req.headers.authorization ? { authorization: req.headers.authorization } : {}
+        },
+        body: requestBody
+      });
+      responseStatus = response.status;
+      responseHeaders = response.headers;
+      responseText = await response.text();
+      const responseJson = tryParseJson(responseText);
+      captureTrackedHashes(methodById, responseJson, {
+        onInvoiceTracked: this.deps.onInvoiceTracked,
+        onPaymentTracked: this.deps.onPaymentTracked
+      });
+    } catch (error) {
+      writeJson(res, 502, { error: `Proxy request failed: ${String(error)}` });
+      return;
+    }
+    const contentType = responseHeaders.get("content-type") ?? "application/json";
+    res.writeHead(responseStatus, {
+      "content-type": contentType,
+      ...CORS_HEADERS
+    });
+    res.end(responseText);
+  }
+};
+
+// src/storage/memory-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+function nowMs() {
+  return Date.now();
+}
+function toRecord2(items) {
+  return Object.fromEntries(items.entries());
+}
+var MemoryStore = class {
+  config;
+  channelSnapshot = [];
+  peerSnapshot = [];
+  trackedInvoices = /* @__PURE__ */ new Map();
+  trackedPayments = /* @__PURE__ */ new Map();
+  alerts = [];
+  flushTimer;
+  constructor(config) {
+    this.config = config;
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.config.stateFilePath, "utf-8");
+      const state = JSON.parse(raw);
+      this.channelSnapshot = state.channels ?? [];
+      this.peerSnapshot = state.peers ?? [];
+      this.trackedInvoices = new Map(Object.entries(state.trackedInvoices ?? {}));
+      this.trackedPayments = new Map(Object.entries(state.trackedPayments ?? {}));
+      this.alerts = state.alerts ?? [];
+    } catch {
+      this.channelSnapshot = [];
+      this.peerSnapshot = [];
+      this.trackedInvoices.clear();
+      this.trackedPayments.clear();
+      this.alerts = [];
+    }
+  }
+  async flush() {
+    const state = {
+      channels: this.channelSnapshot,
+      peers: this.peerSnapshot,
+      trackedInvoices: toRecord2(this.trackedInvoices),
+      trackedPayments: toRecord2(this.trackedPayments),
+      alerts: this.alerts
+    };
+    await mkdir(dirname2(this.config.stateFilePath), { recursive: true });
+    await writeFile(this.config.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+  }
+  startAutoFlush() {
+    this.stopAutoFlush();
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, this.config.flushIntervalMs);
+  }
+  stopAutoFlush() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+  }
+  pruneCompleted(ttlMs) {
+    const now = nowMs();
+    for (const [hash, entry] of this.trackedInvoices.entries()) {
+      if (entry.completedAt && now - entry.completedAt >= ttlMs) {
+        this.trackedInvoices.delete(hash);
+      }
+    }
+    for (const [hash, entry] of this.trackedPayments.entries()) {
+      if (entry.completedAt && now - entry.completedAt >= ttlMs) {
+        this.trackedPayments.delete(hash);
+      }
+    }
+  }
+  getChannelSnapshot() {
+    return this.channelSnapshot;
+  }
+  setChannelSnapshot(channels) {
+    this.channelSnapshot = channels;
+  }
+  getPeerSnapshot() {
+    return this.peerSnapshot;
+  }
+  setPeerSnapshot(peers) {
+    this.peerSnapshot = peers;
+  }
+  addTrackedInvoice(hash, status = "Open") {
+    const existing = this.trackedInvoices.get(hash);
+    if (existing) return;
+    const now = nowMs();
+    this.trackedInvoices.set(hash, {
+      paymentHash: hash,
+      status,
+      trackedAt: now,
+      updatedAt: now
+    });
+  }
+  listTrackedInvoices() {
+    return [...this.trackedInvoices.values()];
+  }
+  getTrackedInvoice(hash) {
+    return this.trackedInvoices.get(hash);
+  }
+  updateTrackedInvoice(hash, status) {
+    const now = nowMs();
+    const existing = this.trackedInvoices.get(hash);
+    const next = existing ? {
+      ...existing,
+      status,
+      updatedAt: now,
+      completedAt: isTerminalInvoiceStatus(status) ? existing.completedAt ?? now : void 0
+    } : {
+      paymentHash: hash,
+      status,
+      trackedAt: now,
+      updatedAt: now,
+      completedAt: isTerminalInvoiceStatus(status) ? now : void 0
+    };
+    this.trackedInvoices.set(hash, next);
+  }
+  addTrackedPayment(hash, status = "Created") {
+    const existing = this.trackedPayments.get(hash);
+    if (existing) return;
+    const now = nowMs();
+    this.trackedPayments.set(hash, {
+      paymentHash: hash,
+      status,
+      trackedAt: now,
+      updatedAt: now
+    });
+  }
+  listTrackedPayments() {
+    return [...this.trackedPayments.values()];
+  }
+  getTrackedPayment(hash) {
+    return this.trackedPayments.get(hash);
+  }
+  updateTrackedPayment(hash, status) {
+    const now = nowMs();
+    const existing = this.trackedPayments.get(hash);
+    const next = existing ? {
+      ...existing,
+      status,
+      updatedAt: now,
+      completedAt: isTerminalPaymentStatus(status) ? existing.completedAt ?? now : void 0
+    } : {
+      paymentHash: hash,
+      status,
+      trackedAt: now,
+      updatedAt: now,
+      completedAt: isTerminalPaymentStatus(status) ? now : void 0
+    };
+    this.trackedPayments.set(hash, next);
+  }
+  addAlert(alert) {
+    this.alerts.push(alert);
+    if (this.alerts.length > this.config.maxAlertHistory) {
+      this.alerts.splice(0, this.alerts.length - this.config.maxAlertHistory);
+    }
+  }
+  listAlerts(filters) {
+    const minPriority = filters?.minPriority;
+    const type = filters?.type;
+    const source = filters?.source;
+    const limit = filters?.limit;
+    let alerts = this.alerts;
+    if (minPriority) {
+      const minRank = alertPriorityOrder[minPriority];
+      alerts = alerts.filter((alert) => alertPriorityOrder[alert.priority] >= minRank);
+    }
+    if (type) {
+      alerts = alerts.filter((alert) => alert.type === type);
+    }
+    if (source) {
+      alerts = alerts.filter((alert) => alert.source === source);
+    }
+    if (!limit || limit <= 0) {
+      return [...alerts];
+    }
+    return alerts.slice(-limit);
+  }
+};
+function isTerminalInvoiceStatus(status) {
+  return status === "Paid" || status === "Cancelled" || status === "Expired";
+}
+function isTerminalPaymentStatus(status) {
+  return status === "Success" || status === "Failed";
+}
+
+// src/storage/sqlite-store.ts
+import Database from "better-sqlite3";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+var MIGRATIONS = [
+  {
+    version: 1,
+    sql: `
+      CREATE TABLE IF NOT EXISTS jobs (
+        id                TEXT PRIMARY KEY,
+        type              TEXT NOT NULL,
+        state             TEXT NOT NULL,
+        params            TEXT NOT NULL,
+        result            TEXT,
+        error             TEXT,
+        retry_count       INTEGER NOT NULL DEFAULT 0,
+        max_retries       INTEGER NOT NULL DEFAULT 3,
+        next_retry_at     INTEGER,
+        idempotency_key   TEXT NOT NULL UNIQUE,
+        created_at        INTEGER NOT NULL,
+        updated_at        INTEGER NOT NULL,
+        completed_at      INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_state         ON jobs(state);
+      CREATE INDEX IF NOT EXISTS idx_jobs_type          ON jobs(type);
+      CREATE INDEX IF NOT EXISTS idx_jobs_next_retry_at ON jobs(next_retry_at);
+
+      CREATE TABLE IF NOT EXISTS job_events (
+        id          TEXT PRIMARY KEY,
+        job_id      TEXT NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        event_type  TEXT NOT NULL,
+        from_state  TEXT,
+        to_state    TEXT,
+        data        TEXT,
+        created_at  INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_job_events_job_id ON job_events(job_id);
+    `
+  }
+];
+var SqliteJobStore = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync2(dirname3(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.runMigrations();
+  }
+  // ─── Migrations ─────────────────────────────────────────────────────────────
+  runMigrations() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version    INTEGER PRIMARY KEY,
+        applied_at INTEGER NOT NULL
+      );
+    `);
+    const applied = new Set(
+      this.db.prepare("SELECT version FROM schema_migrations").all().map(
+        (r) => r.version
+      )
+    );
+    for (const migration of MIGRATIONS) {
+      if (!applied.has(migration.version)) {
+        this.db.transaction(() => {
+          this.db.exec(migration.sql);
+          this.db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)").run(
+            migration.version,
+            Date.now()
+          );
+        })();
+      }
+    }
+  }
+  // ─── Job CRUD ────────────────────────────────────────────────────────────────
+  createJob(job) {
+    const now = Date.now();
+    const full = {
+      ...job,
+      id: randomUUID2(),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.prepare(
+      `INSERT INTO jobs
+          (id, type, state, params, result, error, retry_count, max_retries,
+           next_retry_at, idempotency_key, created_at, updated_at, completed_at)
+         VALUES
+          (@id, @type, @state, @params, @result, @error, @retry_count, @max_retries,
+           @next_retry_at, @idempotency_key, @created_at, @updated_at, @completed_at)`
+    ).run({
+      id: full.id,
+      type: full.type,
+      state: full.state,
+      params: JSON.stringify(full.params),
+      result: full.result !== void 0 ? JSON.stringify(full.result) : null,
+      error: full.error !== void 0 ? JSON.stringify(full.error) : null,
+      retry_count: full.retryCount,
+      max_retries: full.maxRetries,
+      next_retry_at: full.nextRetryAt ?? null,
+      idempotency_key: full.idempotencyKey,
+      created_at: full.createdAt,
+      updated_at: full.updatedAt,
+      completed_at: full.completedAt ?? null
+    });
+    return full;
+  }
+  updateJob(id, updates) {
+    const existing = this.getJob(id);
+    if (!existing) throw new Error(`Job not found: ${id}`);
+    const now = Date.now();
+    const merged = { ...existing, ...updates, updatedAt: now };
+    this.db.prepare(
+      `UPDATE jobs SET
+          state         = @state,
+          params        = @params,
+          result        = @result,
+          error         = @error,
+          retry_count   = @retry_count,
+          next_retry_at = @next_retry_at,
+          updated_at    = @updated_at,
+          completed_at  = @completed_at
+         WHERE id = @id`
+    ).run({
+      id: merged.id,
+      state: merged.state,
+      params: JSON.stringify(merged.params),
+      result: merged.result !== void 0 ? JSON.stringify(merged.result) : null,
+      error: merged.error !== void 0 ? JSON.stringify(merged.error) : null,
+      retry_count: merged.retryCount,
+      next_retry_at: merged.nextRetryAt ?? null,
+      updated_at: merged.updatedAt,
+      completed_at: merged.completedAt ?? null
+    });
+    return merged;
+  }
+  getJob(id) {
+    const row = this.db.prepare("SELECT * FROM jobs WHERE id = ?").get(id);
+    return row ? this.rowToJob(row) : void 0;
+  }
+  getJobByIdempotencyKey(key) {
+    const row = this.db.prepare("SELECT * FROM jobs WHERE idempotency_key = ?").get(key);
+    return row ? this.rowToJob(row) : void 0;
+  }
+  listJobs(filter = {}) {
+    const conditions = [];
+    const params = {};
+    if (filter.type) {
+      conditions.push("type = @type");
+      params.type = filter.type;
+    }
+    if (filter.state) {
+      const states = Array.isArray(filter.state) ? filter.state : [filter.state];
+      const placeholders = states.map((_, i) => `@state_${i}`).join(", ");
+      conditions.push(`state IN (${placeholders})`);
+      for (const [i, s] of states.entries()) {
+        params[`state_${i}`] = s;
+      }
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter.limit ? `LIMIT @limit` : "";
+    const offset = filter.offset ? `OFFSET @offset` : "";
+    if (filter.limit) params.limit = filter.limit;
+    if (filter.offset) params.offset = filter.offset;
+    const rows = this.db.prepare(`SELECT * FROM jobs ${where} ORDER BY created_at DESC ${limit} ${offset}`).all(params);
+    return rows.map((r) => this.rowToJob(r));
+  }
+  deleteJob(id) {
+    this.db.prepare("DELETE FROM jobs WHERE id = ?").run(id);
+  }
+  /** Return jobs that are ready to be retried right now. */
+  getRetryableJobs(now = Date.now()) {
+    const rows = this.db.prepare(
+      `SELECT * FROM jobs
+         WHERE state = 'waiting_retry' AND next_retry_at <= @now
+         ORDER BY next_retry_at ASC`
+    ).all({ now });
+    return rows.map((r) => this.rowToJob(r));
+  }
+  /** Return jobs in non-terminal states (for recovery after daemon restart). */
+  getInProgressJobs() {
+    const rows = this.db.prepare(
+      `SELECT * FROM jobs
+         WHERE state IN (
+           'queued',
+           'executing',
+           'inflight',
+           'waiting_retry',
+           'invoice_created',
+           'invoice_active',
+           'invoice_received',
+           'channel_opening',
+           'channel_accepting',
+           'channel_abandoning',
+           'channel_updating',
+           'channel_awaiting_ready',
+           'channel_closing'
+         )
+         ORDER BY created_at ASC`
+    ).all();
+    return rows.map((r) => this.rowToJob(r));
+  }
+  // ─── Job Events ──────────────────────────────────────────────────────────────
+  addJobEvent(jobId, eventType, fromState, toState, data) {
+    const event = {
+      id: randomUUID2(),
+      jobId,
+      eventType,
+      fromState,
+      toState,
+      data,
+      createdAt: Date.now()
+    };
+    this.db.prepare(
+      `INSERT INTO job_events (id, job_id, event_type, from_state, to_state, data, created_at)
+         VALUES (@id, @job_id, @event_type, @from_state, @to_state, @data, @created_at)`
+    ).run({
+      id: event.id,
+      job_id: event.jobId,
+      event_type: event.eventType,
+      from_state: event.fromState ?? null,
+      to_state: event.toState ?? null,
+      data: event.data !== void 0 ? JSON.stringify(event.data) : null,
+      created_at: event.createdAt
+    });
+    return event;
+  }
+  listJobEvents(jobId) {
+    const rows = this.db.prepare("SELECT * FROM job_events WHERE job_id = ? ORDER BY created_at ASC").all(jobId);
+    return rows.map((r) => ({
+      id: r.id,
+      jobId: r.job_id,
+      eventType: r.event_type,
+      fromState: r.from_state ?? void 0,
+      toState: r.to_state ?? void 0,
+      data: r.data ? JSON.parse(r.data) : void 0,
+      createdAt: r.created_at
+    }));
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────────────
+  close() {
+    this.db.close();
+  }
+  // ─── Private Helpers ─────────────────────────────────────────────────────────
+  rowToJob(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      state: row.state,
+      params: JSON.parse(row.params),
+      result: row.result ? JSON.parse(row.result) : void 0,
+      error: row.error ? JSON.parse(row.error) : void 0,
+      retryCount: row.retry_count,
+      maxRetries: row.max_retries,
+      nextRetryAt: row.next_retry_at ?? void 0,
+      idempotencyKey: row.idempotency_key,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      completedAt: row.completed_at ?? void 0
+    };
+  }
+};
+
+// src/jobs/job-manager.ts
+import { EventEmitter } from "events";
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/jobs/types.ts
+var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+
+// src/jobs/error-classifier.ts
+var PATTERNS = [
+  // Routing / topology
+  { pattern: /no path found|no route|route not found/i, category: "no_route", retryable: true },
+  { pattern: /no outgoing channel|no available channel/i, category: "no_route", retryable: true },
+  // Liquidity
+  { pattern: /insufficient (balance|capacity|funds)/i, category: "insufficient_balance", retryable: false },
+  { pattern: /amount.*too large|exceeds.*capacity/i, category: "amount_too_large", retryable: false },
+  // Invoice lifecycle
+  { pattern: /invoice.*expir|expir.*invoice/i, category: "invoice_expired", retryable: false },
+  { pattern: /invoice.*cancel|cancel.*invoice/i, category: "invoice_cancelled", retryable: false },
+  { pattern: /payment hash.*exist|payment_hash.*exist|duplicated payment hash/i, category: "invalid_payment", retryable: false },
+  // Peer / connectivity
+  { pattern: /peer.*offline|peer.*unreachable|peer.*disconnect/i, category: "peer_offline", retryable: true },
+  { pattern: /connection.*refused|connection.*reset/i, category: "peer_offline", retryable: true },
+  { pattern: /peer.*feature not found|waiting for peer to send init message/i, category: "peer_offline", retryable: true },
+  { pattern: /channel.*already.*exist|duplicat(e|ed).*channel/i, category: "temporary_failure", retryable: true },
+  // Timeout
+  { pattern: /timeout|timed out/i, category: "timeout", retryable: true },
+  // Payment validity
+  { pattern: /invalid.*invoice|malformed.*invoice/i, category: "invalid_payment", retryable: false },
+  { pattern: /payment.*hash.*mismatch|preimage.*invalid/i, category: "invalid_payment", retryable: false },
+  // Generic temporary
+  { pattern: /temporary.*failure|try again|retry/i, category: "temporary_failure", retryable: true }
+];
+function classifyRpcError(error, failedError) {
+  const raw = failedError ?? (error instanceof Error ? error.message : String(error));
+  for (const { pattern, category, retryable } of PATTERNS) {
+    if (pattern.test(raw)) {
+      return { category, retryable, message: raw, rawError: raw };
+    }
+  }
+  return {
+    category: "unknown",
+    retryable: false,
+    // safe default: don't retry unknowns
+    message: raw,
+    rawError: raw
+  };
+}
+
+// src/jobs/state-machine.ts
+var PAYMENT_TRANSITIONS = [
+  { from: "queued", event: "send_issued", to: "executing" },
+  { from: "executing", event: "payment_inflight", to: "inflight" },
+  { from: "executing", event: "payment_success", to: "succeeded" },
+  { from: "executing", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "executing", event: "payment_failed_permanent", to: "failed" },
+  { from: "inflight", event: "payment_success", to: "succeeded" },
+  { from: "inflight", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "inflight", event: "payment_failed_permanent", to: "failed" },
+  { from: "waiting_retry", event: "retry_delay_elapsed", to: "executing" },
+  {
+    from: ["queued", "executing", "inflight", "waiting_retry"],
+    event: "cancel",
+    to: "cancelled"
+  }
+];
+var INVOICE_TRANSITIONS = [
+  { from: "queued", event: "send_issued", to: "executing" },
+  { from: "executing", event: "invoice_created", to: "invoice_created" },
+  { from: "invoice_created", event: "payment_success", to: "succeeded" },
+  { from: "executing", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "invoice_created", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "invoice_active", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "invoice_received", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "waiting_retry", event: "retry_delay_elapsed", to: "executing" },
+  { from: "invoice_created", event: "invoice_received", to: "invoice_received" },
+  { from: "invoice_created", event: "invoice_settled", to: "invoice_settled" },
+  { from: "invoice_active", event: "invoice_received", to: "invoice_received" },
+  { from: "invoice_active", event: "invoice_settled", to: "invoice_settled" },
+  { from: "invoice_active", event: "invoice_expired", to: "invoice_expired" },
+  { from: "invoice_active", event: "invoice_cancelled", to: "invoice_cancelled" },
+  { from: "invoice_received", event: "invoice_settled", to: "invoice_settled" },
+  { from: ["invoice_created", "invoice_received"], event: "invoice_expired", to: "invoice_expired" },
+  { from: ["invoice_created", "invoice_received"], event: "invoice_cancelled", to: "invoice_cancelled" },
+  { from: ["invoice_settled", "invoice_expired", "invoice_cancelled"], event: "payment_success", to: "succeeded" },
+  { from: ["invoice_expired", "invoice_cancelled"], event: "payment_failed_permanent", to: "failed" },
+  { from: ["executing", "invoice_created", "invoice_active", "invoice_received"], event: "payment_failed_permanent", to: "failed" },
+  {
+    from: ["queued", "executing", "waiting_retry", "invoice_created", "invoice_active", "invoice_received"],
+    event: "cancel",
+    to: "cancelled"
+  }
+];
+var CHANNEL_TRANSITIONS = [
+  { from: "queued", event: "send_issued", to: "executing" },
+  { from: "executing", event: "channel_opening", to: "channel_opening" },
+  { from: "executing", event: "channel_accepting", to: "channel_accepting" },
+  { from: "executing", event: "channel_abandoning", to: "channel_abandoning" },
+  { from: "executing", event: "channel_updating", to: "channel_updating" },
+  { from: "channel_opening", event: "payment_success", to: "succeeded" },
+  { from: "channel_accepting", event: "payment_success", to: "succeeded" },
+  { from: "channel_abandoning", event: "payment_success", to: "succeeded" },
+  { from: "channel_updating", event: "payment_success", to: "succeeded" },
+  { from: "executing", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_opening", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_accepting", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_abandoning", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_updating", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_awaiting_ready", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "channel_closing", event: "payment_failed_retryable", to: "waiting_retry" },
+  { from: "executing", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_opening", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_accepting", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_abandoning", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_updating", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_awaiting_ready", event: "payment_failed_permanent", to: "failed" },
+  { from: "channel_closing", event: "payment_failed_permanent", to: "failed" },
+  { from: ["executing", "channel_ready"], event: "channel_closing", to: "channel_closing" },
+  { from: "waiting_retry", event: "retry_delay_elapsed", to: "executing" },
+  { from: "channel_opening", event: "channel_opening", to: "channel_awaiting_ready" },
+  { from: "channel_awaiting_ready", event: "channel_opening", to: "channel_awaiting_ready" },
+  { from: "channel_opening", event: "channel_ready", to: "channel_ready" },
+  { from: "channel_awaiting_ready", event: "channel_ready", to: "channel_ready" },
+  { from: ["channel_opening", "channel_ready"], event: "channel_closed", to: "channel_closed" },
+  { from: "channel_awaiting_ready", event: "channel_closed", to: "channel_closed" },
+  { from: "channel_closing", event: "channel_closed", to: "channel_closed" },
+  { from: "channel_closing", event: "payment_success", to: "succeeded" },
+  { from: "channel_closed", event: "payment_failed_permanent", to: "failed" },
+  { from: ["channel_ready", "channel_opening"], event: "channel_failed", to: "failed" },
+  { from: ["channel_ready", "channel_closed"], event: "payment_success", to: "succeeded" },
+  {
+    from: ["queued", "executing", "waiting_retry", "channel_opening", "channel_accepting", "channel_abandoning", "channel_updating", "channel_awaiting_ready", "channel_ready", "channel_closing"],
+    event: "cancel",
+    to: "cancelled"
+  }
+];
+var JobStateMachine = class {
+  table;
+  constructor(transitions) {
+    this.table = /* @__PURE__ */ new Map();
+    for (const t of transitions) {
+      const froms = Array.isArray(t.from) ? t.from : [t.from];
+      for (const from of froms) {
+        this.table.set(`${from}:${t.event}`, t.to);
+      }
+    }
+  }
+  transition(current, event) {
+    return this.table.get(`${current}:${event}`) ?? null;
+  }
+  isTerminal(state) {
+    return state === "succeeded" || state === "failed" || state === "cancelled";
+  }
+};
+var paymentStateMachine = new JobStateMachine(PAYMENT_TRANSITIONS);
+var invoiceStateMachine = new JobStateMachine(INVOICE_TRANSITIONS);
+var channelStateMachine = new JobStateMachine(CHANNEL_TRANSITIONS);
+
+// src/jobs/executor-utils.ts
+function transitionJobState(job, machine, event, options) {
+  const nextState = machine.transition(job.state, event);
+  if (!nextState) {
+    throw new Error(`Invalid state transition: ${job.state} --${event}--> ?`);
+  }
+  const now = options?.now ?? Date.now();
+  return {
+    ...job,
+    ...options?.patch ?? {},
+    state: nextState,
+    updatedAt: now,
+    completedAt: machine.isTerminal(nextState) ? now : job.completedAt
+  };
+}
+function applyRetryOrFail(job, classifiedError, policy, options) {
+  const now = options?.now ?? Date.now();
+  if (shouldRetry(classifiedError, job.retryCount, policy)) {
+    const delay = computeRetryDelay(job.retryCount, policy);
+    const retryTransition = options?.machine && options.retryEvent ? transitionJobState(job, options.machine, options.retryEvent, { now }) : { ...job, state: "waiting_retry", updatedAt: now };
+    return {
+      ...retryTransition,
+      error: classifiedError,
+      retryCount: job.retryCount + 1,
+      nextRetryAt: now + delay
+    };
+  }
+  const failTransition = options?.machine && options.failEvent ? transitionJobState(job, options.machine, options.failEvent, { now }) : { ...job, state: "failed", completedAt: now, updatedAt: now };
+  return {
+    ...failTransition,
+    error: classifiedError,
+    ...options?.failedPatch ?? {}
+  };
+}
+
+// src/jobs/executors/payment-executor.ts
+async function* runPaymentJob(job, rpc, policy, signal) {
+  let current = { ...job };
+  while (!paymentStateMachine.isTerminal(current.state)) {
+    if (signal.aborted) {
+      current = transitionJobState(current, paymentStateMachine, "cancel");
+      yield current;
+      return;
+    }
+    if (current.state === "queued") {
+      current = transitionJobState(current, paymentStateMachine, "send_issued");
+      yield current;
+      continue;
+    }
+    if (current.state === "waiting_retry") {
+      const delay = current.nextRetryAt ? Math.max(0, current.nextRetryAt - Date.now()) : 0;
+      if (delay > 0) {
+        await sleep(delay, signal);
+        if (signal.aborted) {
+          current = transitionJobState(current, paymentStateMachine, "cancel");
+          yield current;
+          return;
+        }
+      }
+      current = transitionJobState(current, paymentStateMachine, "retry_delay_elapsed", {
+        patch: { nextRetryAt: void 0 }
+      });
+      yield current;
+      continue;
+    }
+    if (current.state === "executing") {
+      let paymentHash;
+      try {
+        const sendResult = await rpc.sendPayment(current.params.sendPaymentParams);
+        paymentHash = sendResult.payment_hash;
+        if (sendResult.status === "Success") {
+          current = transitionJobState(current, paymentStateMachine, "payment_success", {
+            patch: {
+              result: {
+                paymentHash: sendResult.payment_hash,
+                status: sendResult.status,
+                fee: sendResult.fee,
+                failedError: sendResult.failed_error
+              }
+            }
+          });
+          yield current;
+          return;
+        }
+        if (sendResult.status === "Failed") {
+          const classified = classifyRpcError(
+            new Error(sendResult.failed_error ?? "Payment failed"),
+            sendResult.failed_error
+          );
+          current = applyRetryOrFail(current, classified, policy, {
+            failedPatch: {
+              result: {
+                paymentHash: sendResult.payment_hash,
+                status: sendResult.status,
+                fee: sendResult.fee,
+                failedError: sendResult.failed_error
+              }
+            },
+            machine: paymentStateMachine,
+            retryEvent: "payment_failed_retryable",
+            failEvent: "payment_failed_permanent"
+          });
+          yield current;
+          continue;
+        }
+        current = transitionJobState(current, paymentStateMachine, "payment_inflight");
+        if (paymentHash) {
+          current = { ...current, params: { ...current.params, sendPaymentParams: { ...current.params.sendPaymentParams, payment_hash: paymentHash } } };
+        }
+        yield current;
+        continue;
+      } catch (err) {
+        const classified = classifyRpcError(err);
+        current = applyRetryOrFail(current, classified, policy, {
+          machine: paymentStateMachine,
+          retryEvent: "payment_failed_retryable",
+          failEvent: "payment_failed_permanent"
+        });
+        yield current;
+        continue;
+      }
+    }
+    if (current.state === "inflight") {
+      const hash = current.params.sendPaymentParams.payment_hash;
+      if (!hash) {
+        current = transitionJobState(current, paymentStateMachine, "payment_failed_permanent", {
+          patch: {
+            error: { category: "unknown", retryable: false, message: "No payment_hash in inflight job" }
+          }
+        });
+        yield current;
+        continue;
+      }
+      try {
+        const pollResult = await rpc.getPayment({ payment_hash: hash });
+        if (pollResult.status === "Success") {
+          current = transitionJobState(current, paymentStateMachine, "payment_success", {
+            patch: {
+              result: {
+                paymentHash: pollResult.payment_hash,
+                status: pollResult.status,
+                fee: pollResult.fee,
+                failedError: pollResult.failed_error
+              }
+            }
+          });
+          yield current;
+          return;
+        }
+        if (pollResult.status === "Failed") {
+          const classified = classifyRpcError(
+            new Error(pollResult.failed_error ?? "Payment failed"),
+            pollResult.failed_error
+          );
+          current = applyRetryOrFail(current, classified, policy, {
+            failedPatch: {
+              result: {
+                paymentHash: pollResult.payment_hash,
+                status: pollResult.status,
+                fee: pollResult.fee,
+                failedError: pollResult.failed_error
+              }
+            },
+            machine: paymentStateMachine,
+            retryEvent: "payment_failed_retryable",
+            failEvent: "payment_failed_permanent"
+          });
+          yield current;
+          continue;
+        }
+        await sleep(POLL_INTERVAL_MS, signal);
+        if (signal.aborted) {
+          current = transitionJobState(current, paymentStateMachine, "cancel");
+          yield current;
+          return;
+        }
+        current = { ...current, updatedAt: Date.now() };
+        continue;
+      } catch (err) {
+        const classified = classifyRpcError(err);
+        current = applyRetryOrFail(current, classified, policy, {
+          machine: paymentStateMachine,
+          retryEvent: "payment_failed_retryable",
+          failEvent: "payment_failed_permanent"
+        });
+        yield current;
+        continue;
+      }
+    }
+    break;
+  }
+}
+var POLL_INTERVAL_MS = 1500;
+
+// src/jobs/executors/invoice-executor.ts
+var DEFAULT_POLL_INTERVAL = 1500;
+async function* runInvoiceJob(job, rpc, policy, signal) {
+  let current = { ...job };
+  if (current.state === "queued") {
+    current = transitionJobState(current, invoiceStateMachine, "send_issued");
+    yield current;
+  }
+  if (current.state === "waiting_retry") {
+    current = transitionJobState(current, invoiceStateMachine, "retry_delay_elapsed", {
+      patch: { nextRetryAt: void 0 }
+    });
+    yield current;
+  }
+  try {
+    const pollIntervalMs = current.params.pollIntervalMs ?? DEFAULT_POLL_INTERVAL;
+    if (current.params.action === "create") {
+      if (!current.params.newInvoiceParams) {
+        throw new Error("Invoice create job requires newInvoiceParams");
+      }
+      const created = await rpc.newInvoice(current.params.newInvoiceParams);
+      const paymentHash = created.invoice.data.payment_hash;
+      const createdStatus = "Open";
+      current = {
+        ...current,
+        state: "invoice_created",
+        result: {
+          paymentHash,
+          invoiceAddress: created.invoice_address,
+          status: createdStatus,
+          invoice: created.invoice
+        },
+        updatedAt: Date.now()
+      };
+      yield current;
+      if (!current.params.waitForTerminal) {
+        current = transitionJobState(current, invoiceStateMachine, "payment_success");
+        yield current;
+        return;
+      }
+      while (true) {
+        if (signal.aborted) {
+          current = transitionJobState(current, invoiceStateMachine, "cancel");
+          yield current;
+          return;
+        }
+        const invoice = await rpc.getInvoice({ payment_hash: paymentHash });
+        if (invoice.status === "Paid") {
+          current = {
+            ...current,
+            state: "invoice_settled",
+            result: {
+              paymentHash,
+              invoiceAddress: invoice.invoice_address,
+              status: invoice.status,
+              invoice: invoice.invoice
+            },
+            updatedAt: Date.now()
+          };
+          yield current;
+          current = transitionJobState(current, invoiceStateMachine, "payment_success");
+          yield current;
+          return;
+        }
+        if (invoice.status === "Received") {
+          current = {
+            ...current,
+            state: "invoice_received",
+            result: {
+              paymentHash,
+              invoiceAddress: invoice.invoice_address,
+              status: invoice.status,
+              invoice: invoice.invoice
+            },
+            updatedAt: Date.now()
+          };
+          yield current;
+        } else if (invoice.status === "Cancelled") {
+          current = {
+            ...current,
+            state: "invoice_cancelled",
+            result: {
+              paymentHash,
+              invoiceAddress: invoice.invoice_address,
+              status: invoice.status,
+              invoice: invoice.invoice
+            },
+            completedAt: Date.now(),
+            updatedAt: Date.now()
+          };
+          yield current;
+          current = transitionJobState(current, invoiceStateMachine, "payment_failed_permanent");
+          yield current;
+          return;
+        } else if (invoice.status === "Expired") {
+          current = {
+            ...current,
+            state: "invoice_expired",
+            result: {
+              paymentHash,
+              invoiceAddress: invoice.invoice_address,
+              status: invoice.status,
+              invoice: invoice.invoice
+            },
+            completedAt: Date.now(),
+            updatedAt: Date.now()
+          };
+          yield current;
+          current = transitionJobState(current, invoiceStateMachine, "payment_failed_permanent");
+          yield current;
+          return;
+        }
+        await sleep(pollIntervalMs, signal);
+      }
+    }
+    if (current.params.action === "watch") {
+      if (!current.params.getInvoicePaymentHash) {
+        throw new Error("Invoice watch job requires getInvoicePaymentHash");
+      }
+      const paymentHash = current.params.getInvoicePaymentHash;
+      while (true) {
+        if (signal.aborted) {
+          current = transitionJobState(current, invoiceStateMachine, "cancel");
+          yield current;
+          return;
+        }
+        const invoice = await rpc.getInvoice({ payment_hash: paymentHash });
+        current = {
+          ...current,
+          state: invoice.status === "Paid" ? "invoice_settled" : invoice.status === "Received" ? "invoice_received" : invoice.status === "Cancelled" ? "invoice_cancelled" : invoice.status === "Expired" ? "invoice_expired" : "invoice_active",
+          result: {
+            paymentHash,
+            invoiceAddress: invoice.invoice_address,
+            status: invoice.status,
+            invoice: invoice.invoice
+          },
+          updatedAt: Date.now()
+        };
+        yield current;
+        if (invoice.status === "Paid") {
+          current = transitionJobState(current, invoiceStateMachine, "payment_success");
+          yield current;
+          return;
+        }
+        if (invoice.status === "Cancelled" || invoice.status === "Expired") {
+          current = transitionJobState(current, invoiceStateMachine, "payment_failed_permanent");
+          yield current;
+          return;
+        }
+        await sleep(pollIntervalMs, signal);
+      }
+    }
+    if (current.params.action === "cancel") {
+      if (!current.params.cancelInvoiceParams) {
+        throw new Error("Invoice cancel job requires cancelInvoiceParams");
+      }
+      const cancelled = await rpc.cancelInvoice(current.params.cancelInvoiceParams);
+      current = {
+        ...current,
+        state: "invoice_cancelled",
+        result: {
+          paymentHash: current.params.cancelInvoiceParams.payment_hash,
+          invoiceAddress: cancelled.invoice_address,
+          status: cancelled.status,
+          invoice: cancelled.invoice
+        },
+        updatedAt: Date.now()
+      };
+      yield current;
+      current = transitionJobState(current, invoiceStateMachine, "payment_success");
+      yield current;
+      return;
+    }
+    if (current.params.action === "settle") {
+      if (!current.params.settleInvoiceParams) {
+        throw new Error("Invoice settle job requires settleInvoiceParams");
+      }
+      await rpc.settleInvoice(current.params.settleInvoiceParams);
+      current = {
+        ...current,
+        state: "invoice_settled",
+        result: {
+          paymentHash: current.params.settleInvoiceParams.payment_hash,
+          status: "Paid"
+        },
+        updatedAt: Date.now()
+      };
+      yield current;
+      current = transitionJobState(current, invoiceStateMachine, "payment_success");
+      yield current;
+      return;
+    }
+    throw new Error(`Unsupported invoice action: ${current.params.action}`);
+  } catch (error) {
+    const classified = classifyRpcError(error);
+    current = applyRetryOrFail(current, classified, policy, {
+      machine: invoiceStateMachine,
+      retryEvent: "payment_failed_retryable",
+      failEvent: "payment_failed_permanent"
+    });
+    yield current;
+  }
+}
+
+// src/jobs/executors/channel-executor.ts
+import { ChannelState as ChannelState2 } from "@fiber-pay/sdk";
+var DEFAULT_POLL_INTERVAL2 = 2e3;
+async function* runChannelJob(job, rpc, policy, signal) {
+  let current = { ...job };
+  const resumedFromRetry = job.state === "waiting_retry";
+  if (current.state === "queued") {
+    current = transitionJobState(current, channelStateMachine, "send_issued");
+    yield current;
+  }
+  if (current.state === "waiting_retry") {
+    current = transitionJobState(current, channelStateMachine, "retry_delay_elapsed", {
+      patch: { nextRetryAt: void 0 }
+    });
+    yield current;
+  }
+  try {
+    const pollIntervalMs = current.params.pollIntervalMs ?? DEFAULT_POLL_INTERVAL2;
+    if (current.params.action === "open") {
+      if (!current.params.openChannelParams) {
+        throw new Error("Channel open job requires openChannelParams");
+      }
+      const targetPeerId = current.params.peerId ?? current.params.openChannelParams.peer_id;
+      let temporaryChannelId = current.result?.temporaryChannelId;
+      if (resumedFromRetry) {
+        const existing = await findTargetChannel(rpc, targetPeerId, current.params.channelId);
+        if (existing && !isClosed(existing.state.state_name)) {
+          current = transitionJobState(current, channelStateMachine, "channel_opening", {
+            patch: {
+              result: {
+                temporaryChannelId,
+                channelId: existing.channel_id,
+                state: existing.state.state_name
+              }
+            }
+          });
+          yield current;
+        } else {
+          const opened = await rpc.openChannel(current.params.openChannelParams);
+          temporaryChannelId = opened.temporary_channel_id;
+          current = transitionJobState(current, channelStateMachine, "channel_opening", {
+            patch: {
+              result: {
+                temporaryChannelId,
+                state: "OPENING"
+              }
+            }
+          });
+          yield current;
+        }
+      } else {
+        const opened = await rpc.openChannel(current.params.openChannelParams);
+        temporaryChannelId = opened.temporary_channel_id;
+        current = transitionJobState(current, channelStateMachine, "channel_opening", {
+          patch: {
+            result: {
+              temporaryChannelId,
+              state: "OPENING"
+            }
+          }
+        });
+        yield current;
+      }
+      if (!current.params.waitForReady) {
+        current = transitionJobState(current, channelStateMachine, "payment_success");
+        yield current;
+        return;
+      }
+      while (true) {
+        if (signal.aborted) {
+          current = transitionJobState(current, channelStateMachine, "cancel");
+          yield current;
+          return;
+        }
+        const channels = await rpc.listChannels({
+          peer_id: targetPeerId,
+          include_closed: true
+        });
+        const candidates = channels.channels.filter((channel) => {
+          if (current.params.channelId && channel.channel_id !== current.params.channelId) return false;
+          return channel.peer_id === targetPeerId;
+        });
+        const readyMatch = candidates.find(
+          (channel) => String(channel.state.state_name).toUpperCase() === "CHANNEL_READY"
+        );
+        const activeMatch = candidates.find((channel) => !isClosed(channel.state.state_name));
+        const closedMatch = current.params.channelId && !activeMatch && candidates.length > 0 ? candidates.find((channel) => isTerminalClosed(channel.state.state_name)) : void 0;
+        if (readyMatch) {
+          current = transitionJobState(current, channelStateMachine, "channel_ready", {
+            patch: {
+              result: {
+                temporaryChannelId,
+                channelId: readyMatch.channel_id,
+                state: readyMatch.state.state_name
+              }
+            }
+          });
+          yield current;
+          current = transitionJobState(current, channelStateMachine, "payment_success");
+          yield current;
+          return;
+        }
+        if (closedMatch) {
+          current = transitionJobState(current, channelStateMachine, "channel_closed", {
+            patch: {
+              result: {
+                temporaryChannelId,
+                channelId: closedMatch.channel_id,
+                state: closedMatch.state.state_name
+              }
+            }
+          });
+          yield current;
+          current = transitionJobState(current, channelStateMachine, "payment_failed_permanent");
+          yield current;
+          return;
+        }
+        current = transitionJobState(current, channelStateMachine, "channel_opening");
+        yield current;
+        await sleep(pollIntervalMs, signal);
+      }
+    }
+    if (current.params.action === "shutdown") {
+      const shutdownParams = current.params.shutdownChannelParams;
+      if (!shutdownParams) {
+        throw new Error("Channel shutdown job requires shutdownChannelParams");
+      }
+      await rpc.shutdownChannel(shutdownParams);
+      current = transitionJobState(current, channelStateMachine, "channel_closing", {
+        patch: {
+          result: {
+            channelId: shutdownParams.channel_id,
+            state: "SHUTTING_DOWN"
+          }
+        }
+      });
+      yield current;
+      if (!current.params.waitForClosed) {
+        current = transitionJobState(current, channelStateMachine, "payment_success");
+        yield current;
+        return;
+      }
+      while (true) {
+        if (signal.aborted) {
+          current = transitionJobState(current, channelStateMachine, "cancel");
+          yield current;
+          return;
+        }
+        const channels = await rpc.listChannels({ include_closed: true });
+        const match = channels.channels.find((channel) => channel.channel_id === shutdownParams.channel_id);
+        if (!match || isTerminalClosed(String(match.state.state_name))) {
+          current = transitionJobState(current, channelStateMachine, "channel_closed", {
+            patch: {
+              result: {
+                channelId: shutdownParams.channel_id,
+                state: "CLOSED"
+              }
+            }
+          });
+          yield current;
+          current = transitionJobState(current, channelStateMachine, "payment_success");
+          yield current;
+          return;
+        }
+        await sleep(pollIntervalMs, signal);
+      }
+    }
+    if (current.params.action === "accept") {
+      if (!current.params.acceptChannelParams) {
+        throw new Error("Channel accept job requires acceptChannelParams");
+      }
+      const accepted = await rpc.acceptChannel(current.params.acceptChannelParams);
+      current = transitionJobState(current, channelStateMachine, "channel_accepting", {
+        patch: {
+          result: {
+            acceptedChannelId: accepted.channel_id,
+            channelId: accepted.channel_id,
+            state: "ACCEPTED"
+          }
+        }
+      });
+      yield current;
+      current = transitionJobState(current, channelStateMachine, "payment_success");
+      yield current;
+      return;
+    }
+    if (current.params.action === "abandon") {
+      if (!current.params.abandonChannelParams) {
+        throw new Error("Channel abandon job requires abandonChannelParams");
+      }
+      await rpc.abandonChannel(current.params.abandonChannelParams);
+      current = transitionJobState(current, channelStateMachine, "channel_abandoning", {
+        patch: {
+          result: {
+            channelId: current.params.abandonChannelParams.channel_id,
+            state: "ABANDONED"
+          }
+        }
+      });
+      yield current;
+      current = transitionJobState(current, channelStateMachine, "payment_success");
+      yield current;
+      return;
+    }
+    if (current.params.action === "update") {
+      if (!current.params.updateChannelParams) {
+        throw new Error("Channel update job requires updateChannelParams");
+      }
+      await rpc.updateChannel(current.params.updateChannelParams);
+      current = transitionJobState(current, channelStateMachine, "channel_updating", {
+        patch: {
+          result: {
+            channelId: current.params.updateChannelParams.channel_id,
+            state: "UPDATED"
+          }
+        }
+      });
+      yield current;
+      current = transitionJobState(current, channelStateMachine, "payment_success");
+      yield current;
+      return;
+    }
+    throw new Error(`Unsupported channel action: ${current.params.action}`);
+  } catch (error) {
+    const classified = classifyRpcError(error);
+    current = applyRetryOrFail(current, classified, policy, {
+      machine: channelStateMachine,
+      retryEvent: "payment_failed_retryable",
+      failEvent: "payment_failed_permanent"
+    });
+    yield current;
+  }
+}
+async function findTargetChannel(rpc, peerId, channelId) {
+  const channels = await rpc.listChannels({
+    peer_id: peerId,
+    include_closed: true
+  });
+  return channels.channels.find((channel) => {
+    if (channelId && channel.channel_id !== channelId) return false;
+    return channel.peer_id === peerId;
+  });
+}
+function isClosed(stateName) {
+  return stateName === ChannelState2.Closed || stateName === "CLOSED" || stateName === ChannelState2.ShuttingDown || stateName === "SHUTTING_DOWN";
+}
+function isTerminalClosed(stateName) {
+  return stateName === ChannelState2.Closed || stateName === "CLOSED";
+}
+
+// src/jobs/job-manager.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`);
+  return `{${entries.join(",")}}`;
+}
+function haveSameParams(left, right) {
+  return stableStringify(left) === stableStringify(right);
+}
+var JobManager = class extends EventEmitter {
+  rpc;
+  store;
+  retryPolicy;
+  schedulerIntervalMs;
+  maxConcurrentJobs;
+  running = false;
+  schedulerTimer;
+  active = /* @__PURE__ */ new Map();
+  constructor(rpc, store, config = {}) {
+    super();
+    this.rpc = rpc;
+    this.store = store;
+    this.retryPolicy = config.retryPolicy ?? defaultPaymentRetryPolicy;
+    this.schedulerIntervalMs = config.schedulerIntervalMs ?? 500;
+    this.maxConcurrentJobs = config.maxConcurrentJobs ?? 5;
+  }
+  async ensurePayment(params, options = {}) {
+    const idempotencyKey = options.idempotencyKey ?? params.sendPaymentParams.payment_hash ?? randomUUID3();
+    const existing = this.store.getJobByIdempotencyKey(idempotencyKey);
+    if (existing?.type === "payment") {
+      if (!haveSameParams(existing.params, params)) {
+        throw new Error(
+          `Idempotency key collision with different payment params: ${idempotencyKey}. Use a new idempotency key for a new payment intent.`
+        );
+      }
+      if (existing.state === "succeeded" || existing.state === "cancelled") {
+        return existing;
+      }
+      if (!TERMINAL_JOB_STATES.has(existing.state) || existing.state === "failed") {
+        if (existing.state === "failed" && !this.active.has(existing.id)) {
+          const reset = this.store.updateJob(existing.id, {
+            state: "queued",
+            params,
+            result: void 0,
+            error: void 0,
+            retryCount: 0,
+            nextRetryAt: void 0,
+            completedAt: void 0
+          });
+          this.schedule(reset);
+          return reset;
+        }
+        return existing;
+      }
+    }
+    const job = this.store.createJob({
+      type: "payment",
+      state: "queued",
+      params,
+      retryCount: 0,
+      maxRetries: options.maxRetries ?? this.retryPolicy.maxRetries,
+      idempotencyKey
+    });
+    this.store.addJobEvent(job.id, "created", void 0, "queued", this.buildEventData(job));
+    this.emit("job:created", job);
+    this.schedule(job);
+    return job;
+  }
+  async manageInvoice(params, options = {}) {
+    const idempotencyKey = options.idempotencyKey ?? deriveInvoiceKey(params) ?? randomUUID3();
+    return this.createOrReuseJob("invoice", params, idempotencyKey, options.maxRetries, options.reuseTerminal);
+  }
+  async manageChannel(params, options = {}) {
+    const idempotencyKey = options.idempotencyKey ?? deriveChannelKey(params) ?? randomUUID3();
+    return this.createOrReuseJob("channel", params, idempotencyKey, options.maxRetries, options.reuseTerminal);
+  }
+  getJob(id) {
+    return this.store.getJob(id);
+  }
+  listJobs(filter = {}) {
+    return this.store.listJobs(filter);
+  }
+  cancelJob(id) {
+    const job = this.getJob(id);
+    if (!job) throw new Error(`Job not found: ${id}`);
+    if (TERMINAL_JOB_STATES.has(job.state)) return;
+    this.active.get(id)?.abortController.abort();
+    if (!this.active.has(id)) {
+      const updated = this.store.updateJob(id, {
+        state: "cancelled",
+        completedAt: Date.now()
+      });
+      this.store.addJobEvent(id, "cancelled", job.state, "cancelled", this.buildEventData(updated));
+      this.emit("job:cancelled", updated);
+    }
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.recover();
+    this.schedulerTimer = setInterval(() => this.tick(), this.schedulerIntervalMs);
+  }
+  async stop() {
+    this.running = false;
+    if (this.schedulerTimer) {
+      clearInterval(this.schedulerTimer);
+      this.schedulerTimer = void 0;
+    }
+    for (const [, exec] of this.active) {
+      exec.abortController.abort();
+    }
+    await Promise.allSettled(Array.from(this.active.values()).map((e) => e.promise));
+  }
+  async createOrReuseJob(type, params, idempotencyKey, maxRetries, reuseTerminal) {
+    const existing = this.store.getJobByIdempotencyKey(idempotencyKey);
+    if (existing?.type === type) {
+      if (!haveSameParams(existing.params, params)) {
+        throw new Error(
+          `Idempotency key collision with different ${type} params: ${idempotencyKey}. Use a new idempotency key for a new ${type} intent.`
+        );
+      }
+      if (existing.state === "succeeded" || existing.state === "cancelled") {
+        if (reuseTerminal === false) {
+          const reset = this.store.updateJob(existing.id, {
+            state: "queued",
+            params,
+            result: void 0,
+            error: void 0,
+            retryCount: 0,
+            nextRetryAt: void 0,
+            completedAt: void 0
+          });
+          this.store.addJobEvent(existing.id, "created", existing.state, "queued", this.buildEventData(reset));
+          this.emit("job:created", reset);
+          this.schedule(reset);
+          return reset;
+        }
+        return existing;
+      }
+      if (!TERMINAL_JOB_STATES.has(existing.state) || existing.state === "failed") {
+        if (existing.state === "failed" && !this.active.has(existing.id)) {
+          const reset = this.store.updateJob(existing.id, {
+            state: "queued",
+            params,
+            result: void 0,
+            error: void 0,
+            retryCount: 0,
+            nextRetryAt: void 0,
+            completedAt: void 0
+          });
+          this.schedule(reset);
+          return reset;
+        }
+        return existing;
+      }
+    }
+    const job = this.store.createJob({
+      type,
+      state: "queued",
+      params,
+      retryCount: 0,
+      maxRetries: maxRetries ?? this.retryPolicy.maxRetries,
+      idempotencyKey
+    });
+    this.store.addJobEvent(job.id, "created", void 0, "queued", this.buildEventData(job));
+    this.emit("job:created", job);
+    this.schedule(job);
+    return job;
+  }
+  tick() {
+    if (!this.running) return;
+    if (this.active.size >= this.maxConcurrentJobs) return;
+    const queued = this.store.listJobs({
+      state: "queued",
+      limit: this.maxConcurrentJobs - this.active.size
+    });
+    for (const job of queued) {
+      if (this.active.size >= this.maxConcurrentJobs) break;
+      if (!this.active.has(job.id)) {
+        this.execute(job);
+      }
+    }
+    if (this.active.size < this.maxConcurrentJobs) {
+      const retryable = this.store.getRetryableJobs();
+      for (const job of retryable) {
+        if (this.active.size >= this.maxConcurrentJobs) break;
+        if (!this.active.has(job.id)) {
+          this.execute(job);
+        }
+      }
+    }
+  }
+  schedule(job) {
+    if (this.running && this.active.size < this.maxConcurrentJobs && !this.active.has(job.id)) {
+      this.execute(job);
+    }
+  }
+  recover() {
+    const inProgress = this.store.getInProgressJobs();
+    for (const job of inProgress) {
+      if (this.active.size >= this.maxConcurrentJobs) break;
+      let recoveredJob = job;
+      if (job.type === "payment" && (job.state === "executing" || job.state === "inflight")) {
+        recoveredJob = this.store.updateJob(job.id, { state: "inflight" });
+      }
+      this.execute(recoveredJob);
+    }
+  }
+  execute(job) {
+    const abortController = new AbortController();
+    const promise = (async () => {
+      try {
+        const generator = job.type === "payment" ? runPaymentJob(job, this.rpc, this.retryPolicy, abortController.signal) : job.type === "invoice" ? runInvoiceJob(job, this.rpc, this.retryPolicy, abortController.signal) : runChannelJob(job, this.rpc, this.retryPolicy, abortController.signal);
+        for await (const updated of generator) {
+          const prev = this.getJob(updated.id);
+          const fromState = prev?.state ?? job.state;
+          this.store.updateJob(updated.id, updated);
+          this.store.addJobEvent(
+            updated.id,
+            stateToEvent(updated.state),
+            fromState,
+            updated.state,
+            this.buildEventData(updated)
+          );
+          this.emit("job:state_changed", updated, fromState);
+          if (updated.state === "succeeded") this.emit("job:succeeded", updated);
+          if (updated.state === "failed") this.emit("job:failed", updated);
+          if (updated.state === "cancelled") this.emit("job:cancelled", updated);
+        }
+      } finally {
+        this.active.delete(job.id);
+      }
+    })();
+    this.active.set(job.id, { abortController, promise });
+  }
+  buildEventData(job) {
+    const base = {
+      type: job.type,
+      idempotencyKey: job.idempotencyKey,
+      retryCount: job.retryCount,
+      maxRetries: job.maxRetries,
+      nextRetryAt: job.nextRetryAt
+    };
+    if (job.error) {
+      base.error = {
+        category: job.error.category,
+        retryable: job.error.retryable,
+        message: job.error.message
+      };
+    }
+    if (job.type === "payment") {
+      const paymentJob = job;
+      return {
+        ...base,
+        invoice: paymentJob.params.invoice,
+        paymentHash: paymentJob.result?.paymentHash,
+        paymentStatus: paymentJob.result?.status
+      };
+    }
+    if (job.type === "invoice") {
+      const invoiceJob = job;
+      return {
+        ...base,
+        action: invoiceJob.params.action,
+        paymentHash: invoiceJob.result?.paymentHash ?? invoiceJob.params.getInvoicePaymentHash,
+        invoiceStatus: invoiceJob.result?.status
+      };
+    }
+    const channelJob = job;
+    return {
+      ...base,
+      action: channelJob.params.action,
+      channelId: channelJob.params.channelId ?? channelJob.params.shutdownChannelParams?.channel_id ?? channelJob.result?.channelId,
+      peerId: channelJob.params.peerId ?? channelJob.params.openChannelParams?.peer_id,
+      channelState: channelJob.result?.state
+    };
+  }
+};
+function deriveInvoiceKey(params) {
+  if (params.action === "watch" && params.getInvoicePaymentHash) {
+    return `invoice:watch:${params.getInvoicePaymentHash}`;
+  }
+  if (params.action === "cancel" && params.cancelInvoiceParams?.payment_hash) {
+    return `invoice:cancel:${params.cancelInvoiceParams.payment_hash}`;
+  }
+  if (params.action === "settle" && params.settleInvoiceParams?.payment_hash) {
+    return `invoice:settle:${params.settleInvoiceParams.payment_hash}`;
+  }
+  if (params.action === "create" && params.newInvoiceParams?.payment_hash) {
+    return `invoice:create:${params.newInvoiceParams.payment_hash}`;
+  }
+  return void 0;
+}
+function deriveChannelKey(params) {
+  if (params.action === "open") return void 0;
+  if (params.acceptChannelParams?.temporary_channel_id) {
+    return `channel:accept:${params.acceptChannelParams.temporary_channel_id}`;
+  }
+  if (params.action === "shutdown" && params.shutdownChannelParams?.channel_id) {
+    return `channel:shutdown:${params.shutdownChannelParams.channel_id}`;
+  }
+  if (params.action === "abandon" && params.abandonChannelParams?.channel_id) {
+    return `channel:abandon:${params.abandonChannelParams.channel_id}`;
+  }
+  if (params.action === "update" && params.updateChannelParams?.channel_id) {
+    const fingerprint = stableStringify(params.updateChannelParams);
+    return `channel:update:${params.updateChannelParams.channel_id}:${fingerprint}`;
+  }
+  if (params.channelId) return `channel:${params.action}:${params.channelId}`;
+  return void 0;
+}
+function stateToEvent(state) {
+  switch (state) {
+    case "executing":
+      return "executing";
+    case "inflight":
+      return "inflight";
+    case "invoice_created":
+      return "invoice_created";
+    case "invoice_received":
+      return "invoice_received";
+    case "invoice_settled":
+      return "invoice_settled";
+    case "invoice_expired":
+      return "invoice_expired";
+    case "invoice_cancelled":
+      return "invoice_cancelled";
+    case "channel_opening":
+      return "channel_opening";
+    case "channel_accepting":
+      return "channel_accepting";
+    case "channel_abandoning":
+      return "channel_abandoning";
+    case "channel_updating":
+      return "channel_updating";
+    case "channel_awaiting_ready":
+      return "channel_awaiting_ready";
+    case "channel_ready":
+      return "channel_ready";
+    case "channel_closing":
+      return "channel_closing";
+    case "channel_closed":
+      return "channel_closed";
+    case "waiting_retry":
+      return "retry_scheduled";
+    case "succeeded":
+      return "succeeded";
+    case "failed":
+      return "failed";
+    case "cancelled":
+      return "cancelled";
+    default:
+      return "executing";
+  }
+}
+
+// src/service.ts
+var FiberMonitorService = class extends EventEmitter2 {
+  config;
+  startedAt;
+  client;
+  store;
+  alerts;
+  monitors;
+  proxy;
+  jobStore;
+  jobManager;
+  running = false;
+  constructor(configInput = {}) {
+    super();
+    this.config = createRuntimeConfig(configInput);
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.client = new FiberRpcClient2({
+      url: this.config.fiberRpcUrl,
+      timeout: this.config.requestTimeoutMs
+    });
+    this.store = new MemoryStore({
+      stateFilePath: this.config.storage.stateFilePath,
+      flushIntervalMs: this.config.storage.flushIntervalMs,
+      maxAlertHistory: this.config.storage.maxAlertHistory
+    });
+    this.alerts = new AlertManager({
+      backends: this.createAlertBackends(this.config),
+      store: this.store
+    });
+    this.jobStore = this.config.jobs.enabled ? new SqliteJobStore(this.config.jobs.dbPath) : null;
+    this.jobManager = this.jobStore ? new JobManager(this.client, this.jobStore, {
+      maxConcurrentJobs: this.config.jobs.maxConcurrentJobs,
+      schedulerIntervalMs: this.config.jobs.schedulerIntervalMs,
+      retryPolicy: this.config.jobs.retryPolicy
+    }) : null;
+    this.wireJobAlerts();
+    const hooks = {};
+    this.monitors = [
+      new ChannelMonitor({
+        client: this.client,
+        store: this.store,
+        alerts: this.alerts,
+        config: {
+          intervalMs: this.config.channelPollIntervalMs,
+          includeClosedChannels: this.config.includeClosedChannels
+        },
+        hooks
+      }),
+      new InvoiceTracker({
+        client: this.client,
+        store: this.store,
+        alerts: this.alerts,
+        config: {
+          intervalMs: this.config.invoicePollIntervalMs,
+          completedItemTtlSeconds: this.config.completedItemTtlSeconds
+        },
+        hooks
+      }),
+      new PaymentTracker({
+        client: this.client,
+        store: this.store,
+        alerts: this.alerts,
+        config: {
+          intervalMs: this.config.paymentPollIntervalMs,
+          completedItemTtlSeconds: this.config.completedItemTtlSeconds
+        },
+        hooks
+      }),
+      new PeerMonitor({
+        client: this.client,
+        store: this.store,
+        alerts: this.alerts,
+        config: { intervalMs: this.config.peerPollIntervalMs },
+        hooks
+      }),
+      new HealthMonitor({
+        client: this.client,
+        alerts: this.alerts,
+        config: { intervalMs: this.config.healthPollIntervalMs }
+      })
+    ];
+    this.alerts.onEmit((alert) => {
+      this.emit("alert", alert);
+    });
+    this.proxy = new RpcMonitorProxy(
+      {
+        listen: this.config.proxy.listen,
+        targetUrl: this.config.fiberRpcUrl
+      },
+      {
+        onInvoiceTracked: (paymentHash) => {
+          this.store.addTrackedInvoice(paymentHash);
+        },
+        onPaymentTracked: (paymentHash) => {
+          this.store.addTrackedPayment(paymentHash);
+        },
+        listTrackedInvoices: () => this.store.listTrackedInvoices(),
+        listTrackedPayments: () => this.store.listTrackedPayments(),
+        listAlerts: (filters) => this.store.listAlerts(filters),
+        getStatus: () => this.getStatus(),
+        createPaymentJob: this.jobManager ? (params, options) => this.jobManager.ensurePayment(params, options) : void 0,
+        createInvoiceJob: this.jobManager ? (params, options) => this.jobManager.manageInvoice(params, options) : void 0,
+        createChannelJob: this.jobManager ? (params, options) => this.jobManager.manageChannel(params, options) : void 0,
+        getJob: this.jobManager ? (id) => this.jobManager.getJob(id) : void 0,
+        listJobs: this.jobManager ? (filter) => this.jobManager.listJobs(filter) : void 0,
+        cancelJob: this.jobManager ? (id) => this.jobManager.cancelJob(id) : void 0,
+        listJobEvents: this.jobStore ? (jobId) => this.jobStore.listJobEvents(jobId) : void 0
+      }
+    );
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    await this.store.load();
+    this.store.startAutoFlush();
+    await this.alerts.start();
+    for (const monitor of this.monitors) {
+      monitor.start();
+    }
+    this.jobManager?.start();
+    if (this.config.proxy.enabled) {
+      await this.proxy.start();
+    }
+    this.running = true;
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    for (const monitor of this.monitors) {
+      monitor.stop();
+    }
+    await this.jobManager?.stop();
+    if (this.config.proxy.enabled) {
+      await this.proxy.stop();
+    }
+    this.store.stopAutoFlush();
+    await this.store.flush();
+    await this.alerts.stop();
+    this.jobStore?.close();
+    this.running = false;
+  }
+  getStatus() {
+    return {
+      startedAt: this.startedAt,
+      proxyListen: this.config.proxy.listen,
+      targetUrl: this.config.fiberRpcUrl,
+      running: this.running
+    };
+  }
+  listAlerts(filters) {
+    return this.store.listAlerts(filters);
+  }
+  listTrackedInvoices() {
+    return this.store.listTrackedInvoices();
+  }
+  listTrackedPayments() {
+    return this.store.listTrackedPayments();
+  }
+  trackInvoice(paymentHash) {
+    this.store.addTrackedInvoice(paymentHash);
+  }
+  trackPayment(paymentHash) {
+    this.store.addTrackedPayment(paymentHash);
+  }
+  createAlertBackends(config) {
+    return config.alerts.map((alertConfig) => {
+      if (alertConfig.type === "stdout") {
+        return new StdoutAlertBackend();
+      }
+      if (alertConfig.type === "webhook") {
+        return new WebhookAlertBackend({
+          url: alertConfig.url,
+          timeoutMs: alertConfig.timeoutMs,
+          headers: alertConfig.headers
+        });
+      }
+      if (alertConfig.type === "file") {
+        return new JsonlFileAlertBackend(alertConfig.path);
+      }
+      const [host, portText] = alertConfig.listen.split(":");
+      return new WebsocketAlertBackend({
+        host,
+        port: Number(portText)
+      });
+    });
+  }
+  wireJobAlerts() {
+    if (!this.jobManager) {
+      return;
+    }
+    this.jobManager.on("job:created", (job) => {
+      this.emitJobAlert(job, "started", "low");
+      this.trackJobArtifacts(job);
+    });
+    this.jobManager.on("job:state_changed", (job) => {
+      this.trackJobArtifacts(job);
+      if (job.state === "waiting_retry") {
+        this.emitJobAlert(job, "retrying", "medium");
+      }
+    });
+    this.jobManager.on("job:succeeded", (job) => {
+      this.trackJobArtifacts(job);
+      this.emitJobAlert(job, "succeeded", "medium");
+    });
+    this.jobManager.on("job:failed", (job) => {
+      this.trackJobArtifacts(job);
+      this.emitJobAlert(job, "failed", "high");
+    });
+  }
+  emitJobAlert(job, lifecycle, priority) {
+    const type = this.toJobAlertType(job.type, lifecycle);
+    const data = this.toJobAlertData(job);
+    void this.alerts.emit({
+      type,
+      priority,
+      source: "job-manager",
+      data
+    });
+  }
+  toJobAlertType(jobType, lifecycle) {
+    return `${jobType}_job_${lifecycle}`;
+  }
+  toJobAlertData(job) {
+    const error = job.error?.message;
+    if (job.type === "payment") {
+      const paymentJob = job;
+      return {
+        jobId: paymentJob.id,
+        idempotencyKey: paymentJob.idempotencyKey,
+        retryCount: paymentJob.retryCount,
+        error,
+        fee: paymentJob.result?.fee
+      };
+    }
+    if (job.type === "invoice") {
+      const invoiceJob = job;
+      return {
+        jobId: invoiceJob.id,
+        idempotencyKey: invoiceJob.idempotencyKey,
+        retryCount: invoiceJob.retryCount,
+        action: invoiceJob.params.action,
+        status: invoiceJob.result?.status,
+        paymentHash: this.extractInvoiceHash(invoiceJob),
+        error
+      };
+    }
+    const channelJob = job;
+    return {
+      jobId: channelJob.id,
+      idempotencyKey: channelJob.idempotencyKey,
+      retryCount: channelJob.retryCount,
+      action: channelJob.params.action,
+      channelId: this.extractChannelId(channelJob),
+      error
+    };
+  }
+  trackJobArtifacts(job) {
+    if (job.type === "payment") {
+      const paymentHash = this.extractPaymentHash(job);
+      if (paymentHash) {
+        this.store.addTrackedPayment(paymentHash);
+      }
+      return;
+    }
+    if (job.type === "invoice") {
+      const paymentHash = this.extractInvoiceHash(job);
+      if (paymentHash) {
+        this.store.addTrackedInvoice(paymentHash);
+      }
+    }
+  }
+  extractPaymentHash(job) {
+    return this.normalizeHash(job.result?.paymentHash ?? job.params.sendPaymentParams.payment_hash);
+  }
+  extractInvoiceHash(job) {
+    return this.normalizeHash(
+      job.result?.paymentHash ?? job.params.getInvoicePaymentHash ?? job.params.cancelInvoiceParams?.payment_hash ?? job.params.settleInvoiceParams?.payment_hash ?? job.params.newInvoiceParams?.payment_hash
+    );
+  }
+  extractChannelId(job) {
+    return this.normalizeHash(
+      job.result?.channelId ?? job.result?.acceptedChannelId ?? job.params.channelId ?? job.params.shutdownChannelParams?.channel_id
+    );
+  }
+  normalizeHash(value) {
+    if (!value || !value.startsWith("0x")) {
+      return void 0;
+    }
+    return value;
+  }
+};
+
+// src/bootstrap.ts
+async function startRuntimeService(configInput = {}) {
+  const service = new FiberMonitorService(configInput);
+  await service.start();
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    await service.stop();
+  };
+  const waitForShutdownSignal = () => {
+    return new Promise((resolve2) => {
+      const onSignal = (signal) => {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        resolve2(signal);
+      };
+      process.on("SIGINT", onSignal);
+      process.on("SIGTERM", onSignal);
+    });
+  };
+  return {
+    service,
+    stop,
+    waitForShutdownSignal
+  };
+}
+export {
+  FiberMonitorService,
+  JobManager,
+  MemoryStore,
+  RpcMonitorProxy,
+  SqliteJobStore,
+  alertPriorityOrder,
+  alertTypeValues,
+  classifyRpcError,
+  computeRetryDelay,
+  createRuntimeConfig,
+  defaultPaymentRetryPolicy,
+  defaultRuntimeConfig,
+  formatRuntimeAlert,
+  isAlertPriority,
+  isAlertType,
+  paymentStateMachine,
+  shouldRetry,
+  startRuntimeService
+};
+//# sourceMappingURL=index.js.map