@dvmkit/sdk 0.0.0 → 0.1.0-rc.1

package/dist/chunk-6JZIX5WW.js

@@ -0,0 +1,1155 @@
+import {
+  withSdkInitLock
+} from "./chunk-S3XAHZQY.js";
+
+// src/sdk/server/postgres-job-store.ts
+import { createHash } from "crypto";
+
+// src/lib/listen-channel.ts
+var DEFAULT_BACKOFF_MS = [1e3, 4e3, 15e3, 3e4];
+var ListenChannel = class {
+  constructor(pool, opts) {
+    this.pool = pool;
+    this.opts = opts;
+    this.backoffMs = opts.backoffMs ?? DEFAULT_BACKOFF_MS;
+  }
+  pool;
+  opts;
+  client = null;
+  stopped = false;
+  reconnectTimer = null;
+  reconnectAttempt = 0;
+  backoffMs;
+  /**
+   * Open the LISTEN connection. Resolves once the initial connect attempt
+   * has either succeeded or scheduled a retry — never rejects, so callers
+   * can fire-and-forget at boot.
+   */
+  start() {
+    this.stopped = false;
+    return this.connect();
+  }
+  /** Release the LISTEN client and cancel any pending reconnect. */
+  async stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const client = this.client;
+    this.client = null;
+    if (client) {
+      try {
+        await client.query("UNLISTEN *");
+      } catch {
+      }
+      try {
+        client.release();
+      } catch {
+      }
+    }
+  }
+  async connect() {
+    if (this.stopped) return;
+    let client;
+    try {
+      client = await this.pool.connect();
+    } catch (err) {
+      this.opts.onReconnectFailed?.(this.reconnectAttempt, err);
+      this.scheduleReconnect();
+      return;
+    }
+    let lost = false;
+    const onLost = (err) => {
+      if (lost || this.stopped) return;
+      lost = true;
+      if (this.client === client) this.client = null;
+      this.opts.onLost?.(err);
+      try {
+        client.release(err ?? new Error("listen connection lost"));
+      } catch {
+      }
+      this.scheduleReconnect();
+    };
+    const onEnd = () => {
+      onLost();
+    };
+    client.on("error", onLost);
+    client.on("end", onEnd);
+    try {
+      await client.query(`LISTEN ${this.opts.channel}`);
+    } catch (err) {
+      if (!lost) {
+        lost = true;
+        this.opts.onReconnectFailed?.(this.reconnectAttempt, err);
+        try {
+          client.release(err instanceof Error ? err : new Error(String(err)));
+        } catch {
+        }
+        this.scheduleReconnect();
+      }
+      return;
+    }
+    if (lost) return;
+    if (this.stopped) {
+      lost = true;
+      try {
+        await client.query("UNLISTEN *");
+      } catch {
+      }
+      try {
+        client.release();
+      } catch {
+      }
+      return;
+    }
+    this.client = client;
+    this.reconnectAttempt = 0;
+    client.on("notification", (notification) => {
+      if (notification.channel !== this.opts.channel) return;
+      this.opts.onNotification(notification.payload);
+    });
+  }
+  scheduleReconnect() {
+    if (this.stopped) return;
+    if (this.reconnectTimer) return;
+    const idx = Math.min(this.reconnectAttempt, this.backoffMs.length - 1);
+    const delay = this.backoffMs[idx];
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect();
+    }, delay);
+  }
+};
+
+// src/sdk/server/postgres-job-store.ts
+var JOB_MESSAGES_CHANNEL = "job_messages";
+var PostgresJobStore = class {
+  pool;
+  listenChannel = null;
+  messageSubscribers = /* @__PURE__ */ new Map();
+  notifySubscribers = /* @__PURE__ */ new Map();
+  requestIdClaimLocks = /* @__PURE__ */ new Map();
+  constructor(pool) {
+    this.pool = pool;
+  }
+  /** Run the CREATE TABLE migration. Call once at startup. */
+  async init() {
+    await withSdkInitLock(this.pool, () => this.createTables());
+  }
+  /** The boot DDL itself — always runs under {@link withSdkInitLock} (internal-review). */
+  async createTables() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id                          TEXT PRIMARY KEY,
+        tags                        JSONB NOT NULL DEFAULT '[]',
+        input                       TEXT NOT NULL,
+        params                      JSONB NOT NULL DEFAULT '{}',
+        requester_id                TEXT NOT NULL,
+        status                      TEXT NOT NULL DEFAULT 'processing',
+        summary                     TEXT,
+        messages                    JSONB NOT NULL DEFAULT '[]',
+        seq                         INTEGER NOT NULL DEFAULT 0,
+        paid_msats                  BIGINT NOT NULL DEFAULT 0,
+        payment_mint                TEXT,
+        received_proofs             JSONB NOT NULL DEFAULT '[]',
+        pending_payment_msats       BIGINT,
+        -- Keeps its mpp spelling past internal-review's rail rename (internal-review): it
+        -- holds mppx challenge ids \u2014 objects of the MPP envelope the Tempo rail
+        -- rides, not the rail key \u2014 and it is server-internal anti-replay state
+        -- (internal-review) that never reaches a caller.
+        pending_mpp_challenge_ids   JSONB,
+        pending_x402_nonce          TEXT,
+        pending_x402_amount_usdc_micro TEXT,
+        step_cache                  JSONB NOT NULL DEFAULT '[]',
+        state                       JSONB NOT NULL DEFAULT '{}',
+        created_at                  BIGINT NOT NULL,
+        last_activity_at            BIGINT NOT NULL
+      );
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS pending_mpp_challenge_ids JSONB;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS pending_x402_nonce TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS pending_x402_amount_usdc_micro TEXT;
+      ALTER TABLE jobs DROP COLUMN IF EXISTS pending_payment_hash;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS payment_rail TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS payment_tx_hash TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS payment_transaction_hash TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS native_amount DOUBLE PRECISION;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS native_asset TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS cashu_flow TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS required_msats BIGINT;
+      -- next_seq is intentionally absent from isolate_jobs (platform/db.ts).
+      -- It powers StreamableJobStore cross-machine seq allocation; isolate
+      -- DVMs are single-machine and use basic JobStore only.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS next_seq INTEGER NOT NULL DEFAULT 1;
+      -- internal-review: the rail formerly written as 'mpp' is 'tempo'. A live job's
+      -- mid-job payment compares this against the incoming rail, and the
+      -- receipt reports it.
+      UPDATE jobs SET payment_rail = 'tempo' WHERE payment_rail = 'mpp';
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS capability TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS requester_token_hash TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS requester_token TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS request_fingerprint TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS requester_pubkey TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS request_id TEXT;
+      -- internal-review: the route accepted by the live auth gate. Kept outside the
+      -- caller-controlled envelope so reactivation cannot derive its expected
+      -- route from the proof it is meant to check.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS auth_request_path TEXT;
+      -- internal-review: the signed receipt, written once at terminal by saveReceipt,
+      -- plus the per-DVM terminal counter value this job holds. Neither is in
+      -- save's column list \u2014 a stale snapshot must not be able to clear a
+      -- receipt or re-allocate a sequence number.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS receipt JSONB;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS receipt_seq BIGINT;
+      -- internal-review: credit-ledger linkage. Written at submission alongside the
+      -- payment fields; the terminal funnel settles/releases the draw and the
+      -- receipt countersigns the ReceiptCredit block from it.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS credit_id TEXT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS draw_id TEXT;
+      -- internal-review: the original signed funding artifact and the snapshot served
+      -- with a fund-and-draw response. INSERT-only for replay stability.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS funding_receipt JSONB;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS funding_credit JSONB;
+      -- internal-review: the outstanding mid-job ask, denominated in fiat micro at the
+      -- instant it was emitted. The top-up's ledger leg funds and grows the
+      -- draw in this figure, so it must not move with the BTC/USD rate between
+      -- the ask and the payment (and the paying machine is often not the one
+      -- that asked, so it has to be durable rather than handler-local).
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS pending_payment_fiat_micro BIGINT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS pending_payment_fiat_currency TEXT;
+      -- internal-review: the same figure accumulated over the job's whole life, which
+      -- is what caps mid-job draw growth. It has to be its own column rather
+      -- than a read of the one above: Tx C decrements the outstanding figure as
+      -- payments land, and a cap that shrank with it would let a duplicate
+      -- payment buy the same ask twice.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS asked_topup_micro BIGINT;
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS asked_topup_currency TEXT;
+      -- internal-review: why the ceiling above is absent, on the jobs where it is. The
+      -- durable half of the -1 sentinel \u2014 an uncapped job has to be findable by
+      -- query, not by grepping a log line off a machine that may be long gone.
+      ALTER TABLE jobs ADD COLUMN IF NOT EXISTS topup_cap_unenforced_reason TEXT;
+      DO $migration$
+      BEGIN
+        IF EXISTS (
+          SELECT 1 FROM information_schema.columns
+          WHERE table_name = 'jobs' AND column_name = 'result'
+        ) THEN
+          ALTER TABLE jobs RENAME COLUMN result TO summary;
+        END IF;
+      END
+      $migration$;
+      UPDATE jobs SET next_seq = seq + 1 WHERE next_seq <= seq;
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs (status);
+      -- internal-review: the idempotent-replay lookup. payment_tx_hash carries the
+      -- caller's X-Cashu-Request-Id on the accumulator path, so a retried paid
+      -- submit finds the job its payment already created.
+      CREATE INDEX IF NOT EXISTS idx_jobs_payment_tx_hash ON jobs (payment_tx_hash);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_request_id_caller
+        ON jobs (requester_pubkey, request_id)
+        WHERE request_id IS NOT NULL;
+
+      -- Public request ids keep a permanent identity/job binding. A live
+      -- Postgres advisory lock serializes the paid accept path; unlike a held
+      -- row, that lock disappears when its owning process or connection dies,
+      -- allowing an exact retry to reach the rail's durable idempotency row.
+      CREATE TABLE IF NOT EXISTS request_id_claims (
+        requester_pubkey   TEXT NOT NULL,
+        request_id         TEXT NOT NULL,
+        request_fingerprint TEXT NOT NULL,
+        requester_id       TEXT NOT NULL,
+        job_id             TEXT NOT NULL UNIQUE,
+        created_at         BIGINT NOT NULL,
+        updated_at         BIGINT NOT NULL,
+        PRIMARY KEY (requester_pubkey, request_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS job_messages (
+        job_id  TEXT NOT NULL,
+        seq     INTEGER NOT NULL,
+        data    JSONB NOT NULL,
+        status  TEXT NOT NULL DEFAULT 'verified',
+        PRIMARY KEY (job_id, seq)
+      );
+      ALTER TABLE job_messages ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'verified';
+
+      -- internal-review: per-DVM monotonic receipt counter. Single row by
+      -- construction (the CHECK pins the key), and per-DVM by construction
+      -- too \u2014 the SDK runs one database per DVM (see postgres-kv-store.ts).
+      -- Allocated with the same UPDATE \u2026 RETURNING trick as jobs.next_seq so
+      -- concurrent machines can't hand two jobs the same number.
+      CREATE TABLE IF NOT EXISTS receipt_counter (
+        id BOOLEAN PRIMARY KEY DEFAULT TRUE,
+        n  BIGINT NOT NULL DEFAULT 0,
+        CONSTRAINT receipt_counter_singleton CHECK (id)
+      );
+      INSERT INTO receipt_counter (id, n) VALUES (TRUE, 0) ON CONFLICT (id) DO NOTHING;
+    `);
+  }
+  async get(id) {
+    const { rows } = await this.pool.query("SELECT * FROM jobs WHERE id = $1", [id]);
+    if (rows.length === 0) return void 0;
+    return rowToRecord(rows[0]);
+  }
+  /**
+   * internal-review. Indexed by `idx_jobs_payment_tx_hash`. `paymentTxHash` is unique
+   * per settlement in practice — the accumulator's
+   * `UNIQUE(dvm_id, request_id, proof_secret)` is what makes a second job under
+   * the same request id impossible — but order by `created_at` so a
+   * hypothetical duplicate resolves to the job the caller actually paid for.
+   */
+  async findJobByPaymentTxHash(txHash) {
+    const { rows } = await this.pool.query(
+      "SELECT * FROM jobs WHERE payment_tx_hash = $1 ORDER BY created_at ASC LIMIT 1",
+      [txHash]
+    );
+    if (rows.length === 0) return void 0;
+    return rowToRecord(rows[0]);
+  }
+  async findJobByRequestId(requestId, requesterPubkey) {
+    const { rows } = await this.pool.query(
+      `SELECT * FROM jobs
+        WHERE requester_pubkey = $1 AND request_id = $2
+        ORDER BY created_at ASC
+        LIMIT 1`,
+      [requesterPubkey, requestId]
+    );
+    if (rows.length === 0) return void 0;
+    return rowToRecord(rows[0]);
+  }
+  async claimRequestId(claim) {
+    return this.acquireRequestIdClaim(claim, true);
+  }
+  async resumeRequestId(claim) {
+    return this.acquireRequestIdClaim(claim, false);
+  }
+  async acquireRequestIdClaim(claim, createBinding) {
+    const client = await this.pool.connect();
+    const lockKey = requestIdAdvisoryLockKey(claim.requesterPubkey, claim.requestId);
+    let locked = false;
+    try {
+      const lock = await client.query(
+        "SELECT pg_try_advisory_lock($1::bigint) AS acquired",
+        [lockKey]
+      );
+      if (!lock.rows[0]?.acquired) return void 0;
+      locked = true;
+      const now = Date.now();
+      const inserted = createBinding ? await client.query(
+        `INSERT INTO request_id_claims (
+               requester_pubkey, request_id, request_fingerprint, requester_id,
+               job_id, created_at, updated_at
+             ) VALUES ($1, $2, $3, $4, $5, $6, $6)
+             ON CONFLICT (requester_pubkey, request_id) DO NOTHING
+             RETURNING job_id`,
+        [
+          claim.requesterPubkey,
+          claim.requestId,
+          claim.requestFingerprint,
+          claim.requesterId,
+          claim.jobId,
+          now
+        ]
+      ) : { rowCount: 0, rows: [] };
+      let result;
+      if (inserted.rowCount === 1) {
+        result = { jobId: inserted.rows[0].job_id, replayed: false };
+      } else {
+        const existing = await client.query(
+          `SELECT job_id, request_fingerprint, requester_id
+             FROM request_id_claims
+            WHERE requester_pubkey = $1 AND request_id = $2`,
+          [claim.requesterPubkey, claim.requestId]
+        );
+        const row = existing.rows.at(0);
+        if (row?.request_fingerprint === claim.requestFingerprint && row.requester_id === claim.requesterId) {
+          result = { jobId: row.job_id, replayed: true };
+        }
+      }
+      if (!result) return void 0;
+      this.requestIdClaimLocks.set(claim.claimToken, {
+        client,
+        lockKey,
+        requesterPubkey: claim.requesterPubkey,
+        requestId: claim.requestId
+      });
+      return result;
+    } finally {
+      if (!this.requestIdClaimLocks.has(claim.claimToken)) {
+        let discard = false;
+        if (locked) {
+          try {
+            await client.query("SELECT pg_advisory_unlock($1::bigint)", [lockKey]);
+          } catch {
+            discard = true;
+          }
+        }
+        client.release(discard);
+      }
+    }
+  }
+  async releaseRequestIdClaim(claim) {
+    const held = this.requestIdClaimLocks.get(claim.claimToken);
+    if (held?.requesterPubkey !== claim.requesterPubkey || held.requestId !== claim.requestId) {
+      return;
+    }
+    this.requestIdClaimLocks.delete(claim.claimToken);
+    try {
+      const unlocked = await held.client.query(
+        "SELECT pg_advisory_unlock($1::bigint) AS unlocked",
+        [held.lockKey]
+      );
+      if (!unlocked.rows[0]?.unlocked) {
+        throw new Error("request-id advisory lock was not owned by this connection");
+      }
+    } catch (err) {
+      held.client.release(true);
+      throw err;
+    }
+    held.client.release();
+  }
+  async save(record) {
+    const { rowCount } = await this.pool.query(
+      `INSERT INTO jobs (
+        id, tags, capability, input, params, requester_id, status, summary,
+        messages, seq, paid_msats, payment_mint, payment_rail,
+        payment_tx_hash, payment_transaction_hash, native_amount, native_asset, cashu_flow,
+        received_proofs, pending_payment_msats, pending_mpp_challenge_ids,
+        pending_x402_nonce, pending_x402_amount_usdc_micro, required_msats, step_cache, state, created_at,
+        last_activity_at, next_seq, requester_token_hash, requester_token,
+        request_fingerprint, requester_pubkey, request_id, credit_id, draw_id,
+        pending_payment_fiat_micro, pending_payment_fiat_currency, auth_request_path,
+        funding_receipt, funding_credit
+      ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23,$24,$25,$26,$27,$28,$29,$30,$31,$32,$33,$34,$35,$36,$37,$38,$39,$40,$41)
+      ON CONFLICT (id) DO UPDATE SET
+        status = EXCLUDED.status,
+        summary = EXCLUDED.summary,
+        messages = EXCLUDED.messages,
+        -- GREATEST keeps seq monotonic: a stale snapshot from a machine
+        -- whose in-memory job.seq is behind the DB high-water mark must
+        -- not regress jobs.seq. See internal-review review feedback.
+        seq = GREATEST(jobs.seq, EXCLUDED.seq),
+        payment_mint = EXCLUDED.payment_mint,
+        payment_rail = EXCLUDED.payment_rail,
+        payment_tx_hash = EXCLUDED.payment_tx_hash,
+        payment_transaction_hash = COALESCE(jobs.payment_transaction_hash, EXCLUDED.payment_transaction_hash),
+        native_amount = EXCLUDED.native_amount,
+        native_asset = EXCLUDED.native_asset,
+        cashu_flow = EXCLUDED.cashu_flow,
+        received_proofs = EXCLUDED.received_proofs,
+        pending_mpp_challenge_ids = EXCLUDED.pending_mpp_challenge_ids,
+        pending_x402_nonce = EXCLUDED.pending_x402_nonce,
+        pending_x402_amount_usdc_micro = EXCLUDED.pending_x402_amount_usdc_micro,
+        required_msats = EXCLUDED.required_msats,
+        step_cache = EXCLUDED.step_cache,
+        state = EXCLUDED.state,
+        last_activity_at = EXCLUDED.last_activity_at
+      -- internal-review: terminal is terminal. On a multi-machine DVM a DELETE can
+      -- land on a machine that isn't running the handler, which cancels the
+      -- job in the store only; the handler's machine never learns of it and
+      -- would otherwise persist completed over the cancelled row. Once a row is
+      -- terminal, only a re-save of the SAME terminal status lands (an
+      -- idempotent re-persist of the same outcome); a different status is
+      -- rejected wholesale, so the row can't end up as a Frankenstein of a
+      -- cancelled status and a completed snapshot.
+      WHERE jobs.status NOT IN ('completed', 'failed', 'cancelled')
+         OR jobs.status = EXCLUDED.status`,
+      [
+        record.id,
+        JSON.stringify(record.tags),
+        record.capability,
+        record.input,
+        JSON.stringify(record.params),
+        record.requesterId,
+        record.status,
+        record.summary ?? null,
+        JSON.stringify(record.messages),
+        record.seq,
+        record.paidMsats,
+        record.paymentMint ?? null,
+        record.paymentRail ?? null,
+        record.paymentTxHash ?? null,
+        record.paymentTransactionHash ?? null,
+        record.nativeAmount ?? null,
+        record.nativeAsset ?? null,
+        record.cashuFlow ?? null,
+        JSON.stringify(record.receivedProofs),
+        record.pendingPaymentMsats ?? null,
+        record.pendingMppChallengeIds ? JSON.stringify(record.pendingMppChallengeIds) : null,
+        record.pendingX402Nonce ?? null,
+        record.pendingX402AmountUsdcMicro ?? null,
+        record.requiredMsats ?? null,
+        JSON.stringify(record.stepCache),
+        JSON.stringify(record.state),
+        record.createdAt,
+        record.lastActivityAt,
+        Math.max(record.seq + 1, 1),
+        record.requesterTokenHash ?? null,
+        // internal-review: submission-time provenance. Like requester_token_hash,
+        // these are INSERT-only — the ON CONFLICT branch above never touches
+        // them, so a later snapshot save can't rewrite what the caller must
+        // reproduce to recover the job.
+        record.requesterToken ?? null,
+        record.requestFingerprint ?? null,
+        record.requesterPubkey ?? null,
+        record.requestId ?? null,
+        // internal-review: ledger linkage — INSERT-only for the same reason.
+        record.creditId ?? null,
+        record.drawId ?? null,
+        // internal-review: the pinned mid-job ask. INSERT-only, exactly like its
+        // companion `pending_payment_msats` — both are owned by the
+        // transactional paths (`appendOutgoing` sets them, `verifyAndCredit`
+        // clears them), so a stale snapshot must not be able to reset one
+        // while the other stands.
+        record.pendingPaymentFiatMicro ?? null,
+        record.pendingPaymentFiatCurrency ?? null,
+        // internal-review: submission provenance, INSERT-only with the fingerprint
+        // and caller identity above. Snapshot saves cannot rewrite the route
+        // whose live gate accepted this proof.
+        record.authRequestPath ?? null,
+        record.fundingReceipt ? JSON.stringify(record.fundingReceipt) : null,
+        record.fundingCredit ? JSON.stringify(record.fundingCredit) : null
+      ]
+    );
+    if (rowCount === 0) {
+      console.warn(
+        JSON.stringify({
+          level: "job_save_rejected_terminal",
+          jobId: record.id,
+          attemptedStatus: record.status
+        })
+      );
+      return;
+    }
+    if (record.status === "completed" || record.status === "failed" || record.status === "cancelled") {
+      await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [record.id]).catch(() => void 0);
+    }
+  }
+  async delete(id) {
+    await this.pool.query("DELETE FROM jobs WHERE id = $1", [id]);
+    await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [id]).catch(() => void 0);
+  }
+  async claimReceiptSeq(jobId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rows } = await client.query(
+        "SELECT receipt_seq FROM jobs WHERE id = $1 FOR UPDATE",
+        [jobId]
+      );
+      if (rows.length === 0) {
+        await client.query("ROLLBACK");
+        throw new Error(`claimReceiptSeq: job ${jobId} not found`);
+      }
+      const existing = rows[0].receipt_seq;
+      if (existing != null) {
+        await client.query("ROLLBACK");
+        return Number(existing);
+      }
+      const { rows: counterRows } = await client.query(
+        "UPDATE receipt_counter SET n = n + 1 WHERE id = TRUE RETURNING n"
+      );
+      const seq = Number(counterRows[0].n);
+      await client.query("UPDATE jobs SET receipt_seq = $2 WHERE id = $1", [jobId, seq]);
+      await client.query("COMMIT");
+      return seq;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async saveReceipt(jobId, receipt) {
+    const { rows } = await this.pool.query(
+      "UPDATE jobs SET receipt = COALESCE(receipt, $2::jsonb) WHERE id = $1 RETURNING receipt",
+      [jobId, JSON.stringify(receipt)]
+    );
+    if (rows.length === 0) return void 0;
+    return rows[0].receipt;
+  }
+  // ── Tx A / Tx B / Tx C (internal-review) ────────────────────────────────────
+  async appendOutgoing(jobId, message, opts) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rows } = await client.query(
+        "UPDATE jobs SET next_seq = next_seq + 1, last_activity_at = $2 WHERE id = $1 RETURNING (next_seq - 1) AS seq",
+        [jobId, Date.now()]
+      );
+      if (rows.length === 0) {
+        await client.query("ROLLBACK");
+        throw new Error(`appendOutgoing: job ${jobId} not found`);
+      }
+      const seq = rows[0].seq;
+      const fullMessage = { ...message, seq };
+      await client.query(
+        "INSERT INTO job_messages (job_id, seq, data, status) VALUES ($1, $2, $3, 'verified')",
+        [jobId, seq, JSON.stringify(fullMessage)]
+      );
+      if (opts?.pendingPaymentDelta !== void 0) {
+        await client.query(
+          `UPDATE jobs SET
+             pending_payment_msats = COALESCE(pending_payment_msats, 0) + $2,
+             pending_mpp_challenge_ids = $3,
+             pending_x402_nonce = $4,
+             pending_x402_amount_usdc_micro = $5,
+             -- internal-review: accumulate the fiat ask alongside the msat one when the
+             -- currency matches what's already outstanding, replace when it
+             -- doesn't. A NULL micro clears both \u2014 an ask that couldn't be
+             -- priced in fiat must not leave a stale figure the top-up would
+             -- then fund against.
+             pending_payment_fiat_micro = CASE
+               WHEN $6::bigint IS NULL THEN NULL
+               WHEN pending_payment_fiat_currency IS NOT DISTINCT FROM $7 THEN
+                 COALESCE(pending_payment_fiat_micro, 0) + $6
+               ELSE $6
+             END,
+             pending_payment_fiat_currency = CASE WHEN $6::bigint IS NULL THEN NULL ELSE $7 END,
+             -- internal-review: the cumulative ask total, the ceiling on this job's
+             -- draw growth. Same accumulate rule as above, minus the reset \u2014
+             -- it is monotonic by definition. Mirrors accumulateAskedTopUp
+             -- in job-store.ts; edit the two together. -1 is the sticky "can't
+             -- bound anything" sentinel: it leaves asks missing from the sum,
+             -- so a ceiling built on it would clip a legitimate payment.
+             asked_topup_micro = CASE
+               WHEN asked_topup_micro = -1 THEN -1
+               WHEN $6::bigint IS NULL THEN -1
+               WHEN asked_topup_micro IS NULL THEN $6
+               WHEN asked_topup_currency IS NOT DISTINCT FROM $7 THEN asked_topup_micro + $6
+               ELSE -1
+             END,
+             -- First-write-wins, and internal-review made that load-bearing: this is
+             -- the job's own ask denomination, read back by ctx.requestPayment
+             -- so every later ask pins in it. The ELSE -1 arm above is the
+             -- backstop for a row an older build wrote, not a live path.
+             asked_topup_currency = COALESCE(asked_topup_currency, $7),
+             -- internal-review: the sticky reason the ceiling is gone, mirroring the
+             -- sentinel's own stickiness through COALESCE. NULL arms mean "no
+             -- new poison" \u2014 an already-poisoned row keeps its first reason.
+             topup_cap_unenforced_reason = COALESCE(topup_cap_unenforced_reason, CASE
+               WHEN asked_topup_micro = -1 THEN NULL
+               WHEN $6::bigint IS NULL THEN 'ask_unpriceable'
+               WHEN asked_topup_micro IS NULL THEN NULL
+               WHEN asked_topup_currency IS NOT DISTINCT FROM $7 THEN NULL
+               ELSE 'ask_currency_switch'
+             END)
+           WHERE id = $1`,
+          [
+            jobId,
+            opts.pendingPaymentDelta,
+            opts.pendingMppChallengeIds ? JSON.stringify(opts.pendingMppChallengeIds) : null,
+            opts.pendingX402Nonce ?? null,
+            opts.pendingX402AmountUsdcMicro ?? null,
+            opts.pendingPaymentFiatMicro ?? null,
+            opts.pendingPaymentFiatCurrency ?? null
+          ]
+        );
+      }
+      await client.query("SELECT pg_notify('job_messages', $1)", [jobId]);
+      await client.query("COMMIT");
+      return seq;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async recordInbound(jobId, message) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rows } = await client.query(
+        "UPDATE jobs SET next_seq = next_seq + 1, last_activity_at = $2 WHERE id = $1 RETURNING (next_seq - 1) AS seq",
+        [jobId, Date.now()]
+      );
+      if (rows.length === 0) {
+        await client.query("ROLLBACK");
+        throw new Error(`recordInbound: job ${jobId} not found`);
+      }
+      const seq = rows[0].seq;
+      const fullMessage = { ...message, seq };
+      await client.query(
+        "INSERT INTO job_messages (job_id, seq, data, status) VALUES ($1, $2, $3, 'pending-verification')",
+        [jobId, seq, JSON.stringify(fullMessage)]
+      );
+      await client.query("SELECT pg_notify('job_messages', $1)", [jobId]);
+      await client.query("COMMIT");
+      return seq;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async verifyAndCredit(jobId, seq, credit) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rowCount } = await client.query(
+        "UPDATE job_messages SET status='verified' WHERE job_id = $1 AND seq = $2 AND status = 'pending-verification'",
+        [jobId, seq]
+      );
+      if (!rowCount) {
+        const counters2 = await this.fetchCountersTx(client, jobId);
+        const binding2 = await this.fetchCreditBindingTx(client, jobId);
+        await client.query("COMMIT");
+        if (!counters2) throw new Error(`verifyAndCredit: job ${jobId} not found`);
+        return { counters: counters2, alreadyVerified: true, ...binding2 };
+      }
+      let counters;
+      let binding = {};
+      if (credit) {
+        const sameRail = credit.paymentRail !== void 0 && credit.accumulateNative === true;
+        const params = [
+          jobId,
+          credit.paidMsatsDelta,
+          credit.clearPending ?? false,
+          credit.paymentMint ?? null,
+          credit.paymentRail ?? null,
+          credit.paymentTxHash ?? null,
+          credit.nativeAmount ?? null,
+          credit.nativeAsset ?? null,
+          credit.cashuFlow ?? null,
+          sameRail,
+          credit.clearPendingX402Binding ?? false,
+          Date.now(),
+          credit.creditId ?? null,
+          credit.drawId ?? null
+        ];
+        const { rows } = await client.query(
+          `UPDATE jobs SET
+             paid_msats = paid_msats + $2,
+             pending_payment_msats = CASE
+               WHEN $3::boolean THEN NULL
+               ELSE GREATEST(0, COALESCE(pending_payment_msats, 0) - $2)
+             END,
+             -- internal-review: the pinned fiat ask dies with the msat ask it denominates.
+             -- Cleared outright rather than decremented: a partially-paid ask keeps
+             -- its original fiat envelope so the remainder still funds at the rate
+             -- the caller was quoted.
+             pending_payment_fiat_micro = CASE
+               WHEN $3::boolean OR pending_payment_msats IS NULL OR pending_payment_msats <= $2
+                 THEN NULL ELSE pending_payment_fiat_micro END,
+             pending_payment_fiat_currency = CASE
+               WHEN $3::boolean OR pending_payment_msats IS NULL OR pending_payment_msats <= $2
+                 THEN NULL ELSE pending_payment_fiat_currency END,
+             -- Set-if-null: a mid-job top-up that minted a fresh implicit credit
+             -- binds it here; a job that already has one keeps it, because the
+             -- top-up grew that draw rather than opening a second one.
+             credit_id = COALESCE(credit_id, $13),
+             draw_id = COALESCE(draw_id, $14),
+             payment_mint = COALESCE($4, payment_mint),
+             payment_rail = COALESCE($5, payment_rail),
+             payment_tx_hash = COALESCE($6, payment_tx_hash),
+             native_amount = CASE
+               WHEN $7::double precision IS NULL THEN native_amount
+               WHEN $10::boolean THEN COALESCE(native_amount, 0) + $7
+               ELSE $7
+             END,
+             native_asset = COALESCE($8, native_asset),
+             cashu_flow = COALESCE($9, cashu_flow),
+             pending_x402_nonce = CASE WHEN $11::boolean THEN NULL ELSE pending_x402_nonce END,
+             pending_x402_amount_usdc_micro = CASE WHEN $11::boolean THEN NULL ELSE pending_x402_amount_usdc_micro END,
+             last_activity_at = $12
+           WHERE id = $1
+           RETURNING status, paid_msats, pending_payment_msats, credit_id, draw_id`,
+          params
+        );
+        if (rows.length === 0) {
+          await client.query("ROLLBACK");
+          throw new Error(`verifyAndCredit: job ${jobId} not found`);
+        }
+        counters = {
+          status: rows[0].status,
+          paidMsats: Number(rows[0].paid_msats),
+          pendingPaymentMsats: rows[0].pending_payment_msats == null ? void 0 : Number(rows[0].pending_payment_msats)
+        };
+        binding = {
+          ...rows[0].credit_id !== null && { creditId: rows[0].credit_id },
+          ...rows[0].draw_id !== null && { drawId: rows[0].draw_id }
+        };
+      } else {
+        counters = await this.fetchCountersTx(client, jobId);
+        if (!counters) {
+          await client.query("ROLLBACK");
+          throw new Error(`verifyAndCredit: job ${jobId} not found`);
+        }
+        binding = await this.fetchCreditBindingTx(client, jobId);
+      }
+      await client.query("SELECT pg_notify('job_messages', $1)", [jobId]);
+      await client.query("COMMIT");
+      return { counters, alreadyVerified: false, ...binding };
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async getVerifiedInbound(jobId, seq) {
+    const { rows } = await this.pool.query(
+      `SELECT j.status, j.paid_msats, j.pending_payment_msats, j.summary, j.credit_id, j.draw_id
+         FROM jobs j
+         JOIN job_messages m ON m.job_id = j.id AND m.seq = $2
+        WHERE j.id = $1 AND m.status = 'verified'`,
+      [jobId, seq]
+    );
+    if (rows.length === 0) return void 0;
+    const row = rows[0];
+    return {
+      counters: rowToCounters(row),
+      alreadyVerified: true,
+      ...row.credit_id !== null && { creditId: row.credit_id },
+      ...row.draw_id !== null && { drawId: row.draw_id }
+    };
+  }
+  async markInboundFailed(jobId, seq, _reason) {
+    await this.pool.query(
+      "UPDATE job_messages SET status='failed-verify' WHERE job_id = $1 AND seq = $2 AND status = 'pending-verification'",
+      [jobId, seq]
+    );
+  }
+  async findStaleJobs(processingThresholdMs, awaitingThresholdMs, limit, capabilities) {
+    const staleClause = `(
+        ((status IN ('processing', 'working')) AND last_activity_at <= $1)
+        OR (status = 'awaiting-input' AND last_activity_at <= $2)
+      )`;
+    const sql = capabilities === null ? `SELECT * FROM jobs
+           WHERE ${staleClause}
+           ORDER BY last_activity_at ASC
+           LIMIT $3` : `SELECT * FROM jobs
+           WHERE ${staleClause}
+             AND capability = ANY($4::text[])
+           ORDER BY last_activity_at ASC
+           LIMIT $3`;
+    const params = capabilities === null ? [processingThresholdMs, awaitingThresholdMs, limit] : [processingThresholdMs, awaitingThresholdMs, limit, capabilities];
+    const { rows } = await this.pool.query(sql, params);
+    return rows.map((r) => rowToRecord(r));
+  }
+  async heartbeatActiveJobs(jobIds, now) {
+    if (jobIds.length === 0) return;
+    await this.pool.query(
+      `UPDATE jobs SET last_activity_at = $1
+       WHERE id = ANY($2::text[]) AND status IN ('processing', 'working')`,
+      [now, jobIds]
+    );
+  }
+  cancelStaleJob(jobId, expectedActivityBefore, reason, terminalStatus) {
+    return this.terminateJob(jobId, reason, terminalStatus, expectedActivityBefore);
+  }
+  cancelJob(jobId, reason) {
+    return this.terminateJob(jobId, reason, "cancelled", null);
+  }
+  async getCounters(jobId) {
+    const { rows } = await this.pool.query(
+      "SELECT status, paid_msats, pending_payment_msats, summary FROM jobs WHERE id = $1",
+      [jobId]
+    );
+    if (rows.length === 0) return void 0;
+    return rowToCounters(rows[0]);
+  }
+  async claimForProcessing(jobId) {
+    const { rowCount } = await this.pool.query(
+      "UPDATE jobs SET status='processing', last_activity_at=$2 WHERE id=$1 AND status='awaiting-input'",
+      [jobId, Date.now()]
+    );
+    return rowCount === 1;
+  }
+  async tryReactivationLock(jobId, fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rows } = await client.query(
+        "SELECT pg_try_advisory_xact_lock(hashtext($1)) AS got",
+        [jobId]
+      );
+      if (!rows[0]?.got) {
+        await client.query("ROLLBACK");
+        return { acquired: false };
+      }
+      try {
+        const result = await fn();
+        await client.query("COMMIT");
+        return { acquired: true, result };
+      } catch (err) {
+        await client.query("ROLLBACK");
+        throw err;
+      }
+    } finally {
+      client.release();
+    }
+  }
+  // ── Streaming ─────────────────────────────────────────────────────────
+  async subscribeMessages(jobId, afterSeq, onMessage) {
+    const sub = { afterSeq, cb: onMessage };
+    let subs = this.messageSubscribers.get(jobId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.messageSubscribers.set(jobId, subs);
+    }
+    subs.add(sub);
+    const existing = await this.getMessages(jobId, afterSeq);
+    for (const msg of existing) {
+      if (msg.seq > sub.afterSeq) {
+        sub.afterSeq = msg.seq;
+        onMessage(msg);
+      }
+    }
+    const subSet = subs;
+    return () => {
+      subSet.delete(sub);
+      if (subSet.size === 0) this.messageSubscribers.delete(jobId);
+    };
+  }
+  subscribeNotifications(jobId, onNotify) {
+    const sub = { cb: onNotify };
+    let subs = this.notifySubscribers.get(jobId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.notifySubscribers.set(jobId, subs);
+    }
+    subs.add(sub);
+    const subSet = subs;
+    return Promise.resolve(() => {
+      subSet.delete(sub);
+      if (subSet.size === 0) this.notifySubscribers.delete(jobId);
+    });
+  }
+  async getMessages(jobId, afterSeq) {
+    const { rows } = await this.pool.query(
+      "SELECT data FROM job_messages WHERE job_id = $1 AND seq > $2 AND status = 'verified' ORDER BY seq",
+      [jobId, afterSeq]
+    );
+    return rows.map((r) => typeof r.data === "string" ? JSON.parse(r.data) : r.data);
+  }
+  async initStreaming() {
+    this.listenChannel = new ListenChannel(this.pool, {
+      channel: JOB_MESSAGES_CHANNEL,
+      onNotification: (payload) => {
+        this.dispatch(payload);
+      },
+      onLost: (err) => {
+        console.warn(
+          JSON.stringify({
+            level: "job_messages_listen_lost",
+            error: err ? err.message : "client closed"
+          })
+        );
+      },
+      onReconnectFailed: (attempt, err) => {
+        console.warn(
+          JSON.stringify({
+            level: "job_messages_listen_connect_failed",
+            attempt,
+            error: err instanceof Error ? err.message : String(err)
+          })
+        );
+      }
+    });
+    await this.listenChannel.start();
+  }
+  async shutdownStreaming() {
+    if (this.listenChannel) {
+      await this.listenChannel.stop();
+      this.listenChannel = null;
+    }
+    this.messageSubscribers.clear();
+    this.notifySubscribers.clear();
+  }
+  dispatch(jobId) {
+    if (!jobId) return;
+    const notifySubs = this.notifySubscribers.get(jobId);
+    if (notifySubs) {
+      for (const sub of notifySubs) sub.cb();
+    }
+    const subs = this.messageSubscribers.get(jobId);
+    if (!subs || subs.size === 0) return;
+    const minSeq = Math.min(...[...subs].map((s) => s.afterSeq));
+    this.getMessages(jobId, minSeq).then((msgs) => {
+      for (const sub of subs) {
+        for (const msg of msgs) {
+          if (msg.seq > sub.afterSeq) {
+            sub.afterSeq = msg.seq;
+            sub.cb(msg);
+          }
+        }
+      }
+    }).catch(() => void 0);
+  }
+  // ── Internal ────────────────────────────────────────────────────────
+  /**
+   * Drive a non-terminal job to `terminalStatus` and append its final `cancel`
+   * message in one transaction. Backs both `cancelStaleJob` (which passes an
+   * `expectedActivityBefore` cutoff, so the flip only lands while the row is
+   * still stale — a live worker that heartbeats in between keeps its job) and
+   * `cancelJob` (which passes `null`: an operator/caller cancel is
+   * unconditional, gated only on the row still being non-terminal).
+   *
+   * The `SELECT … FOR UPDATE` makes the whole thing a CAS: two machines racing
+   * to terminate the same job serialise on the row lock, and the loser's
+   * status filter no longer matches. `pg_notify` fires inside the tx so the
+   * machine running the handler wakes as soon as the terminal status is
+   * visible.
+   */
+  async terminateJob(jobId, reason, terminalStatus, expectedActivityBefore) {
+    const staleOnly = expectedActivityBefore !== null;
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const { rows } = await client.query(
+        `SELECT next_seq FROM jobs
+         WHERE id = $1
+           AND status IN ('processing', 'working', 'awaiting-input')
+           ${staleOnly ? "AND last_activity_at <= $2" : ""}
+         FOR UPDATE`,
+        staleOnly ? [jobId, expectedActivityBefore] : [jobId]
+      );
+      if (rows.length === 0) {
+        await client.query("ROLLBACK");
+        return false;
+      }
+      const nextSeq = rows[0].next_seq;
+      const now = Date.now();
+      const cancelMsg = {
+        seq: nextSeq,
+        from: "provider",
+        timestamp: Math.floor(now / 1e3),
+        type: "cancel",
+        content: { reason }
+      };
+      await client.query(
+        "INSERT INTO job_messages (job_id, seq, data, status) VALUES ($1, $2, $3, 'verified')",
+        [jobId, nextSeq, JSON.stringify(cancelMsg)]
+      );
+      await client.query(
+        `UPDATE jobs SET
+           status = $6,
+           summary = COALESCE(summary, $2),
+           messages = COALESCE(messages, '[]'::jsonb) || $3::jsonb,
+           seq = $4,
+           next_seq = $4 + 1,
+           last_activity_at = $5
+         WHERE id = $1`,
+        [jobId, reason, JSON.stringify([cancelMsg]), nextSeq, now, terminalStatus]
+      );
+      await client.query("SELECT pg_notify('job_messages', $1)", [jobId]);
+      await client.query("COMMIT");
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+    await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [jobId]).catch(() => void 0);
+    return true;
+  }
+  async fetchCountersTx(client, jobId) {
+    const { rows } = await client.query(
+      "SELECT status, paid_msats, pending_payment_msats, summary FROM jobs WHERE id = $1",
+      [jobId]
+    );
+    if (rows.length === 0) return void 0;
+    return rowToCounters(rows[0]);
+  }
+  /**
+   * The credit binding on the job row, read inside Tx C (internal-review). Used on the
+   * paths that don't get it from a `RETURNING` — the `alreadyVerified` skip and
+   * a non-payment inbound.
+   */
+  async fetchCreditBindingTx(client, jobId) {
+    const { rows } = await client.query(
+      "SELECT credit_id, draw_id FROM jobs WHERE id = $1",
+      [jobId]
+    );
+    if (rows.length === 0) return {};
+    const row = rows[0];
+    return {
+      ...row.credit_id !== null && { creditId: row.credit_id },
+      ...row.draw_id !== null && { drawId: row.draw_id }
+    };
+  }
+};
+function requestIdAdvisoryLockKey(requesterPubkey, requestId) {
+  return createHash("sha256").update(requesterPubkey, "utf8").update("\0", "utf8").update(requestId, "utf8").digest().readBigInt64BE(0).toString();
+}
+function rowToCounters(row) {
+  return {
+    status: row.status,
+    paidMsats: Number(row.paid_msats),
+    pendingPaymentMsats: row.pending_payment_msats == null ? void 0 : Number(row.pending_payment_msats),
+    summary: row.summary ?? void 0
+  };
+}
+function rowToRecord(row) {
+  return {
+    id: row.id,
+    tags: row.tags,
+    // Pre-internal-review rows persisted before this migration shipped may carry NULL
+    // here. Fall back to "" so reactivation lookups surface a clear
+    // "unknown capability" error rather than crashing on a typed read.
+    capability: row.capability ?? "",
+    input: row.input,
+    params: row.params,
+    requesterId: row.requester_id,
+    requesterTokenHash: row.requester_token_hash ?? void 0,
+    requesterToken: row.requester_token ?? void 0,
+    requestFingerprint: row.request_fingerprint ?? void 0,
+    requesterPubkey: row.requester_pubkey ?? void 0,
+    requestId: row.request_id ?? void 0,
+    authRequestPath: row.auth_request_path ?? void 0,
+    status: row.status,
+    summary: row.summary,
+    messages: row.messages,
+    seq: row.seq,
+    paidMsats: Number(row.paid_msats),
+    paymentMint: row.payment_mint,
+    paymentRail: row.payment_rail ?? void 0,
+    paymentTxHash: row.payment_tx_hash,
+    paymentTransactionHash: row.payment_transaction_hash ?? void 0,
+    nativeAmount: row.native_amount,
+    nativeAsset: row.native_asset,
+    cashuFlow: row.cashu_flow,
+    creditId: row.credit_id ?? void 0,
+    drawId: row.draw_id ?? void 0,
+    fundingReceipt: row.funding_receipt ?? void 0,
+    fundingCredit: row.funding_credit ?? void 0,
+    receivedProofs: row.received_proofs,
+    pendingPaymentMsats: row.pending_payment_msats == null ? void 0 : Number(row.pending_payment_msats),
+    pendingMppChallengeIds: row.pending_mpp_challenge_ids ?? void 0,
+    pendingX402Nonce: row.pending_x402_nonce ?? void 0,
+    pendingX402AmountUsdcMicro: row.pending_x402_amount_usdc_micro ?? void 0,
+    pendingPaymentFiatMicro: row.pending_payment_fiat_micro == null ? void 0 : Number(row.pending_payment_fiat_micro),
+    pendingPaymentFiatCurrency: row.pending_payment_fiat_currency ?? void 0,
+    askedTopUpMicro: row.asked_topup_micro == null ? void 0 : Number(row.asked_topup_micro),
+    askedTopUpCurrency: row.asked_topup_currency ?? void 0,
+    topUpCapUnenforcedReason: row.topup_cap_unenforced_reason ?? void 0,
+    requiredMsats: row.required_msats == null ? void 0 : Number(row.required_msats),
+    receipt: row.receipt ?? void 0,
+    stepCache: row.step_cache,
+    state: row.state,
+    createdAt: Number(row.created_at),
+    lastActivityAt: Number(row.last_activity_at)
+  };
+}
+
+export {
+  PostgresJobStore
+};