@dvmkit/sdk 0.7.0-rc.9 → 0.8.1

package/dist/{chunk-2DE32RAW.js → chunk-NU5RWJ5B.js}

@@ -1,6 +1,6 @@
 import {
   diagnosticConsole
-} from "./chunk-5PLQOC4B.js";
+} from "./chunk-BFGQG4WY.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";

package/dist/chunk-OP7VCGQR.js

@@ -0,0 +1,47 @@
+import {
+  emitDiagnostic,
+  projectDiagnosticFields
+} from "./chunk-BFGQG4WY.js";
+
+// src/sdk/logger.ts
+function createConsoleLogger(_jobId) {
+  return {
+    debug(_message, data) {
+      emitDiagnostic("debug", "diagnostic.message", data);
+    },
+    info(_message, data) {
+      emitDiagnostic("info", "diagnostic.message", data);
+    },
+    warn(_message, data) {
+      emitDiagnostic("warn", "diagnostic.message", data);
+    },
+    error(_message, data) {
+      emitDiagnostic("error", "diagnostic.message", data);
+    }
+  };
+}
+function createStdoutLogger(context) {
+  const emit = (level) => (_message, data) => {
+    emitDiagnostic(level, "diagnostic.message", {
+      ...projectDiagnosticFields(context),
+      ...projectDiagnosticFields(data)
+    });
+  };
+  return {
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
+  };
+}
+function createNoopLogger() {
+  const noop = () => {
+  };
+  return { debug: noop, info: noop, warn: noop, error: noop };
+}
+
+export {
+  createConsoleLogger,
+  createStdoutLogger,
+  createNoopLogger
+};

package/dist/{chunk-QN3CQOE2.js → chunk-QKE5NDPF.js}

@@ -1,6 +1,9 @@
+import {
+  loggers
+} from "./chunk-IOQIXRGM.js";
 import {
   diagnosticConsole
-} from "./chunk-5PLQOC4B.js";
+} from "./chunk-BFGQG4WY.js";
 
 // src/sdk/server/mpp-setup.ts
 import { createHash, randomUUID } from "crypto";
@@ -533,7 +536,7 @@ function buildMppMethods(opts, env) {
       })
     );
     if (opts.tempoSession) {
-      methods.push(
+      methods.push(withAuthenticationOnlyValidation(
         tempo.session({
           recipient: opts.tempoRecipient,
           account: opts.tempoSession.account,
@@ -554,15 +557,51 @@ function buildMppMethods(opts, env) {
           chainId: opts.tempoSession.chainId ?? chainId,
           ...opts.tempoSession.getClient && { getClient: opts.tempoSession.getClient },
           ...opts.tempoSession.onSessionSettlement && {
-            onSessionSettlement: opts.tempoSession.onSessionSettlement
+            onSessionSettlement: claimingCloseSettlement(opts.tempoSession)
           }
         })
-      );
+      ));
     }
   }
   if (methods.length === 0 || !tempoConfiguration) return void 0;
   return { methods, tempoConfiguration };
 }
+function claimingCloseSettlement(session) {
+  const callback = session.onSessionSettlement;
+  const store = session.store;
+  if (session.hostedObligations || !store.getClose || !store.claimCloseReference) return callback;
+  return async (context) => {
+    if (context.trigger === "close") {
+      const intent = await store.getClose(context.channelId);
+      if (intent) {
+        let claimed = true;
+        try {
+          claimed = (await store.claimCloseReference(
+            context.channelId,
+            intent.drainId,
+            context.txHash
+          )).claimed;
+        } catch {
+        }
+        if (!claimed) return;
+      }
+    }
+    await callback(context);
+  };
+}
+function withAuthenticationOnlyValidation(method) {
+  if (method.validate) return method;
+  const validate = async ({ credential, request }) => ({
+    challenge: credential.challenge,
+    credential,
+    details: void 0,
+    intent: method.intent,
+    method: method.name,
+    request,
+    ...credential.source !== void 0 && { source: credential.source }
+  });
+  return { ...method, validate };
+}
 function resolveTempoNetwork(env) {
   const testnet = env.DVMKIT_TEMPO_TESTNET === "1" || env.DVMKIT_TEMPO_TESTNET === "true";
   const rawChainId = env.DVMKIT_TEMPO_CHAIN_ID?.trim();
@@ -612,6 +651,9 @@ function wrapMppx(mppx) {
   };
   return Object.assign(server, { issueChallenge });
 }
