mppx 0.13.5 → 0.13.6

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

@@ -5,12 +5,11 @@ import * as ChannelStore from './ChannelStore.js';
 /** Controller passed to manual-charge streaming generators. */
 export type SessionController = {
     /**
-     * Reserve voucher coverage for the next emitted chunk.
+     * Commit a charge before performing billable work.
      *
-     * The reservation blocks until sufficient voucher headroom exists, but the
-     * charge is committed when a chunk is emitted or when the generator finishes
-     * successfully. A reservation is only dropped when the stream aborts or the
-     * generator fails before the charge can be committed.
+     * Waits for sufficient voucher coverage and commits the charge before resolving.
+     * Once resolved, the charge is retained even if the stream is canceled or the
+     * generator fails. Await this method before starting the corresponding work.
      *
      * Pass an explicit raw-unit `amount` for request-aware or otherwise dynamic
      * pricing. When omitted, the session challenge's configured tick cost is
@@ -32,6 +31,8 @@ export type MeteredStreamOptions = {
     formatNeedVoucher(parameters: NeedVoucherEvent): string;
     /** Async source or manual-charge source. */
     generate: SessionStreamGenerator;
+    /** Verifies that the channel can still fund work and delivery; failures stop the stream. */
+    beforeCharge?: (() => MaybePromise<void>) | undefined;
     /** Runs after a nonzero reserved charge has been committed. */
     onChargeCommitted?: ((channel: ChannelStore.State) => MaybePromise<unknown>) | undefined;
     /** Store polling interval when `waitForUpdate` is unavailable. */

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

@@ -1,38 +1,24 @@
-import { commitReservedCharges, releaseReservedCharges, renewReservedCharges, reserveChargeOrWait, streamReservationLeaseMs, } from './Transports.js';
+import { commitReservedCharges, releaseReservedCharges, reserveChargeOrWait } from './Transports.js';
 /** Applies voucher reservation and spend commits to an async session stream. */
 export async function* meterIterable(options) {
+    const manual = typeof options.generate === 'function';
     let prepaidUnits = options.prepaidUnits ?? 0;
-    const controller = new AbortController();
-    const signal = controller.signal;
+    const signal = options.signal ?? new AbortController().signal;
     const reservation = {
         store: options.store,
         channelId: options.channelId,
         reservationId: globalThis.crypto.randomUUID(),
     };
     let pending = false;
-    let cancelled = false;
-    const onAbort = () => {
-        if (signal.aborted)
-            return;
-        cancelled = true;
-        controller.abort(options.signal?.reason);
-    };
-    options.signal?.addEventListener('abort', onAbort, { once: true });
-    if (options.signal?.aborted)
-        onAbort();
-    const renewal = setInterval(() => {
-        if (pending)
-            void renewReservedCharges(reservation).catch((error) => controller.abort(error));
-    }, streamReservationLeaseMs / 3);
-    renewal.unref?.();
     const releaseOnAbort = () => {
-        clearInterval(renewal);
         void releaseReservedCharges(reservation).catch(() => { });
     };
     signal.addEventListener('abort', releaseOnAbort, { once: true });
     if (signal.aborted)
         releaseOnAbort();
     const charge = async (amount) => {
+        signal.throwIfAborted();
+        await options.beforeCharge?.();
         signal.throwIfAborted();
         if (amount === undefined && prepaidUnits > 0) {
             prepaidUnits -= 1;
@@ -50,9 +36,13 @@ export async function* meterIterable(options) {
             signal,
         });
         pending = true;
+        if (manual)
+            await commit();
         signal.throwIfAborted();
     };
     const commit = async () => {
+        signal.throwIfAborted();
+        await options.beforeCharge?.();
         signal.throwIfAborted();
         if (!pending)
             return;
@@ -63,7 +53,6 @@ export async function* meterIterable(options) {
         await options.onChargeCommitted?.(channel);
     };
     try {
-        const manual = typeof options.generate === 'function';
         const iterable = typeof options.generate === 'function'
             ? options.generate({ charge, signal })
             : options.generate;
@@ -74,7 +63,7 @@ export async function* meterIterable(options) {
                 if (signal.aborted)
                     break;
                 if (done) {
-                    if (manual)
+                    if (manual && pending)
                         await commit();
                     break;
                 }
@@ -83,18 +72,13 @@ export async function* meterIterable(options) {
                 await commit();
                 yield value;
             }
-            if (!cancelled)
-                signal.throwIfAborted();
         }
         finally {
-            clearInterval(renewal);
             await releaseReservedCharges(reservation);
             await iterator.return?.();
         }
     }
     finally {
-        clearInterval(renewal);
-        options.signal?.removeEventListener('abort', onAbort);
         signal.removeEventListener('abort', releaseOnAbort);
         await releaseReservedCharges(reservation);
     }

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

@@ -21,6 +21,8 @@ import { type ResolveSessionChannelId } from './RequestState.js';
 import { type SettleChargedSessionChannel } from './Settlement.js';
 import { type OnSessionSettlement, type OnSessionSettlementFailure, type SettlementSchedule } from './Settlement.js';
 import * as Ws from './Ws.js';
+/** @internal Reuses a method's escrow verifier when composing shared currency helpers. */
+export declare function verifyStream(method: object, channelId: Hex): Promise<void>;
 /** Server-side automatic settlement schedule. */
 export type { SettlementSchedule } from './Settlement.js';
 /** Server-side settlement event hook types. */
@@ -131,15 +133,27 @@ export declare namespace session {
         serveWebSocket: (options: ServeWebSocketOptions) => Promise<void>;
     };
     /** WebSocket server options supplied after the session binds shared dependencies. */
-    type ServeWebSocketOptions = Omit<Ws.serve.Options, 'onChargeCommitted' | 'settleScheduled' | 'store'>;
+    type ServeWebSocketOptions = Omit<Ws.serve.Options, 'beforeCharge' | 'onChargeCommitted' | 'settleScheduled' | 'store'>;
     /** Request defaults inferred from the Tempo session method schema. */
     type Defaults = LooseOmit<Method.RequestDefaults<typeof Methods.session>, 'escrowContract' | 'feePayer' | 'recipient'>;
     /** Partial fee-sponsor policy used for server-submitted session transactions. */
     type FeePayerPolicy = Partial<FeePayer.Policy>;
     /** Parameters accepted by the TIP-1034 server session payment method. */
     type Parameters = {
-        /** TTL in milliseconds for cached on-chain channel state during non-mutating validation. Voucher acceptance always refreshes on-chain state. @default 5_000 */
+        /** TTL in milliseconds for cached on-chain channel state during non-mutating validation, and before a voucher accepted under `voucherStateMaxAge` starts a fresh read. @default 5_000 */
         channelStateTtl?: number | undefined;
+        /**
+         * Maximum age in milliseconds of verified on-chain channel state that a voucher may be validated
+         * and accepted against without waiting for a fresh read. The fresh read then finishes in the background and
+         * records a pending close, so later vouchers are rejected. `0` reads on-chain state before every
+         * acceptance.
+         *
+         * A payer can withdraw only after the escrow's `CLOSE_GRACE_PERIOD` (900 s on Tempo) following a
+         * close request, so vouchers accepted this way stay settleable as long as the payee settles them
+         * within the grace period minus this age. Keep it well below that bound.
+         * @default 0
+         */
+        voucherStateMaxAge?: number | undefined;
         /** Override the fee-sponsor policy used for sponsored open/topUp transactions and server-driven close transactions. */
         feePayerPolicy?: FeePayerPolicy | undefined;
         /** Minimum voucher delta to accept (numeric string, default: "0"). */
@@ -159,6 +173,19 @@ export declare namespace session {
          * containing the signed highest voucher for client rehydration.
          */
         bootstrap?: boolean | undefined;
+        /**
+         * Lets a session challenge pay for later requests to the same route until it expires. The
+         * challenge is bound to its route, currency, recipient and channel terms but not to the amount
+         * it quoted, and every request is charged its own price from the channel's accepted balance.
+         * A client can then send a voucher with a request instead of waiting for a `402`.
+         */
+        reusableChallenges?: boolean | undefined;
+        /**
+         * Charges request-priced content (`unitType: 'request'`) in the same store update that accepts
+         * its voucher, before the response, instead of in a second update when the response is
+         * delivered. The server must then refund requests it cannot serve.
+         */
+        chargeOnAcceptance?: boolean | undefined;
         /**
          * Atomic store backend for channel state.
          *

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

@@ -20,17 +20,26 @@ import * as Methods from '../../Methods.js';
 import * as ChargeServer from '../../server/Charge.js';
 import { fallbackStore } from '../../server/internal/fallback-store.js';
 import * as Transport from '../../server/internal/transport.js';
+import * as Chain from '../precompile/Chain.js';
 import { tip20ChannelEscrow } from '../precompile/Protocol.js';
 import { deserializeSnapshot as deserializeSessionSnapshot, serializeSnapshot as serializeSessionSnapshot, } from '../Snapshot.js';
 import * as ChannelStore from './ChannelStore.js';
 import { broadcastCredentialPayload, validateCredentialPayload } from './CredentialVerification.js';
-import { requireSessionCredentialPayload } from './CredentialVerification.js';
+import { requireSessionCredentialPayload, validateChannelState } from './CredentialVerification.js';
 import { resolveCredentialVerificationContext, resolveSessionChannelId, resolveSessionSnapshot, resolveSessionPaymentRequest, } from './RequestState.js';
 import { respondToSessionCredential } from './RequestState.js';
-import { applyVerifiedHttpAccounting, chargeSessionChannel, shouldApplyVerifiedHttpAccounting, } from './Settlement.js';
+import { applyVerifiedHttpAccounting, chargeSessionChannel, shouldApplyVerifiedHttpAccounting, shouldChargeVoucherOnAcceptance, } from './Settlement.js';
 import { ignoreRetryableSettlementFailure, isSettlementDue, maybeSettleScheduled, reportSessionSettlementFailure, } from './Settlement.js';
 import { resolveSettlementSchedule, } from './Settlement.js';
 import * as Ws from './Ws.js';
+const streamVerifiers = new WeakMap();
+/** @internal Reuses a method's escrow verifier when composing shared currency helpers. */
+export function verifyStream(method, channelId) {
+    const verify = streamVerifiers.get(method);
+    if (!verify)
+        throw new Error('Session stream verifier is not configured');
+    return verify(channelId);
+}
 export { settle, settleBatch } from './Settlement.js';
 function deriveServerDefaults(values) {
     // `Method.toServer()` models defaults from request input fields. Tempo session
@@ -191,6 +200,19 @@ async function handleBootstrapPreflight(parameters) {
     }
     return new Response(null, { status: 204, headers });
 }
+/** Binds a reusable session challenge to its route and channel terms but not to its quoted amount. */
+const reusableSessionBinding = (request) => {
+    const { methodDetails } = request;
+    return {
+        chainId: methodDetails.chainId,
+        currency: request.currency,
+        escrowContract: methodDetails.escrowContract,
+        operator: methodDetails.operator,
+        recipient: request.recipient,
+        sessionProtocol: methodDetails[Constants.MethodDetailKeys.sessionProtocol],
+        unitType: request.unitType,
+    };
+};
 /** Creates a server-side TIP20EscrowChannel precompile session payment method. */
 export function session(p) {
     const parameters = p;
@@ -236,8 +258,33 @@ export function session(p) {
     // A failed scheduled settlement is reported and retried by the next one; the charged request
     // stays served because the payer's voucher already covers the charge.
     const settleCharged = (channel) => settleScheduled(channel).catch(ignoreRetryableSettlementFailure);
+    // Stream checks have a bounded TTL even when callers disable validation caching.
+    // Cache only successful reads; RPC failures must stop delivery.
+    const beforeStreamCharge = async (channelId) => {
+        channelId = ChannelStore.normalizeChannelId(channelId);
+        const channel = await store.getChannel(channelId);
+        if (!channel || channel.finalized || channel.closeRequestedAt !== 0n)
+            throw new Errors.ChannelClosedError({ reason: 'stream channel is closed' });
+        const now = Date.now();
+        const ttl = Math.min(Math.max(channelStateTtl, 0), 5_000);
+        const lastVerified = lastOnChainVerified.get(channelId);
+        if (lastVerified !== undefined && now >= lastVerified && now - lastVerified < ttl)
+            return;
+        let state;
+        try {
+            const client = await getClient({ chainId: channel.chainId });
+            state = await Chain.getChannelState(client, channelId, channel.escrowContract);
+        }
+        catch {
+            // Transport errors can include private RPC URLs or authentication details.
+            throw new Error('Unable to verify stream escrow');
+        }
+        validateChannelState(state);
+        lastOnChainVerified.set(channelId, now);
+    };
     const serveWebSocket = (options) => Ws.serve({
         ...options,
+        beforeCharge: beforeStreamCharge,
         onChargeCommitted: settleCharged,
         store,
     });
@@ -253,9 +300,11 @@ export function session(p) {
     });
     const transport = parameters.sse
         ? Transport.sse({
+            ...(typeof parameters.sse === 'object' ? parameters.sse : {}),
+            beforeCharge: beforeStreamCharge,
+            reusableChallenges: parameters.reusableChallenges,
             settleCharged,
             store,
-            ...(typeof parameters.sse === 'object' ? parameters.sse : undefined),
         })
         : undefined;
     const validateCredential = async ({ credential, operation, request, }) => {
@@ -267,24 +316,31 @@ export function session(p) {
             minVoucherDelta: parameters.minVoucherDelta,
             request,
         });
-        const details = await validateCredentialPayload({
-            account,
-            allowPendingClose: operation === 'broadcast',
-            challenge: credential.challenge,
-            channelStateTtl,
-            chainId: context.chainId,
-            client: context.client,
-            credentialSource: credential.source,
-            escrow: context.escrow,
-            expectedOperator: context.methodDetails.operator,
-            feePayer: context.feePayer,
-            feePayerPolicy: parameters.feePayerPolicy,
-            feeToken: context.methodDetails.feeToken,
-            lastOnChainVerified,
-            minVoucherDelta: context.minVoucherDelta,
-            payload,
-            store,
-        });
+        // A broadcast voucher is checked against the stored channel by the update that accepts it.
+        const details = operation === 'broadcast' && payload.action === 'voucher'
+            ? {
+                action: payload.action,
+                channelId: ChannelStore.normalizeChannelId(payload.channelId),
+            }
+            : await validateCredentialPayload({
+                account,
+                allowPendingClose: operation === 'broadcast',
+                challenge: credential.challenge,
+                channelStateTtl,
+                chainId: context.chainId,
+                client: context.client,
+                credentialSource: credential.source,
+                escrow: context.escrow,
+                expectedOperator: context.methodDetails.operator,
+                feePayer: context.feePayer,
+                feePayerPolicy: parameters.feePayerPolicy,
+                feeToken: context.methodDetails.feeToken,
+                lastOnChainVerified,
+                minVoucherDelta: context.minVoucherDelta,
+                payload,
+                store,
+                voucherStateMaxAge: parameters.voucherStateMaxAge,
+            });
         return {
             challenge: credential.challenge,
             credential: { ...credential, payload },
@@ -305,9 +361,34 @@ export function session(p) {
             minVoucherDelta: parameters.minVoucherDelta,
             request,
         });
+        const chargeAmount = parameters.chargeOnAcceptance &&
+            shouldChargeVoucherOnAcceptance({
+                capturedRequest: envelope?.capturedRequest,
+                payloadAction: payload.action,
+                unitType: context.request.unitType,
+            })
+            ? BigInt(context.request.amount ?? challenge.request.amount)
+            : undefined;
+        const acceptance = {};
+        const settleAcceptedCharge = (channel) => maybeSettleScheduled({
+            account,
+            client: context.client,
+            ...(context.feePayer ? { feePayer: context.feePayer } : {}),
+            feePayerPolicy: parameters.feePayerPolicy,
+            feeToken: parameters.feeToken,
+            onSessionSettlement,
+            onSessionSettlementFailure,
+            schedule: settlementSchedule,
+            store,
+            channel,
+        }).catch(ignoreRetryableSettlementFailure);
         const sessionReceipt = await broadcastCredentialPayload({
             account,
             challenge,
+            chargeAmount,
+            onCharged: (channel) => {
+                acceptance.charged = channel;
+            },
             channelStateTtl,
             chainId: context.chainId,
             client: context.client,
@@ -328,7 +409,16 @@ export function session(p) {
                 sseEnabled: Boolean(parameters.sse),
             }),
             store,
+            voucherStateMaxAge: parameters.voucherStateMaxAge,
         });
+        if (acceptance.charged) {
+            const settlementTxHash = await settleAcceptedCharge(acceptance.charged);
+            const receipt = {
+                ...sessionReceipt,
+                ...(settlementTxHash ? { txHash: settlementTxHash } : {}),
+            };
+            return parameters.sse ? Transport.markPrepaidSessionTick(receipt) : receipt;
+        }
         return applyVerifiedHttpAccounting({
             capturedRequest: envelope?.capturedRequest,
             payloadAction: payload.action,
@@ -337,18 +427,7 @@ export function session(p) {
             sseEnabled: Boolean(parameters.sse),
             markPrepaidReceipt: Transport.markPrepaidSessionTick,
             charge: (channelId, requestAmount) => chargeSessionChannel({ store, channelId, amount: requestAmount }),
-            settleCharged: (channel) => maybeSettleScheduled({
-                account,
-                client: context.client,
-                ...(context.feePayer ? { feePayer: context.feePayer } : {}),
-                feePayerPolicy: parameters.feePayerPolicy,
-                feeToken: parameters.feeToken,
-                onSessionSettlement,
-                onSessionSettlementFailure,
-                schedule: settlementSchedule,
-                store,
-                channel,
-            }).catch(ignoreRetryableSettlementFailure),
+            settleCharged: settleAcceptedCharge,
         });
     };
     const method = Method.toServer(Methods.session, {
@@ -364,6 +443,7 @@ export function session(p) {
             unitType,
         }),
         extensions: { serveWebSocket, settleScheduled },
+        ...(parameters.reusableChallenges ? { stableBinding: reusableSessionBinding } : {}),
         transport: deriveTransport(transport),
         preflight: parameters.bootstrap
             ? async ({ capturedRequest, credential, expires, input, options, realm, secretKey }) => {
@@ -430,6 +510,7 @@ export function session(p) {
             });
         },
     });
+    streamVerifiers.set(method, beforeStreamCharge);
     return method;
 }
 (function (session) {

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

@@ -174,6 +174,15 @@ export type ApplyVerifiedHttpAccountingParameters = {
 };
 /** Returns whether an accepted credential will authorize and charge an HTTP content response. */
 export declare function shouldApplyVerifiedHttpAccounting(parameters: Pick<ApplyVerifiedHttpAccountingParameters, 'capturedRequest' | 'payloadAction' | 'sseEnabled'>): boolean;
+/**
+ * Returns whether a voucher pays for its request in the store update that accepts it. A
+ * request-priced content request is charged exactly once, so this is the charge the HTTP
+ * accounting or the streamed response would make, without a second store update; the receipt is
+ * then marked prepaid so an SSE response does not charge again.
+ */
+export declare function shouldChargeVoucherOnAcceptance(parameters: Pick<ApplyVerifiedHttpAccountingParameters, 'capturedRequest' | 'payloadAction'> & {
+    unitType: unknown;
+}): boolean;
 /** Applies the default HTTP content charge after a session credential has been accepted. */
 export declare function applyVerifiedHttpAccounting(parameters: ApplyVerifiedHttpAccountingParameters): Promise<SessionReceipt>;
 /** Atomically deducts spend from a channel and maps store failures to typed session errors. */

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

@@ -171,6 +171,18 @@ export function shouldApplyVerifiedHttpAccounting(parameters) {
         return false;
     return isSessionContentRequest(capturedRequest);
 }
+/**
+ * Returns whether a voucher pays for its request in the store update that accepts it. A
+ * request-priced content request is charged exactly once, so this is the charge the HTTP
+ * accounting or the streamed response would make, without a second store update; the receipt is
+ * then marked prepaid so an SSE response does not charge again.
+ */
+export function shouldChargeVoucherOnAcceptance(parameters) {
+    const { capturedRequest, payloadAction, unitType } = parameters;
+    if (!capturedRequest || payloadAction !== 'voucher' || unitType !== 'request')
+        return false;
+    return isSessionContentRequest(capturedRequest);
+}
 /** Applies the default HTTP content charge after a session credential has been accepted. */
 export async function applyVerifiedHttpAccounting(parameters) {
     const { receipt, sseEnabled } = parameters;

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

@@ -27,9 +27,8 @@ export type { SessionController } from './MeteredStream.js';
  * 2. If balance is sufficient, emits `event: message` with the value.
  * 3. If balance is exhausted, emits `event: payment-need-voucher`
  *    and polls store until the client tops up the channel.
- * 4. Commits the reserved charge immediately before the chunk is emitted. If a
- *    manual generator completes after charging without yielding another chunk,
- *    commits that terminal charge on successful completion.
+ * 4. Commits automatic charges before emission and manual charges before
+ *    `stream.charge()` resolves, retaining them on cancellation or failure.
  * 5. On generator completion, emits a final `event: payment-receipt`.
  *
  * Returns a `ReadableStream<Uint8Array>` suitable for use as an HTTP response body.
@@ -43,6 +42,8 @@ export declare namespace serve {
         challengeId: string;
         tickCost: bigint;
         generate: AsyncIterable<string> | ((stream: SessionController) => AsyncIterable<string>);
+        /** Verifies live escrow before charging and delivering stream items. */
+        beforeCharge?: MeteredStreamOptions['beforeCharge'];
         /** Callback invoked after each nonzero stream charge is committed. */
         onChargeCommitted?: MeteredStreamOptions['onChargeCommitted'];
         pollIntervalMs?: number | undefined;

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

@@ -26,9 +26,8 @@ export { extractData, formatMessageEvent, formatNeedVoucherEvent, formatReceiptE
  * 2. If balance is sufficient, emits `event: message` with the value.
  * 3. If balance is exhausted, emits `event: payment-need-voucher`
  *    and polls store until the client tops up the channel.
- * 4. Commits the reserved charge immediately before the chunk is emitted. If a
- *    manual generator completes after charging without yielding another chunk,
- *    commits that terminal charge on successful completion.
+ * 4. Commits automatic charges before emission and manual charges before
+ *    `stream.charge()` resolves, retaining them on cancellation or failure.
  * 5. On generator completion, emits a final `event: payment-receipt`.
  *
  * Returns a `ReadableStream<Uint8Array>` suitable for use as an HTTP response body.
@@ -44,6 +43,7 @@ export function serve(options) {
         channelId,
         tickCost,
         generate,
+        beforeCharge: options.beforeCharge,
         onChargeCommitted: options.onChargeCommitted,
         pollIntervalMs,
         prepaidUnits: options.prepaidUnits,

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

@@ -1,3 +1,4 @@
+import { type SessionCredentialContext } from '../precompile/Protocol.js';
 import * as ChannelStore from './ChannelStore.js';
 import type { MeteredStreamOptions, SessionController } from './MeteredStream.js';
 import type { SettleChargedSessionChannel } from './Settlement.js';
@@ -16,6 +17,11 @@ export type SessionRouteResult = {
 };
 /** HTTP route used to perform a WebSocket payment probe. */
 export type SessionRoute = (request: Request) => Promise<SessionRouteResult>;
+type StreamContext = {
+    challengeId: string;
+    channelId: SessionCredentialContext['channelId'];
+    tickCost: bigint;
+};
 /**
  * Bridge a WebSocket connection to a Tempo session payment flow.
  *
@@ -47,7 +53,9 @@ export declare namespace serve {
         /** Payment route handler. Receives synthetic `POST` requests with only
          *  the `Authorization` header — no cookies, bodies, or upgrade headers. */
         route: SessionRoute;
-        /** Optional low-level hook invoked after each committed stream charge. */
+        /** Verifies live escrow before charging and delivering stream items. */
+        beforeCharge?: ((channelId: StreamContext['channelId']) => void | Promise<void>) | undefined;
+        /** Callback invoked after each nonzero stream charge is committed. */
         onChargeCommitted?: MeteredStreamOptions['onChargeCommitted'];
         /** @deprecated Use `onChargeCommitted`. */
         settleScheduled?: SettleChargedSessionChannel | undefined;

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

@@ -65,6 +65,7 @@ export async function serve(options) {
                 channelId: context.channelId,
                 tickCost: context.tickCost,
                 generate,
+                beforeCharge: () => options.beforeCharge?.(context.channelId),
                 onChargeCommitted: options.onChargeCommitted ?? options.settleScheduled,
                 pollIntervalMs,
                 signal: abortController.signal,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",