@dvmkit/sdk 0.8.0 → 0.8.1

package/dist/{step-cache-BOWAn_BH.d.ts → step-cache-CR12EZ1Q.d.ts}

@@ -1227,13 +1227,51 @@ declare class HostedSettlementReportObligations {
         };
     }): Promise<HostedEffectReservation | null>;
     reserveTempo(channelId: string, operation: "settle" | "close", drainId?: string): Promise<HostedEffectReservation>;
+    /**
+     * Retire a close reservation that never recorded a transaction and reserve
+     * the drain's next attempt, in one transaction, so the drain always keeps one
+     * outstanding close obligation. A close from the retired attempt that lands
+     * late is a close of the same channel: `recordSubmitted` on the retired row
+     * writes it onto the successor, and recovery attaches it there if that
+     * attempt never got to write, so it is reported once.
+     *
+     * The caller has just read the channel open on chain. The age bound only
+     * spares a reservation young enough to be inside its first receipt wait; an
+     * attempt slowed past it by a degraded RPC can still be running.
+     */
+    releaseStaleTempoClose(id: string, channelId: string, drainId: string, limits: {
+        staleAfterMs: number;
+        maxReleases: number;
+    }): Promise<{
+        outcome: "reserved";
+        id: string;
+        releases: number;
+    } | {
+        outcome: "in_flight";
+    } | {
+        outcome: "exhausted";
+        releases: number;
+    }>;
+    /**
+     * Resolve an unsubmitted close reservation whose channel the payer exited
+     * on its own: no cooperative close of ours can land on a finalized channel.
+     */
+    resolveTempoCloseExit(id: string): Promise<boolean>;
+    private reserveTempoIn;
     findPendingTempo(channelId: string, operation: "settle" | "close"): Promise<ObligationRow | undefined>;
     /** The original close obligation reserved for this drain, while its report is outstanding. */
     pendingTempoClose(channelId: string, drainId: string): Promise<{
         id: string;
         txHash: string | null;
         reservedAtMs: number;
+        searchBefore: bigint | null;
     } | undefined>;
+    /**
+     * Where the next search for this close obligation's transaction resumes. It
+     * lives on the obligation, not the drain's close intent, because releasing
+     * the drain deletes the intent while the obligation still needs the search.
+     */
+    recordTempoCloseSearch(id: string, resumeAt: bigint): Promise<void>;
     submittedIds(rail: Rail, operation: Operation, txHash: string, batchId?: string): Promise<string[]>;
     refundClaimDelta(txHash: string, channelId: string): Promise<bigint>;
     assertReservedTempoClose(id: string, channelId: string): Promise<void>;