+var TEMPO_CLOSE_LOG_WINDOW = 5000n;
+var TEMPO_CLOSE_LOG_SLACK_MS = 10 * 60 * 1e3;
+var TEMPO_CLOSE_LOG_MAX_WINDOWS = 500;
 var DEFAULT_TEMPO_SESSION_CHAIN_OPS = {
   getChannelStatesBatch: TempoSession.Precompile.Chain.getChannelStatesBatch,
   settle: TempoSession.Server.settle,
@@ -621,7 +663,57 @@ var DEFAULT_TEMPO_SESSION_CHAIN_OPS = {
       "ChannelClosed",
       channelId
     )
-  )
+  ),
+  findChannelClose: async (client, channelId, escrowContract, notBeforeMs, startBlock) => {
+    const { getBlock, getBlockNumber, getLogs, getTransaction } = await import("viem/actions");
+    const eventNamed = (name) => {
+      const event = TempoSession.Precompile.escrowAbi.find(
+        (item) => item.type === "event" && item.name === name
+      );
+      if (!event || event.type !== "event") throw new Error(`Tempo escrow ABI has no ${name} event`);
+      return event;
+    };
+    const closedEvent = eventNamed("ChannelClosed");
+    const requestedEvent = eventNamed("CloseRequested");
+    const cancelledEvent = eventNamed("CloseRequestCancelled");
+    const beforeBound = async (blockNumber) => Number((await getBlock(client, { blockNumber })).timestamp) * 1e3 < notBeforeMs - TEMPO_CLOSE_LOG_SLACK_MS;
+    if (startBlock !== void 0 && await beforeBound(startBlock)) {
+      return { outcome: "none", stoppedAt: startBlock };
+    }
+    let toBlock = startBlock ?? await getBlockNumber(client);
+    for (let window = 0; window < TEMPO_CLOSE_LOG_MAX_WINDOWS; window += 1) {
+      const fromBlock = toBlock >= TEMPO_CLOSE_LOG_WINDOW ? toBlock - TEMPO_CLOSE_LOG_WINDOW + 1n : 0n;
+      const range = { address: escrowContract, args: { channelId }, fromBlock, toBlock };
+      const [closed, requested, cancelled] = await Promise.all([
+        getLogs(client, { ...range, event: closedEvent }),
+        getLogs(client, { ...range, event: requestedEvent }),
+        getLogs(client, { ...range, event: cancelledEvent })
+      ]);
+      const newest = [
+        ...closed.map((log) => ({ log, kind: "closed" })),
+        ...requested.map((log) => ({ log, kind: "requested" })),
+        ...cancelled.map((log) => ({ log, kind: "cancelled" }))
+      ].filter(({ log }) => log.transactionHash && log.blockNumber !== null).sort((left, right) => left.log.blockNumber === right.log.blockNumber ? Number(right.log.logIndex ?? 0) - Number(left.log.logIndex ?? 0) : right.log.blockNumber > left.log.blockNumber ? 1 : -1)[0];
+      if (newest?.kind === "closed") {
+        const transaction = await getTransaction(client, {
+          hash: newest.log.transactionHash
+        });
+        return { outcome: "closed", txHash: newest.log.transactionHash, sender: transaction.from };
+      }
+      if (newest?.kind === "requested") {
+        const graceEnd = newest.log.args.closeGraceEnd;
+        const head = await getBlock(client, { blockTag: "latest" });
+        if (graceEnd === void 0 || head.timestamp < graceEnd) return { outcome: "none" };
+        return { outcome: "exit_requested" };
+      }
+      if (newest) return { outcome: "none", stoppedAt: 0n };
+      if (fromBlock === 0n || await beforeBound(fromBlock)) {
+        return { outcome: "none", stoppedAt: fromBlock };
+      }
+      toBlock = fromBlock - 1n;
+    }
+    return { outcome: "paused", resumeAt: toBlock };
+  }
 };
 function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   let creditLedger;
