mppx 0.11.0 → 0.13.1

package/dist/tempo/server/internal/transport.js

@@ -49,6 +49,7 @@ export function sse(options) {
     const base = Transport.http();
     return Transport.from({
         name: 'sse',
+        supportsStreamingReceipts: true,
         captureRequest(request) {
             return (base.captureRequest?.(request) ?? {
                 headers: new Headers(request.headers),
@@ -63,7 +64,7 @@ export function sse(options) {
         respondChallenge(options) {
             return base.respondChallenge(options);
         },
-        respondReceipt({ credential, envelope, receipt, response, challengeId, input }) {
+        async respondReceipt({ credential, envelope, receipt, response, challengeId, input }) {
             const verifiedCredential = envelope?.credential ?? credential;
             const verifiedChallengeId = envelope?.challenge.id ?? challengeId;
             const verifiedRequest = envelope?.request ?? verifiedCredential.challenge.request;
@@ -112,8 +113,7 @@ export function sse(options) {
             if (hasPrepaidSessionTick(currentReceipt)) {
                 return baseResponse;
             }
-            const available = BigInt(currentReceipt.acceptedCumulative) - BigInt(currentReceipt.spent);
-            if (available < tickCost) {
+            const paymentRequired = (available) => {
                 const error = new Errors.InsufficientBalanceError({
                     reason: `requested ${tickCost}, available ${available}`,
                 });
@@ -125,7 +125,10 @@ export function sse(options) {
                         'Content-Type': 'application/problem+json',
                     },
                 });
-            }
+            };
+            const available = BigInt(currentReceipt.acceptedCumulative) - BigInt(currentReceipt.spent);
+            if (available < tickCost)
+                return paymentRequired(available);
             const chargedReceipt = {
                 ...currentReceipt,
                 spent: (BigInt(currentReceipt.spent) + tickCost).toString(),
@@ -150,7 +153,9 @@ export function sse(options) {
             // For null-body statuses, the request shape determines whether the
             // response is management (no charge) or plain content (charge one tick).
             if (isNullBodyStatus(chargedResponse.status)) {
-                void chargePlainResponse();
+                const result = await chargePlainResponse();
+                if (!result.ok)
+                    return paymentRequired(result.channel.highestVoucherAmount - result.channel.spent);
                 return chargedResponse;
             }
             const stream = new ReadableStream({
@@ -193,20 +198,32 @@ export function sse(options) {
 /** Default SSE serve: iterates values and emits `event: message` per value. */
 export function defaultServe(options) {
     const iterable = typeof options.generate === 'function' ? options.generate() : options.generate;
+    const iterator = iterable[Symbol.asyncIterator]();
     const encoder = new TextEncoder();
+    let closed = false;
     const stream = new ReadableStream({
-        async start(controller) {
+        async pull(controller) {
+            if (closed)
+                return;
             try {
-                for await (const value of iterable) {
-                    controller.enqueue(encoder.encode(Sse_core.formatMessageEvent(value)));
+                const next = await iterator.next();
+                if (next.done) {
+                    closed = true;
+                    controller.close();
+                    return;
                 }
+                controller.enqueue(encoder.encode(Sse_core.formatMessageEvent(next.value)));
             }
             catch (e) {
+                closed = true;
                 controller.error(e);
             }
-            finally {
-                controller.close();
-            }
+        },
+        cancel() {
+            closed = true;
+            void Promise.resolve()
+                .then(() => iterator.return?.())
+                .catch(() => { });
         },
     });
     return new Response(stream, {

package/dist/tempo/session/client/ChannelOps.js

@@ -114,12 +114,17 @@ export async function createVoucherPayload(client, account, descriptor, cumulati
  */
 export async function createClosePayload(client, account, descriptor, cumulativeAmount, chainId, escrow = tip20ChannelEscrow) {
     const voucher = await createVoucherPayload(client, account, descriptor, cumulativeAmount, chainId, escrow);
+    const closeSignature = await Voucher.signCloseAuthorization(client, account, {
+        channelId: voucher.channelId,
+        cumulativeAmount: uint96(BigInt(voucher.cumulativeAmount)),
+    }, escrow, chainId);
     return {
         action: 'close',
         channelId: voucher.channelId,
         descriptor,
         cumulativeAmount: voucher.cumulativeAmount,
         signature: voucher.signature,
+        closeSignature,
     };
 }
 /**

package/dist/tempo/session/client/Session.d.ts

@@ -45,6 +45,7 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"close">;
                 channelId: import("zod/mini").ZodMiniString<string>;
+                closeSignature: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<Channel.ChannelDescriptor, Channel.ChannelDescriptor>>;
                 signature: import("zod/mini").ZodMiniString<string>;

package/dist/tempo/session/client/Session.js

@@ -195,7 +195,7 @@ export function session(parameters = {}) {
             }
         },
     });
-    const topUpChannelIfNeeded = async ({ challenge, channel, deposit, fetch, input, requiredCumulative, }) => {
+    const topUpChannelIfNeeded = async ({ challenge, channel, deposit, fetch, input, requiredCumulative, signal, }) => {
         const knownDeposit = channel.deposit > deposit ? channel.deposit : deposit;
         const additionalDeposit = resolveAutomaticTopUp({
             deposit: knownDeposit,
@@ -215,6 +215,7 @@ export function session(parameters = {}) {
                 createSessionCredential: (challenge, context) => method.createCredential({ challenge, context }),
                 fetch,
                 input,
+                signal,
             });
         const nextDeposit = knownDeposit + additionalDeposit;
         if (nextDeposit === channel.deposit)
@@ -228,7 +229,7 @@ export function session(parameters = {}) {
         await store.set(updated);
         sink.notifyUpdate(updated);
     };
-    MethodChallenge.register(method, async ({ challenge, context, fetch, input }) => {
+    MethodChallenge.register(method, async ({ challenge, context, fetch, input, signal }) => {
         if (!isTip1034SessionChallenge(challenge))
             return;
         const sessionContext = context === undefined ? undefined : sessionContextSchema.parse(context);
@@ -264,6 +265,7 @@ export function session(parameters = {}) {
             fetch,
             input,
             requiredCumulative,
+            signal,
         });
     });
     return MethodResponse.register(method, async ({ challenge, credential, fetch, headers, input, refetch, response, signal }) => {
@@ -289,7 +291,7 @@ export function session(parameters = {}) {
             createSessionCredential: (challenge, context) => method.createCredential({ challenge, context }),
             fetch,
             getChannel: () => channel ?? null,
-            async topUpIfNeeded({ deposit, requiredCumulative }) {
+            async topUpIfNeeded({ deposit, requiredCumulative, signal: topUpSignal }) {
                 if (!channel)
                     return;
                 await topUpChannelIfNeeded({
@@ -299,11 +301,12 @@ export function session(parameters = {}) {
                     fetch,
                     input,
                     requiredCumulative,
+                    signal: topUpSignal,
                 });
             },
         };
         return wrapSseResponse({
-            onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input }, event),
+            onNeedVoucher: (event, streamSignal) => handleSseNeedVoucher({ challenge, driver, input, signal: streamSignal }, event),
             onReceipt() { },
             response,
             signal,

package/dist/tempo/session/client/SessionManager.js

@@ -235,6 +235,7 @@ export function sessionManager(parameters) {
         allowedChainIds: parameters.allowedChainIds,
         account: parameters.account,
         getClient: parameters.client ? () => parameters.client : parameters.getClient,
+        resolveAccount: parameters.resolveAccount,
     });
     const wrappedFetch = Fetch.from({
         fetch: config.fetch,
@@ -486,6 +487,7 @@ export function sessionManager(parameters) {
             channelId: parameters.channelId,
             additionalDeposit,
             knownDeposit: deposit,
+            signal: parameters.signal,
         });
     }
     async function restoreCumulative(channelId, cumulativeAmount) {
@@ -700,6 +702,7 @@ export function sessionManager(parameters) {
                         context,
                         fetch: config.fetch,
                         input: probeUrl,
+                        signal: init?.signal,
                     });
                     return createSessionCredential(challenge, context);
                 },

package/dist/tempo/session/client/Transports.d.ts

@@ -80,6 +80,8 @@ export type TopUpRequirement = {
     input: RequestInfo | URL;
     /** Minimum cumulative voucher amount the server needs. */
     requiredCumulative: bigint;
+    /** Cancels nested management requests for this top-up. */
+    signal?: AbortSignal | undefined;
 };
 /** Inputs needed to validate a caller-requested manager top-up. */
 export type ResolveManualTopUpParameters = {
@@ -156,6 +158,8 @@ export type ResolveNeedVoucherContextParameters = {
     getChannel(): ChannelEntry | null;
     /** Original paid resource URL; converted to management URL by the caller. */
     input: RequestInfo | URL;
+    /** Cancels top-up work triggered by this event. */
+    signal?: AbortSignal | undefined;
     /** Performs the deposit top-up when server-required cumulative exceeds deposit. */
     topUpIfNeeded(parameters: TopUpRequirement): Promise<void>;
 };
@@ -207,6 +211,8 @@ export type PostTopUpParameters = {
     fetch: typeof globalThis.fetch;
     /** Original paid resource URL; normalized to a management URL before posting. */
     input: RequestInfo | URL;
+    /** Cancels the top-up management request. */
+    signal?: AbortSignal | undefined;
 };
 /** Inputs for retrying an HTTP 402 with a top-up/voucher management round trip. */
 export type RetryHttpPaymentRequiredParameters = {
@@ -334,7 +340,7 @@ export type SseResponseFrame = {
 /** Inputs for driving an open paid SSE response. */
 export type DriveSseResponseParameters = {
     /** Handles a request for the stream's next cumulative voucher. */
-    onNeedVoucher(event: NeedVoucherEvent): Promise<void>;
+    onNeedVoucher(event: NeedVoucherEvent, signal?: AbortSignal | undefined): Promise<void>;
     /** Handles a payment receipt emitted by the stream. */
     onReceipt(receipt: SessionReceipt): void;
     /** Open SSE response to drive. */
@@ -351,6 +357,7 @@ export declare function handleSseNeedVoucher(parameters: {
     challenge: TempoSessionChallenge | null;
     driver: SsePaymentDriver;
     input: RequestInfo | URL;
+    signal?: AbortSignal | undefined;
 }, event: NeedVoucherEvent): Promise<void>;
 /** Options accepted by the auto-driving WebSocket session flow. */
 export type WebSocketDriverOptions = {

package/dist/tempo/session/client/Transports.js

@@ -214,6 +214,7 @@ export async function resolveNeedVoucherContext(parameters) {
         channelId: parameters.expectedChannelId,
         deposit: eventAmounts.deposit,
         requiredCumulative: eventAmounts.requiredCumulative,
+        ...(parameters.signal ? { signal: parameters.signal } : {}),
     });
     const channel = parameters.getChannel();
     if (!channel || channel.channelId !== parameters.expectedChannelId) {
@@ -314,6 +315,7 @@ export async function postTopUp(parameters) {
         createSessionCredential: parameters.createSessionCredential,
         fetch: parameters.fetch,
         input: parameters.input,
+        signal: parameters.signal,
     });
     if (!response.ok)
         throw new Error(`Top-up POST failed with status ${response.status}`);
@@ -324,6 +326,7 @@ export async function postTopUp(parameters) {
 async function postManagementCredential(parameters) {
     const post = async (challenge) => parameters.fetch(managementInput(parameters.input), {
         method: 'POST',
+        ...(parameters.signal ? { signal: parameters.signal } : {}),
         headers: {
             [Constants.Headers.authorization]: await parameters.createSessionCredential(challenge, parameters.context),
         },
@@ -352,6 +355,8 @@ export async function retryHttpPaymentRequired(parameters) {
         channelId: snapshot.channelId,
         deposit: BigInt(snapshot.deposit),
         requiredCumulative,
+        signal: parameters.init?.signal ??
+            (parameters.input instanceof Request ? parameters.input.signal : undefined),
     });
     const currentChannel = parameters.getChannel();
     if (!currentChannel?.descriptor || currentChannel.channelId !== snapshot.channelId) {
@@ -453,7 +458,8 @@ export async function closeHttpSession(parameters) {
  * credential creation, and top-up policy stay in `SessionManager`.
  */
 export async function openSseSession(input, init, driver) {
-    const { onReceipt, signal, ...fetchInit } = init ?? {};
+    const { onReceipt, signal: explicitSignal, ...fetchInit } = init ?? {};
+    const signal = explicitSignal ?? (input instanceof Request ? input.signal : undefined);
     const sseInit = {
         ...fetchInit,
         headers: {
@@ -475,7 +481,7 @@ export function consumeSseSessionResponse(input, response, options, driver) {
         throw new Error('Response has no body.');
     const challenge = driver.getChallenge();
     return iterateSseMessages({
-        onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input }, event),
+        onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input, signal: options?.signal }, event),
         onReceipt(receipt) {
             driver.acceptReceipt(receipt);
             options?.onReceipt?.(receipt);
@@ -535,7 +541,7 @@ export async function* driveSseResponse(parameters) {
                         yield { data: event.data, raw };
                         break;
                     case 'payment-need-voucher':
-                        await parameters.onNeedVoucher(event.data);
+                        await parameters.onNeedVoucher(event.data, parameters.signal);
                         break;
                     case 'payment-receipt':
                         parameters.onReceipt(event.data);
@@ -632,6 +638,7 @@ export async function handleSseNeedVoucher(parameters, event) {
         expectedChannelId: channel.channelId,
         getChannel: parameters.driver.getChannel,
         input: parameters.input,
+        signal: parameters.signal,
         topUpIfNeeded: parameters.driver.topUpIfNeeded,
     });
     if (resolution.status !== 'ready')
@@ -642,6 +649,7 @@ export async function handleSseNeedVoucher(parameters, event) {
         createSessionCredential: parameters.driver.createSessionCredential,
         fetch: parameters.driver.fetch,
         input: parameters.input,
+        signal: parameters.signal,
     });
     if (!voucherResponse.ok) {
         throw new Error(`Voucher POST failed with status ${voucherResponse.status}`);
@@ -868,6 +876,7 @@ async function handleNeedVoucher(parameters, event) {
             expectedChannelId: parameters.socketState.channelId,
             getChannel: parameters.driver.getChannel,
             input: parameters.driver.httpUrl,
+            signal: parameters.driver.options?.signal,
             topUpIfNeeded: parameters.driver.topUpIfNeeded,
         });
         if (resolution.status === 'ignored') {

package/dist/tempo/session/precompile/Chain.js

@@ -292,8 +292,23 @@ export async function simulateCredentialTransaction(parameters) {
 }
 function validateCredentialSponsorship(parameters) {
     const { allowedFeeTokens, challengeExpires, chainId, details, feePayer, feePayerPolicy, transaction, } = parameters;
-    if (!feePayer || feePayer === true)
+    if (!feePayer)
         return;
+    if (feePayer === true) {
+        assertPrecompileFeePayerPolicy({ prepared: transaction, policy: feePayerPolicy });
+        if (feePayerPolicy?.allowKeyAuthorization === false &&
+            transaction.keyAuthorization !== undefined)
+            throw new BadRequestError({ reason: 'fee-payer policy keyAuthorization is not allowed' });
+        FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens);
+        FeePayer.assertTransactionPolicy({
+            challengeExpires,
+            chainId,
+            details,
+            policy: feePayerPolicy,
+            transaction,
+        });
+        return;
+    }
     FeePayer.prepareSponsoredTransaction({
         account: feePayer,
         allowedFeeTokens,

package/dist/tempo/session/precompile/Protocol.d.ts

@@ -106,6 +106,8 @@ export type CloseCredentialPayload = {
     cumulativeAmount: RawAmountString;
     /** Voucher signature for `cumulativeAmount`. */
     signature: Hex;
+    /** Separate signature authorizing the cooperative close action. */
+    closeSignature: Hex;
 };
 /**
  * TIP20EscrowChannel precompile session credential payload (discriminated union).

package/dist/tempo/session/precompile/Voucher.d.ts

@@ -22,10 +22,26 @@ export declare const voucherTypes: {
         readonly type: 'uint96';
     }];
 };
+/** EIP-712 type that distinguishes cooperative close authorization from a voucher. */
+export declare const closeAuthorizationTypes: {
+    readonly CloseAuthorization: readonly [{
+        readonly name: 'channelId';
+        readonly type: 'bytes32';
+    }, {
+        readonly name: 'cumulativeAmount';
+        readonly type: 'uint96';
+    }];
+};
 /**
  * Sign a voucher with an account.
  */
 export declare function signVoucher(client: Client, account: Account, voucher: Voucher, verifyingContract: Address, chainId: number): Promise<Hex>;
+/**
+ * Signs a distinct EIP-712 authorization for cooperatively closing a channel.
+ */
+export declare function signCloseAuthorization(client: Client, account: Account, authorization: Voucher, verifyingContract: Address, chainId: number): Promise<Hex>;
+/** Verifies that a cooperative-close signature belongs to a channel authority. */
+export declare function verifyCloseAuthorization(escrowContract: Address, chainId: number, authorization: SignedVoucher, expectedSigners: readonly Address[]): boolean;
 /**
  * Verify a voucher signature matches the expected signer.
  *

package/dist/tempo/session/precompile/Voucher.js

@@ -29,6 +29,21 @@ export const voucherTypes = {
         { name: 'cumulativeAmount', type: 'uint96' },
     ],
 };
+/** EIP-712 type that distinguishes cooperative close authorization from a voucher. */
+export const closeAuthorizationTypes = {
+    CloseAuthorization: [
+        { name: 'channelId', type: 'bytes32' },
+        { name: 'cumulativeAmount', type: 'uint96' },
+    ],
+};
+function getCloseAuthorizationPayload(verifyingContract, chainId, authorization) {
+    return hashTypedData({
+        domain: getVoucherDomain(verifyingContract, chainId),
+        types: closeAuthorizationTypes,
+        primaryType: 'CloseAuthorization',
+        message: authorization,
+    });
+}
 function getVoucherDigest(chainId, voucher) {
     return Channel.getVoucherSignPayload({
         chainId,
@@ -90,6 +105,39 @@ export async function signVoucher(client, account, voucher, verifyingContract, c
         throw new Error(`TIP-1034 vouchers require a TIP-1020 primitive signature; received "${envelope.type}".`);
     return SignatureEnvelope.serialize(envelope);
 }
+/**
+ * Signs a distinct EIP-712 authorization for cooperatively closing a channel.
+ */
+export async function signCloseAuthorization(client, account, authorization, verifyingContract, chainId) {
+    const signature = await signTypedData(client, {
+        account,
+        domain: getVoucherDomain(verifyingContract, chainId),
+        types: closeAuthorizationTypes,
+        primaryType: 'CloseAuthorization',
+        message: authorization,
+    });
+    const envelope = SignatureEnvelope.from(signature);
+    if (!isPrimitiveEnvelope(envelope.type))
+        throw new Error(`TIP-1034 close authorizations require a TIP-1020 primitive signature; received "${envelope.type}".`);
+    return SignatureEnvelope.serialize(envelope);
+}
+/** Verifies that a cooperative-close signature belongs to a channel authority. */
+export function verifyCloseAuthorization(escrowContract, chainId, authorization, expectedSigners) {
+    try {
+        const envelope = SignatureEnvelope.from(authorization.signature);
+        if (!isPrimitiveEnvelope(envelope.type))
+            return false;
+        if (SignatureEnvelope.serialize(envelope).toLowerCase() !== authorization.signature.toLowerCase())
+            return false;
+        const payload = getCloseAuthorizationPayload(escrowContract, chainId, authorization);
+        const signer = SignatureEnvelope.extractAddress({ payload, signature: envelope });
+        const valid = SignatureEnvelope.verify(envelope, { address: signer, payload });
+        return valid && expectedSigners.some((expected) => TempoAddress.isEqual(signer, expected));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Verify a voucher signature matches the expected signer.
  *

package/dist/tempo/session/server/ChannelStore.d.ts

@@ -189,6 +189,8 @@ export type VerifyAndAcceptVoucherParameters = {
     methodDetails: SessionMethodDetails;
     /** Minimum allowed voucher delta in raw units. */
     minVoucherDelta: bigint;
+    /** Whether this presentation must advance the accepted voucher. */
+    requireAdvance?: boolean | undefined;
     /** Server channel store. */
     store: ChannelStore;
     /** Signed cumulative voucher to verify and accept. */
@@ -255,6 +257,14 @@ export interface BaseState {
     token: Address;
     /** Number of charge operations (API requests) fulfilled in the current session. */
     units: number;
+    /** Uncommitted stream charges shared across workers. */
+    streamReservations?: Record<string, {
+        amount: bigint;
+        units: number;
+        expiresAt: number;
+    }> | undefined;
+    /** Active cross-worker claim for server-scheduled settlement. */
+    scheduledSettlementLease?: ScheduledSettlementLease | undefined;
     /** ISO 8601 timestamp of the last server-scheduled settlement. */
     lastSettlementAt?: string | undefined;
     /** Cumulative spent value when the last server-scheduled settlement ran. */
@@ -262,6 +272,11 @@ export interface BaseState {
     /** Charge operation count when the last server-scheduled settlement ran. */
     lastSettlementUnits?: number | undefined;
 }
+/** Expiring ownership claim for one server-scheduled settlement attempt. */
+export type ScheduledSettlementLease = {
+    expiresAt: number;
+    owner: string;
+};
 /** Returns whether a channel is backed by the TIP20EscrowChannel precompile. */
 export declare function isPrecompileState(state: State): state is BaseState & PrecompileBackendState;
 /** Returns the greater bigint value without decreasing persisted monotonic state. */
@@ -315,6 +330,8 @@ export declare function verifyAndAcceptVoucher(parameters: VerifyAndAcceptVouche
  * - **D1 / SQL**: Database transactions
  */
 export type ChannelStore = {
+    /** False when the backing store only serializes mutations within this process. */
+    atomic?: boolean | undefined;
     getChannel(channelId: Hex): Promise<State | null>;
     /**
      * Atomic read-modify-write for channel state.
@@ -327,11 +344,12 @@ export type ChannelStore = {
      * Returns a `Promise` that resolves once `updateChannel` is called for
      * `channelId`. Implementations should resolve immediately if the channel
      * was updated between the call to `waitForUpdate` and the `Promise`
-     * being awaited.
+     * being awaited. Implementations must reject and release the waiter when
+     * `signal` aborts.
      *
      * When not implemented, callers fall back to polling.
      */
-    waitForUpdate?(channelId: Hex): Promise<void>;
+    waitForUpdate?(channelId: Hex, signal?: AbortSignal): Promise<void>;
     /**
      * Atomic read-modify-write that returns the callback's `result` directly.
      *
@@ -353,4 +371,6 @@ export declare function fromStore(store: Store.Store | Store.AtomicStore): Chann
  * when the channel exists but cannot currently be charged.
  */
 export declare function deductFromChannel(store: ChannelStore, channelId: State['channelId'], amount: bigint): Promise<DeductResult>;
+/** Returns unexpired stream reservations that ordinary deductions must respect. */
+export declare function reservedStreamAmount(state: Pick<State, 'streamReservations'>): bigint;
 //# sourceMappingURL=ChannelStore.d.ts.map

package/dist/tempo/session/server/ChannelStore.js

@@ -224,9 +224,11 @@ export async function validateVoucher(parameters) {
 }
 /** Verifies a cumulative voucher and returns a session receipt after store reconciliation. */
 export async function verifyAndAcceptVoucher(parameters) {
-    const { store, challenge, channel, voucher, channelState } = parameters;
+    const { store, challenge, channel, voucher, channelState, requireAdvance } = parameters;
     const validation = await validateVoucher(parameters);
-    if (validation.alreadyAccepted)
+    if (validation.alreadyAccepted) {
+        if (requireAdvance)
+            throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
         return createSessionReceipt({
             challengeId: challenge.id,
             channelId: voucher.channelId,
@@ -234,7 +236,14 @@ export async function verifyAndAcceptVoucher(parameters) {
             spent: channel.spent,
             units: channel.units,
         });
-    const updated = await store.updateChannel(voucher.channelId, (current) => acceptVoucherStateUpdate({ channelState, current, voucher }));
+    }
+    const updated = await store.updateChannel(voucher.channelId, (current) => {
+        if (requireAdvance &&
+            current !== null &&
+            voucher.cumulativeAmount <= current.highestVoucherAmount)
+            throw new DeltaTooSmallError({ reason: 'voucher does not add new funds for this request' });
+        return acceptVoucherStateUpdate({ channelState, current, voucher });
+    });
     if (!updated)
         throw new ChannelNotFoundError({ reason: 'channel not found' });
     return createSessionReceipt({
@@ -348,6 +357,7 @@ export function fromStore(store) {
         }
     }
     const cs = {
+        atomic: typeof atomicUpdate === 'function',
         async getChannel(channelId) {
             const normalizedChannelId = normalizeChannelId(channelId);
             return normalizeMaybeState(normalizedChannelId, await stateStore.get(normalizedChannelId));
@@ -355,15 +365,30 @@ export function fromStore(store) {
         async updateChannel(channelId, fn) {
             return update(channelId, fn);
         },
-        waitForUpdate(channelId) {
-            return new Promise((resolve) => {
+        waitForUpdate(channelId, signal) {
+            return new Promise((resolve, reject) => {
                 const normalizedChannelId = normalizeChannelId(channelId);
+                if (signal?.aborted) {
+                    reject(signal.reason ?? new Error('aborted'));
+                    return;
+                }
                 let set = runtime.waiters.get(normalizedChannelId);
                 if (!set) {
                     set = new Set();
                     runtime.waiters.set(normalizedChannelId, set);
                 }
-                set.add(resolve);
+                const settle = () => {
+                    signal?.removeEventListener('abort', onAbort);
+                    resolve();
+                };
+                const onAbort = () => {
+                    set?.delete(settle);
+                    if (set?.size === 0)
+                        runtime.waiters.delete(normalizedChannelId);
+                    reject(signal?.reason ?? new Error('aborted'));
+                };
+                signal?.addEventListener('abort', onAbort, { once: true });
+                set.add(settle);
             });
         },
     };
@@ -404,9 +429,14 @@ function planDeduction(current, amount) {
         return { op: 'noop', result: { ok: false, channel: current } };
     if (current.closeRequestedAt !== 0n)
         return { op: 'noop', result: { ok: false, channel: current } };
-    if (current.highestVoucherAmount - current.spent < amount)
+    if (current.highestVoucherAmount - current.spent - reservedStreamAmount(current) < amount)
         return { op: 'noop', result: { ok: false, channel: current } };
     const next = { ...current, spent: current.spent + amount, units: current.units + 1 };
     return { op: 'set', value: next, result: { ok: true, channel: next } };
 }
+/** Returns unexpired stream reservations that ordinary deductions must respect. */
+export function reservedStreamAmount(state) {
+    const now = Date.now();
+    return Object.values(state.streamReservations ?? {}).reduce((total, reservation) => total + (reservation.expiresAt > now ? reservation.amount : 0n), 0n);
+}
 //# sourceMappingURL=ChannelStore.js.map

package/dist/tempo/session/server/CredentialVerification.d.ts

@@ -79,6 +79,8 @@ export type BroadcastCredentialPayloadParameters = {
     onSessionSettlement?: OnSessionSettlement | undefined;
     /** Discriminated session credential payload to verify. */
     payload: SessionCredentialPayload;
+    /** Whether an open or voucher credential must add new funds for this request. */
+    requireVoucherAdvance?: boolean | undefined;
     /** Server-side channel store. */
     store: ChannelStore.ChannelStore;
 };
@@ -102,7 +104,10 @@ export type VoucherCredentialActionParameters = BroadcastCredentialActionParamet
 /** Inputs for broadcasting and settling a cooperative close credential. */
 export type CloseCredentialActionParameters = BroadcastCredentialActionParameters<'close'>;
 /** Inputs for validating a session credential without applying its state transition. */
-export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'feeToken' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge'>;
+export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'feeToken' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge'> & {
+    /** Allows terminal broadcast to recover accepted funds before rejecting a pending close. */
+    allowPendingClose?: boolean | undefined;
+};
 /** Non-mutating result produced by session credential validation. */
 export type CredentialPayloadValidation = {
     /** Session action validated from the credential. */