@@ -1242,6 +1280,26 @@ declare class HostedSettlementReportObligations {
     reserveOpenX402Settlement(): Promise<HostedEffectReservation>;
     private ensureOpenX402Batch;
     recordSubmitted(id: string, txHash: string): Promise<void>;
+    /**
+     * Close reservations that never recorded a transaction, oldest first. Each
+     * one owes a payout report only if its close lands, so it stays unresolved
+     * until a reconcile reads how its channel finalized.
+     */
+    unsubmittedTempoCloses(limit?: number): Promise<Array<{
+        id: string;
+        channelId: string;
+        drainId: string;
+        reservedAtMs: number;
+        searchBefore: bigint | null;
+    }>>;
+    /**
+     * A retired close reservation's attempt can still be running when its
+     * successor is reserved, and its close can land. The close is the same
+     * channel's, so it belongs to the drain's outstanding obligation; writing it
+     * onto the retired row would leave that obligation without a transaction and
+     * the payout unreported.
+     */
+    private successorOfRetiredClose;
     recoveryCandidates(): Promise<HostedRecoverableEffect[]>;
     recoverOriginalX402Refunds(): Promise<Array<{
         id: string;
@@ -4424,6 +4482,18 @@ declare class PostgresTempoSessionStore implements Store.AtomicStore {
     getClose(channelId: string): Promise<TempoSessionCloseRecord | null>;
     /** Persist proof that a cooperative close reached terminal chain state. */
     confirmClose(channelId: string, drainId: string, reference: string): Promise<TempoSessionCloseRecord>;
+    /** Set a close's reference only if none is set, reporting whether this call set it. */
+    claimCloseReference(channelId: string, drainId: string, reference: string): Promise<{
+        reference: string | null;
+        claimed: boolean;
+    }>;
+    getCloseRecovery(channelId: string): Promise<{
+        updatedAtMs: number;
+        searchBefore: bigint | null;
+        settledBeforeClose: bigint | null;
+    } | null>;
+    /** Record where a paused close search resumes; the cursor only moves back. */
+    recordCloseSearch(channelId: string, drainId: string, resumeAt: bigint): Promise<void>;
     private runCloseIntentTransaction;
     private transaction;
     private writeCloseIntent;
@@ -4566,6 +4636,13 @@ interface MppxServer {
         settled: number;
         inFlight: number;
     }>;
+    /**
+     * Bring hosted close obligations whose channel has finalized to what the
+     * chain shows, without settling anything. The sweep runs it too; the hosting
+     * closure runs it alone before it decides, since those obligations block
+     * the closure certificate.
+     */
+    reconcileTempoSessionCloses?: () => Promise<void>;
     /**
      * Reconcile and, if the channel is at risk, settle exactly one TIP-1034
      * channel. The forced-close protection path: a verified on-chain
@@ -4760,12 +4837,39 @@ interface TempoSessionChainOps {
     }): Promise<Hex>;
     readChannelClose(client: Client, channelId: Hex, txHash: Hex): Promise<TempoChannelCloseAmounts>;
     /**
-     * The transaction that emitted this channel's `ChannelClosed`, searched back
-     * from the chain head no further than blocks older than `notBeforeMs`. Null
-     * only when that whole range was searched and holds no close.
+     * Search back for how this channel finalized: the newest `ChannelClosed`,
+     * `CloseRequested` or `CloseRequestCancelled` log, from `startBlock` (the
+     * chain head when omitted) down to blocks older than `notBeforeMs`. One call searches a bounded number of
+     * windows; `paused` names the block the next call resumes from.
      */
-    findChannelClose(client: Client, channelId: Hex, escrowContract: `0x${string}`, notBeforeMs: number): Promise<Hex | null>;
+    findChannelClose(client: Client, channelId: Hex, escrowContract: `0x${string}`, notBeforeMs: number, startBlock?: bigint): Promise<TempoChannelCloseSearch>;
 }
+type TempoChannelCloseSearch = 
+/** A `ChannelClosed` log, with the address that sent its transaction. */
+{
+    outcome: "closed";
+    txHash: Hex;
+    sender: `0x${string}`;
+}
+/**
+ * The payer's `requestClose` is newer than any `ChannelClosed` and was not
+ * cancelled: a timed exit.
+ */
+ | {
+    outcome: "exit_requested";
+}
+/**
+ * Nothing read shows what finalized the channel; a later search resumes at
+ * `stoppedAt`, which never leads below the reservation's time bound. Without
+ * it the range may still hold the answer, and a later search starts over.
+ */
+ | {
+    outcome: "none";
+    stoppedAt?: bigint;
+} | {
+    outcome: "paused";
+    resumeAt: bigint;
+};
 declare function attachTempoSessionRuntime(mppx: MppxServer, config: MppOpts["tempoSession"], chainOpOverrides?: Partial<TempoSessionChainOps>): MppxServer;
 /** Test-only seams for deterministic watcher coverage without a live Tempo RPC. */
 declare const _testing: {

package/dist/{tempo-charge-store-NKXJ2AXE.js → tempo-charge-store-XEGJYM3G.js}

@@ -1,8 +1,8 @@
 import {
   PostgresTempoChargeStore
-} from "./chunk-TFYY5APM.js";
+} from "./chunk-NA2KOR6G.js";
 import "./chunk-YG7G4DPZ.js";
-import "./chunk-DZQYQN2X.js";
+import "./chunk-BFGQG4WY.js";
 import "./chunk-COYKJRMM.js";
 export {
   PostgresTempoChargeStore

package/dist/{tempo-session-store-ZSDQIWSU.js → tempo-session-store-3WTDOO7H.js}

@@ -1,10 +1,10 @@
 import {
   PostgresTempoSessionStore,
   assertMonotonicTransition
-} from "./chunk-P5WEZXJ2.js";
+} from "./chunk-UWGBI5WK.js";
 import "./chunk-YG7G4DPZ.js";
-import "./chunk-6FEHRZO7.js";
-import "./chunk-DZQYQN2X.js";
+import "./chunk-7PM4R4GD.js";
+import "./chunk-BFGQG4WY.js";
 import "./chunk-COYKJRMM.js";
 export {
   PostgresTempoSessionStore,

package/dist/testing/index.d.ts

@@ -1,6 +1,6 @@
-import { C as ContentHoldHistory, a as ContentHoldMutation } from '../content-retention-D2K4MKNO.js';
-import { a0 as JobReceipt, a5 as Message, a1 as MessageType, K as KVStore, L as Logger, v as ResponseContent, P as PaymentContent, S as SDKJobContext } from '../step-cache-BOWAn_BH.js';
-import { c as StreamableJobStore, R as ReceiptIssuingStore, J as JobRecord, d as RequestIdClaim, e as RequestIdClaimResult, f as JobRetentionCursor, O as OutgoingMessage, A as AppendOutgoingOptions, P as PaymentCreditDelta, V as VerifyAndCreditResult, g as JobCounters } from '../job-store-DCvJQUX0.js';
+import { C as ContentHoldHistory, a as ContentHoldMutation } from '../content-retention-B7ddtJ2y.js';
+import { a0 as JobReceipt, a5 as Message, a1 as MessageType, K as KVStore, L as Logger, v as ResponseContent, P as PaymentContent, S as SDKJobContext } from '../step-cache-CR12EZ1Q.js';
+import { c as StreamableJobStore, R as ReceiptIssuingStore, J as JobRecord, d as RequestIdClaim, e as RequestIdClaimResult, f as JobRetentionCursor, O as OutgoingMessage, A as AppendOutgoingOptions, P as PaymentCreditDelta, V as VerifyAndCreditResult, g as JobCounters } from '../job-store-Cq21JT37.js';
 import 'hono';
 import 'mppx';
 import '@x402/core/server';

package/dist/testing/index.js

@@ -4,22 +4,22 @@ import {
 import {
   MemoryJobStore,
   createInstrumentedFetch
-} from "../chunk-I6PHA54S.js";
+} from "../chunk-IHQUBATH.js";
 import {
   JobCancelledError
 } from "../chunk-AFV77S4C.js";
 import {
   createNoopLogger
-} from "../chunk-IFWUWHTW.js";
-import "../chunk-BL6LRWXD.js";
+} from "../chunk-OP7VCGQR.js";
+import "../chunk-IOQIXRGM.js";
 import "../chunk-FUJ36YDV.js";
 import "../chunk-66HGCPBU.js";
 import "../chunk-BQJIFRAZ.js";
-import "../chunk-XXLUIXPO.js";
+import "../chunk-UDJNZ3UG.js";
 import {
   validateCurrency
-} from "../chunk-5CQKSLAU.js";
-import "../chunk-DZQYQN2X.js";
+} from "../chunk-2U6LAASN.js";
+import "../chunk-BFGQG4WY.js";
 
 // src/sdk/testing/test-context.ts
 function createTestContext(opts) {

package/dist/{usd-MAtMp3DB.d.ts → usd-s_VZ_eS7.d.ts}

@@ -1,4 +1,4 @@
-import { C as Currency } from './step-cache-BOWAn_BH.js';
+import { C as Currency } from './step-cache-CR12EZ1Q.js';
 
 /**
  * Thrown by `fiatToSatsCeil` / `satsToFiat` when the supplied `ratePerBtc` is

package/dist/{x402-Q4S36NHQ.js → x402-HQ5GRQZU.js}

@@ -6,8 +6,8 @@ import {
 } from "./chunk-WMGXJQI3.js";
 import {
   verifyX402Payment
-} from "./chunk-YPSJU3OH.js";
-import "./chunk-ATXDKX6F.js";
+} from "./chunk-UVS7MRJX.js";
+import "./chunk-AVV5SYGO.js";
 import {
   X402_DEFAULT_FACILITATOR,
   X402_DEFAULT_NETWORK,
@@ -37,7 +37,7 @@ import {
   x402NetworkListForCopy,
   x402SupportedNetworksHint
 } from "./chunk-BPYMEMQX.js";
-import "./chunk-DZQYQN2X.js";
+import "./chunk-BFGQG4WY.js";
 export {
   X402_DEFAULT_FACILITATOR,
   X402_DEFAULT_NETWORK,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dvmkit/sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "SDK for building Digital Vending Machines: pay-per-use HTTPS services AI agents can find, pay, and call with no account or API key",
   "author": "DVM Technologies Ltd",
   "keywords": [