@@ -642,6 +734,102 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   }
   if (store) {
     Object.assign(mppx, {
+      assertTempoSessionCloseVoucher: async (voucher) => {
+        const descriptor = readChannelDescriptor(voucher.descriptor);
+        if (!descriptor) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "descriptor required for TIP-1034 session action"
+          });
+        }
+        const details = isStateRecord(voucher.request.methodDetails) ? voucher.request.methodDetails : {};
+        const stored = await store.get(voucher.channelId.toLowerCase());
+        const state = readTempoSessionState(stored);
+        const chainId = typeof details.chainId === "number" ? details.chainId : state?.chainId;
+        const escrow = typeof details.escrowContract === "string" ? details.escrowContract : state?.escrowContract;
+        if (chainId === void 0 || escrow === void 0) {
+          throw new MppxErrors.VerificationFailedError({ reason: "invalid session request" });
+        }
+        const computed = TempoSession.Precompile.Channel.computeId({
+          ...descriptor,
+          chainId,
+          escrow
+        });
+        if (computed.toLowerCase() !== voucher.channelId.toLowerCase()) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor does not match channelId"
+          });
+        }
+        if (!sameHex(descriptor.payee, voucher.request.recipient)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor payee does not match server destination"
+          });
+        }
+        if (!sameHex(descriptor.token, voucher.request.currency)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor token does not match server token"
+          });
+        }
+        if (!sameHex(descriptor.operator, details.operator ?? ZERO_ADDRESS)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel descriptor operator does not match server operator"
+          });
+        }
+        if (!state || !isStateRecord(stored)) {
+          throw new MppxErrors.ChannelNotFoundError({ reason: "channel not found" });
+        }
+        if (stored.backend !== "precompile") {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "channel is not precompile-backed"
+          });
+        }
+        const storedDescriptor = readChannelDescriptor(stored.descriptor);
+        if (!storedDescriptor || !sameDescriptor(descriptor, storedDescriptor)) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: "credential descriptor does not match stored channel"
+          });
+        }
+        const signer = stored.authorizedSigner;
+        if (typeof signer !== "string" || !HEX_ADDRESS_RE.test(signer)) {
+          throw new MppxErrors.ChannelNotFoundError({ reason: "channel not found" });
+        }
+        if (state.finalized) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel is already finalized" });
+        }
+        if (state.closeRequestedAt !== 0n) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel has a pending close request" });
+        }
+        if (state.deposit === 0n && (voucher.cumulativeAmount !== 0n || state.spent !== 0n)) {
+          throw new MppxErrors.ChannelClosedError({ reason: "channel deposit is zero (settled)" });
+        }
+        if (voucher.cumulativeAmount < state.spent) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: `close voucher amount must be >= ${state.spent} (spent)`
+          });
+        }
+        if (voucher.cumulativeAmount < state.settledOnChain) {
+          throw new MppxErrors.VerificationFailedError({
+            reason: `close voucher amount must be >= ${state.settledOnChain} (on-chain settled)`
+          });
+        }
+        const valid = TempoSession.Precompile.Voucher.verifyVoucher(
+          escrow,
+          chainId,
+          {
+            channelId: voucher.channelId,
+            cumulativeAmount: voucher.cumulativeAmount,
+            signature: voucher.signature
+          },
+          signer
+        );
+        if (!valid) {
+          throw new MppxErrors.InvalidSignatureError({ reason: "invalid voucher signature" });
+        }
+        if (maxBigInt(state.spent, state.settledOnChain) > state.deposit) {
+          throw new MppxErrors.AmountExceedsDepositError({
+            reason: "close capture amount exceeds on-chain deposit"
+          });
+        }
+      },
       getTempoSessionSpent: async (channelId) => {
         const state = readTempoSessionState(await store.get(channelId.toLowerCase()));
         if (!state) throw new Error(`Tempo session channel ${channelId} not found`);
@@ -963,6 +1151,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
         }
       }
     }
+    await reconcileUnsubmittedCloses();
     return { scanned: rows.length, closeRequested, settled, inFlight };
   };
   const recoverTempoSessionClose = async (channelId, drainId) => {
@@ -970,7 +1159,8 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     const intent = await store.getClose(channelId);
     if (intent?.drainId !== drainId) return null;
     if (intent.reference) return intent.reference;
-    const current = readTempoSessionState(await store.get(channelId));
+    const stored = await store.get(channelId);
+    const current = readTempoSessionState(stored);
     if (!current) throw new Error(`Tempo session channel ${channelId} not found`);
     let finalized = current.finalized;
     if (!finalized) {
@@ -984,9 +1174,150 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
       finalized = chainState.deposit === 0n;
     }
     if (!finalized) return null;
-    const recovered = await store.confirmClose(channelId, drainId, `channel:${channelId}`);
+    const pending = await config.hostedObligations?.pendingTempoClose(channelId, drainId);
+    const selfHostedReport = !config.hostedObligations && !!config.onSessionSettlement && !!store.claimCloseReference && !!store.getCloseRecovery;
+    let reference = pending?.txHash ?? void 0;
+    if (pending && !reference || selfHostedReport) {
+      const recovery = await store.getCloseRecovery?.(channelId);
+      const notBeforeMs = pending?.reservedAtMs ?? recovery?.updatedAtMs;
+      if (notBeforeMs === void 0) throw new Error(`Tempo session close intent ${channelId} not found`);
+      const obligations = config.hostedObligations;
+      const found = await findFinalizedClose(current, stored, drainId, notBeforeMs, pending ? {
+        from: pending.searchBefore,
+        save: (resumeAt) => obligations.recordTempoCloseSearch(pending.id, resumeAt)
+      } : {
+        from: recovery?.searchBefore ?? null,
+        save: (resumeAt) => store.recordCloseSearch?.(channelId, drainId, resumeAt)
+      });
+      if (pending) {
+        reference = await settleUnsubmittedClose(current.channelId, drainId, pending.id, found);
+      } else if (found.outcome === "ours") {
+        const claimed = await store.claimCloseReference(channelId, drainId, found.txHash);
+        if (claimed.claimed) {
+          await reportRecoveredClose(current, found.txHash, recovery?.settledBeforeClose ?? null);
+        }
+        return claimed.reference;
+      } else if (found.outcome === "none") {
+        loggers.tempo.warn("tempo_session_close_recovery_unmatched", {
+          channel_id: current.channelId,
+          drain_id: drainId
+        });
+      }
+    }
+    const recovered = await store.confirmClose(
+      channelId,
+      drainId,
+      reference ?? `channel:${channelId}`
+    );
     return recovered.reference;
   };
+  const findFinalizedClose = async (current, stored, drainId, notBeforeMs, cursor) => {
+    const client = await getClient({ chainId: current.chainId });
+    const search = await chainOps.findChannelClose(
+      client,
+      current.channelId,
+      current.escrowContract,
+      notBeforeMs,
+      cursor.from ?? void 0
+    );
+    if (search.outcome === "paused") {
+      await cursor.save(search.resumeAt);
+      loggers.tempo.warn("tempo_session_close_recovery_search_paused", {
+        channel_id: current.channelId,
+        drain_id: drainId,
+        resume_block: search.resumeAt.toString()
+      });
+      throw new Error(`Tempo close search for channel ${current.channelId} continues on the next poll`);
+    }
+    if (search.outcome === "closed") {
+      return cooperativeCloseSenders(stored, config.account.address).has(search.sender.toLowerCase()) ? { outcome: "ours", txHash: search.txHash } : { outcome: "exit" };
+    }
+    if (search.outcome === "exit_requested") return { outcome: "exit" };
+    if (search.stoppedAt !== void 0) await cursor.save(search.stoppedAt);
+    return { outcome: "none" };
+  };
+  const settleUnsubmittedClose = async (channelId, drainId, obligationId, found) => {
+    const obligations = config.hostedObligations;
+    if (found.outcome === "ours") {
+      await obligations.recordSubmitted(obligationId, found.txHash);
+      return found.txHash;
+    }
+    if (found.outcome === "exit") {
+      if (await obligations.resolveTempoCloseExit(obligationId)) {
+        loggers.tempo.warn("tempo_session_close_exit_resolved", {
+          channel_id: channelId,
+          drain_id: drainId,
+          obligation_id: obligationId
+        });
+      }
+      return void 0;
+    }
+    loggers.tempo.warn("tempo_session_close_recovery_unmatched", {
+      channel_id: channelId,
+      drain_id: drainId,
+      obligation_id: obligationId
+    });
+    return void 0;
+  };
+  const reconcileUnsubmittedCloses = async () => {
+    const obligations = config.hostedObligations;
+    if (!obligations) return;
+    for (const row of await obligations.unsubmittedTempoCloses()) {
+      try {
+        const stored = await store.get(row.channelId);
+        const current = readTempoSessionState(stored);
+        if (!current) continue;
+        if (!current.finalized) {
+          const client = await getClient({ chainId: current.chainId });
+          const [chainState] = await chainOps.getChannelStatesBatch(
+            client,
+            [current.channelId],
+            current.escrowContract
+          );
+          await terminalizeLostBacking(current, chainState);
+          if (!await writeBackChainState(current, chainState)) continue;
+        }
+        const found = await findFinalizedClose(current, stored, row.drainId, row.reservedAtMs, {
+          from: row.searchBefore,
+          save: (resumeAt) => obligations.recordTempoCloseSearch(row.id, resumeAt)
+        });
+        await settleUnsubmittedClose(current.channelId, row.drainId, row.id, found);
+      } catch (error) {
+        loggers.tempo.warn("tempo_session_close_reconcile_failed", {
+          channel_id: row.channelId,
+          drain_id: row.drainId,
+          obligation_id: row.id,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+  const reportRecoveredClose = async (channel, txHash, settledBeforeClose) => {
+    const client = await getClient({ chainId: channel.chainId });
+    const { settledToPayee } = await chainOps.readChannelClose(client, channel.channelId, txHash);
+    if (settledBeforeClose === null || settledToPayee < settledBeforeClose) {
+      loggers.tempo.warn("tempo_session_close_settlement_unreported", {
+        channel_id: channel.channelId,
+        tx_hash: txHash
+      });
+      return;
+    }
+    try {
+      await config.onSessionSettlement({
+        txHash,
+        channelId: channel.channelId,
+        trigger: "close",
+        amount: settledToPayee,
+        delta: settledToPayee - settledBeforeClose
+      });
+    } catch (error) {
+      loggers.tempo.warn("tempo_session_close_settlement_callback_failed", {
+        channel_id: channel.channelId,
+        tx_hash: txHash,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
   const getClose = store.getClose?.bind(store) ?? (() => Promise.resolve(null));
   const beginClose = store.beginClose?.bind(store);
   const withCloseIntent = store.withCloseIntent?.bind(store);
@@ -995,6 +1326,7 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
   const confirmClose = store.confirmClose?.bind(store);
   return Object.assign(mppx, {
     sweepTempoSessions,
+    ...config?.hostedObligations && { reconcileTempoSessionCloses: reconcileUnsubmittedCloses },
     ...beginClose && {
       beginTempoSessionClose: async (channelId, drainId) => {
         await beginClose(channelId, drainId);
@@ -1014,6 +1346,14 @@ function attachTempoSessionRuntime(mppx, config, chainOpOverrides = {}) {
     }
   });
 }
+function cooperativeCloseSenders(stored, fallback) {
+  const record = stored && typeof stored === "object" ? stored : {};
+  const descriptor = record.descriptor && typeof record.descriptor === "object" ? record.descriptor : {};
+  const senders = new Set(
+    [record.operator, record.payee, descriptor.operator, descriptor.payee].filter((value) => typeof value === "string" && HEX_ADDRESS_RE.test(value)).map((value) => value.toLowerCase())
+  );
+  return senders.size > 0 ? senders : /* @__PURE__ */ new Set([fallback.toLowerCase()]);
+}
 function readTempoSessionState(value) {
   if (!value || typeof value !== "object") return void 0;
   const state = value;
@@ -1028,6 +1368,27 @@ function maxBigInt(left, right) {
 function isStateRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+var ZERO_ADDRESS = `0x${"00".repeat(20)}`;
+var DESCRIPTOR_ADDRESSES = ["payer", "payee", "operator", "token", "authorizedSigner"];
+var DESCRIPTOR_WORDS = ["salt", "expiringNonceHash"];
+function readChannelDescriptor(value) {
+  if (!isStateRecord(value)) return void 0;
+  for (const field of DESCRIPTOR_ADDRESSES) {
+    if (typeof value[field] !== "string" || !HEX_ADDRESS_RE.test(value[field])) return void 0;
+  }
+  for (const field of DESCRIPTOR_WORDS) {
+    if (typeof value[field] !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value[field])) {
+      return void 0;
+    }
+  }
+  return value;
+}
+function sameHex(left, right) {
+  return typeof left === "string" && typeof right === "string" && left.toLowerCase() === right.toLowerCase();
+}
+function sameDescriptor(left, right) {
+  return DESCRIPTOR_ADDRESSES.every((field) => sameHex(left[field], right[field])) && DESCRIPTOR_WORDS.every((field) => sameHex(left[field], right[field]));
+}
 function tempoSettlementDue(args) {
   const { channel, chainSettled, forcedClose, intervalMs } = args;
   const settlementBoundary = Date.parse(channel.lastSettlementAt ?? channel.createdAt ?? "");

package/dist/{chunk-7RZEJJTN.js → chunk-RSNC5T6C.js}

@@ -1,10 +1,10 @@
 import {
   callerLoggers
-} from "./chunk-KXWROQGK.js";
+} from "./chunk-66HGCPBU.js";
 import {
   diagnosticConsole,
   projectSpanRow
-} from "./chunk-5PLQOC4B.js";
+} from "./chunk-BFGQG4WY.js";
 
 // src/lib/x402/env.ts
 import { isAddress } from "viem";

package/dist/{chunk-2GTLF74N.js → chunk-UDJNZ3UG.js}

@@ -1,6 +1,6 @@
 import {
   validateCurrency
-} from "./chunk-5CSR33B5.js";
+} from "./chunk-2U6LAASN.js";
 
 // src/sdk/pricing/upfront.ts
 function buildUpfront(input) {

package/dist/{chunk-WGK5KZ6S.js → chunk-UVS7MRJX.js}

@@ -2,7 +2,7 @@ import {
   createX402FacilitatorAuthHeaders,
   settleWithFacilitator,
   verifyWithFacilitator
-} from "./chunk-FYETJDBB.js";
+} from "./chunk-AVV5SYGO.js";
 import {
   buildPaymentRequirements,
   decodePayment,
@@ -12,10 +12,10 @@ import {
 } from "./chunk-62FI3NJF.js";
 import {
   callerLoggers
-} from "./chunk-KXWROQGK.js";
+} from "./chunk-66HGCPBU.js";
 import {
   diagnosticConsole
-} from "./chunk-5PLQOC4B.js";
+} from "./chunk-BFGQG4WY.js";
 
 // src/lib/x402/verify.ts
 async function verifyX402Payment(paymentHeader, config, requiredUsdcMicro, resource, btcUsdRate, exactVersions = { v1: true, v2: true }) {

package/dist/{chunk-HU6ZMQDN.js → chunk-UWGBI5WK.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-YG7G4DPZ.js";
 import {
   withPostgresTransactionRecovery
-} from "./chunk-QM2OS3NJ.js";
+} from "./chunk-7PM4R4GD.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
@@ -69,6 +69,11 @@ var PostgresTempoSessionStore = class {
         `ALTER TABLE mpp_tempo_close_intents
            ADD COLUMN IF NOT EXISTS forecast_pending BOOLEAN NOT NULL DEFAULT FALSE`
       );
+      await this.pool.query(
+        `ALTER TABLE mpp_tempo_close_intents
+           ADD COLUMN IF NOT EXISTS close_search_before BIGINT,
+           ADD COLUMN IF NOT EXISTS settled_before_close NUMERIC(78,0)`
+      );
     });
   }
   async get(key) {
@@ -273,6 +278,17 @@ var PostgresTempoSessionStore = class {
       if (rows[0].forecast_pending !== false) {
         throw new Error(`Tempo session drain ${drainId} refund forecast is still pending`);
       }
+      const channel = await tx.query(
+        "SELECT state_json FROM mpp_tempo_channels WHERE channel_key = $1",
+        [channelId.toLowerCase()]
+      );
+      const state = channel.rows[0] ? parseStoreValue(channel.rows[0].state_json) : null;
+      const settled = state?.settledOnChain;
+      await tx.query(
+        `UPDATE mpp_tempo_close_intents SET settled_before_close = $3
+          WHERE channel_id = $1 AND drain_id = $2`,
+        [channelId.toLowerCase(), drainId, typeof settled === "bigint" ? settled.toString() : null]
+      );
       return record;
     });
   }
@@ -357,6 +373,47 @@ var PostgresTempoSessionStore = class {
     if (!rows[0]) throw new Error(`Tempo session close intent not found`);
     return closeRecord(rows[0]);
   }
+  /** Set a close's reference only if none is set, reporting whether this call set it. */
+  async claimCloseReference(channelId, drainId, reference) {
+    const { rows } = await this.pool.query(
+      `UPDATE mpp_tempo_close_intents
+          SET reference = $3, updated_at = $4
+        WHERE channel_id = $1 AND drain_id = $2 AND forecast_pending = FALSE
+          AND reference IS NULL
+        RETURNING reference`,
+      [channelId.toLowerCase(), drainId, reference, Date.now()]
+    );
+    if (rows[0]) return { reference: rows[0].reference, claimed: true };
+    const current = await this.getClose(channelId);
+    if (current?.drainId !== drainId || current.reference === null) {
+      throw new Error(`Tempo session close intent not found`);
+    }
+    return { reference: current.reference, claimed: false };
+  }
+  async getCloseRecovery(channelId) {
+    const { rows } = await this.pool.query(
+      `SELECT updated_at, close_search_before, settled_before_close
+         FROM mpp_tempo_close_intents
+        WHERE channel_id = $1`,
+      [channelId.toLowerCase()]
+    );
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      updatedAtMs: Number(row.updated_at),
+      searchBefore: row.close_search_before === null ? null : BigInt(row.close_search_before),
+      settledBeforeClose: row.settled_before_close === null ? null : BigInt(row.settled_before_close)
+    };
+  }
+  /** Record where a paused close search resumes; the cursor only moves back. */
+  async recordCloseSearch(channelId, drainId, resumeAt) {
+    await this.pool.query(
+      `UPDATE mpp_tempo_close_intents
+          SET close_search_before = LEAST(COALESCE(close_search_before, $3), $3)
+        WHERE channel_id = $1 AND drain_id = $2`,
+      [channelId.toLowerCase(), drainId, resumeAt.toString()]
+    );
+  }
   async runCloseIntentTransaction(channelId, drainId, operation) {
     return this.transaction("tempo_session.close_intent", async (client) => {
       const record = await this.writeCloseIntent(client, channelId, drainId);

package/dist/{chunk-OFSOLHRX.js → chunk-WMGXJQI3.js}

@@ -6,7 +6,7 @@ import {
 import {
   redactUrl,
   redactUrlsInText
-} from "./chunk-KXWROQGK.js";
+} from "./chunk-FUJ36YDV.js";
 import {
   DvmError,
   x402NetworkByCaip2,

package/dist/{chunk-5TIFEMHJ.js → chunk-ZEPJF4JC.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-UKD3R2KU.js";
 import {
   callerLoggers
-} from "./chunk-KXWROQGK.js";
+} from "./chunk-66HGCPBU.js";
 import {
   DvmError
 } from "./chunk-BPYMEMQX.js";
 import {
   diagnosticConsole
-} from "./chunk-5PLQOC4B.js";
+} from "./chunk-BFGQG4WY.js";
 
 // src/lib/cashu/lock-pubkey.ts
 function toLockPubkey(raw) {

package/dist/{content-retention-U7dJM7Ph.d.ts → content-retention-B7ddtJ2y.d.ts}

@@ -1,4 +1,4 @@
-import { b as JobStore, J as JobRecord } from './job-store-DjgN2AOk.js';
+import { b as JobStore, J as JobRecord } from './job-store-Cq21JT37.js';
 
 /** Authenticated caller metadata; omitted fields on older services mean unknown. */
 interface JobContentMetadata {