mppx 0.17.1 → 0.17.4

package/dist/cli/sessions/Manager.js

@@ -1,4 +1,5 @@
 import * as Challenge from '../../Challenge.js';
+import * as ProofRealm from '../../client/internal/ProofRealm.js';
 import { resolveEscrow } from '../../tempo/session/client/ChannelOps.js';
 import { getSessionManagerInternals } from '../../tempo/session/client/internal/SessionManager.js';
 import { sessionManager } from '../../tempo/session/client/SessionManager.js';
@@ -25,6 +26,14 @@ function assertCloseChallengeScope(challenge, channel) {
 /** Rehydrates durable session context and cooperatively closes it through the manager. */
 export async function closeWithSessionManager(parameters) {
     assertCloseChallengeScope(parameters.challenge, parameters.channel);
+    let channel = parameters.channel;
+    if (channel.origin === undefined) {
+        const url = new URL(parameters.input instanceof Request ? parameters.input.url : parameters.input);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('Legacy session close requires an HTTP origin');
+        ProofRealm.assert(parameters.challenge, url, parameters.manager.trustedTempoProofRealms);
+        channel = { ...channel, origin: url.origin };
+    }
     const networkFetch = resolveFetch(parameters.fetch);
     let pendingChallenge;
     const validatedFetch = async (input, init) => {
@@ -48,7 +57,9 @@ export async function closeWithSessionManager(parameters) {
         escrow: parameters.channel.escrow,
         fetch: validatedFetch,
     });
-    getSessionManagerInternals(manager).rehydrate(parameters);
+    getSessionManagerInternals(manager).rehydrate({ ...parameters, channel });
+    if (channel !== parameters.channel)
+        await parameters.manager.channelStore?.set(channel);
     const receipt = await manager.close();
     if (!receipt)
         throw new Error('Session close response did not include a payment receipt.');

package/dist/cli/utils.d.ts

@@ -58,6 +58,8 @@ export declare function fmtRequestValue(key: string, value: unknown, ctx: {
 }): string;
 export declare function decodeMemo(hex: string): string | undefined;
 export declare function fmtChallengeValue(key: string, value: unknown): string;
+/** Formats a problem-details field for display, serializing nested objects and arrays as JSON. */
+export declare function fmtProblemValue(value: unknown): string;
 export declare function link(url: string, text: string): string;
 export declare function parseMethodOpts(raw: string | string[] | undefined): Record<string, string>;
 /** Returns true when the CLI is running inside an agent wrapper that prefers machine-readable output. */

package/dist/cli/utils.js

@@ -141,6 +141,12 @@ export function fmtChallengeValue(key, value) {
     }
     return String(value);
 }
+/** Formats a problem-details field for display, serializing nested objects and arrays as JSON. */
+export function fmtProblemValue(value) {
+    if (value !== null && typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
 export function link(url, text) {
     return pc.link(url, text);
 }

package/dist/cli/validate/challenge.d.ts

@@ -15,6 +15,10 @@ export declare function validateChallenge(baseUrl: string, endpoint: EndpointSpe
 export declare function validateRealmMatchesHost(challenges: Challenge.Challenge[], serverHost: string, results: CheckResult[]): void;
 export declare function validateErrorHandling(baseUrl: string, endpoint: EndpointSpec, options?: {
     body?: string | undefined;
+    /** The Challenge whose Credential header the probe targets. Defaults to `Authorization`. */
+    challenge?: Challenge.Challenge | undefined;
+    /** Extra `Name: value` headers (`-H`), such as an API key the endpoint requires. */
+    extraHeaders?: string[] | undefined;
     query?: string[] | undefined;
 }): Promise<CheckResult[]>;
 //# sourceMappingURL=challenge.d.ts.map

package/dist/cli/validate/challenge.js

@@ -289,13 +289,16 @@ function validateAmount(request, tag, results, unitHint) {
 export async function validateErrorHandling(baseUrl, endpoint, options) {
     const results = [];
     const url = buildUrl(baseUrl, endpoint, options?.query);
-    const fetchHeaders = {
-        [Constants.Headers.authorization]: `${Constants.Schemes.payment} dGhpcyBpcyBnYXJiYWdl`,
-    };
+    const fetchHeaders = parseHeaders(options?.extraHeaders);
+    const credentialHeader = options?.challenge
+        ? Challenge.credentialHeader(options.challenge)
+        : Constants.Headers.authorization;
+    fetchHeaders[credentialHeader.toLowerCase()] = `${Constants.Schemes.payment} dGhpcyBpcyBnYXJiYWdl`;
     let fetchBody;
     if (options?.body) {
         fetchBody = options.body;
-        fetchHeaders['content-type'] = 'application/json';
+        if (!fetchHeaders['content-type'])
+            fetchHeaders['content-type'] = 'application/json';
     }
     try {
         const response = await fetchWithTimeout(url, {
@@ -314,10 +317,10 @@ export async function validateErrorHandling(baseUrl, endpoint, options) {
             }
         }
         else if (response.status >= 500) {
-            results.push(fail('Malformed credential returns 402', `Got ${response.status} (server error)`, 'When the Authorization header contains an invalid credential, respond with 402 (not 500). Catch credential validation errors and return a fresh challenge.'));
+            results.push(fail('Malformed credential returns 402', `Got ${response.status} (server error)`, `When the ${credentialHeader} header contains an invalid credential, respond with 402 (not 500). Catch credential validation errors and return a fresh challenge.`));
         }
         else {
-            results.push(warn('Malformed credential returns 402', `Got ${response.status}`, `When the Authorization header contains an invalid Payment credential, respond with 402 and a fresh WWW-Authenticate challenge. Returning ${response.status} prevents the client from retrying with a valid payment.`));
+            results.push(warn('Malformed credential returns 402', `Got ${response.status}`, `When the ${credentialHeader} header contains an invalid Payment credential, respond with 402 and a fresh WWW-Authenticate challenge. Returning ${response.status} prevents the client from retrying with a valid payment.`));
         }
     }
     catch (error) {

package/dist/client/Mppx.d.ts

@@ -189,7 +189,7 @@ export declare namespace create {
         /** Transport to use (defaults to HTTP). */
         transport?: transport | undefined;
         /**
-         * Server origins allowed to request zero-amount Tempo proofs for a realm other than their
+         * Server origins allowed to request zero-amount Tempo proofs or session payments for a realm other than their
          * hostname, mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
          * With `Transport.mcp()`, which has no origin, only realms listed here are trusted,
          * whatever their origin.

package/dist/client/Mppx.js

@@ -4,6 +4,7 @@ import * as IdentityClient from '../identity/Client.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Fetch from './internal/Fetch.js';
 import * as MethodChallenge from './internal/MethodChallenge.js';
+import * as MethodResponse from './internal/MethodResponse.js';
 import * as ProofRealm from './internal/ProofRealm.js';
 import * as Transport from './Transport.js';
 const preparedPaymentMethods = new WeakMap();
@@ -112,7 +113,7 @@ export function create(config) {
                 try {
                     if (selectedChallenge.expires)
                         Expires.assert(selectedChallenge.expires, selectedChallenge.id);
-                    const createCredential = memoizeCreateCredential((overrideContext) => createCredentialForMethod(selectedChallenge, selectedMethod, overrideContext ?? context));
+                    const createCredential = memoizeCreateCredential((overrideContext) => createCredentialForMethod(selectedChallenge, selectedMethod, overrideContext ?? context, responseUrl?.origin));
                     const eventCredential = await events.emit('challenge.received', createChallengeReceivedPayload({
                         challenge: selectedChallenge,
                         challenges,
@@ -482,9 +483,12 @@ function resolveChallengePreferences(fallback, override) {
 async function resolveChallengeOrder(candidates, orderChallenges) {
     return orderChallenges ? orderChallenges(candidates) : candidates;
 }
-async function createCredentialForMethod(challenge, mi, context) {
+async function createCredentialForMethod(challenge, mi, context, origin) {
     const parsedContext = mi.context && context !== undefined ? mi.context.parse(context) : undefined;
-    return mi.createCredential(parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge });
+    const parameters = parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge };
+    if (origin)
+        MethodResponse.attachOrigin(parameters, origin);
+    return mi.createCredential(parameters);
 }
 /** Returns the URL of the HTTP server that sent `response`, or `undefined` when it has none. */
 function resolveResponseUrl(response) {

package/dist/client/internal/Fetch.d.ts

@@ -116,7 +116,7 @@ export declare namespace from {
         /** Transport to use for challenge extraction and credential attachment. */
         transport?: Transport.AnyTransport | undefined;
         /**
-         * Server origins allowed to request zero-amount Tempo proofs for a realm other than their
+         * Server origins allowed to request zero-amount Tempo proofs or session payments for a realm other than their
          * hostname, mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
          */
         trustedTempoProofRealms?: ProofRealm.TrustedRealms | undefined;

package/dist/client/internal/Fetch.js

@@ -8,6 +8,7 @@ import * as Transport from '../Transport.js';
 import * as MethodChallenge from './MethodChallenge.js';
 import * as MethodResponse from './MethodResponse.js';
 import * as ProofRealm from './ProofRealm.js';
+import { adapterOwnsPayment } from './protocols/Mcp.js';
 // We tag wrappers with a global symbol so we can recognize wrappers created by mppx,
 // even across multiple module instances/bundles. This lets restore() avoid clobbering
 // an unrelated fetch installed by user code or another library.
@@ -129,6 +130,8 @@ export function from(config) {
         const transportRequest = withCapturedBody(initialRequest.init, await capturedBody);
         if (init?.[skipPayment])
             return response;
+        if (adapterOwnsPayment(transportRequest))
+            return response;
         if (!(await transport.isPaymentRequired(response, transportRequest)))
             return response;
         // Only extract context for payment handling after confirming 402.
@@ -194,6 +197,7 @@ export function from(config) {
                     if (!MethodChallenge.has(selected.method))
                         return resolveCredential(selectedChallenge, selected.method, credentialContext);
                     const attempt = {
+                        origin: resolveRequestUrl(paymentInput).origin,
                         prepare: () => MethodChallenge.handle(selected.method, {
                             challenge: selectedChallenge,
                             context: credentialContext,
@@ -211,6 +215,7 @@ export function from(config) {
                         .prepare()
                         .then(() => resolveCredential(selectedChallenge, selected.method, credentialContext, attempt));
                     preparedCredential = {
+                        context: credentialContext,
                         attempt,
                         key: overrideContext === undefined ? key : undefined,
                         method: selected.method,
@@ -239,6 +244,7 @@ export function from(config) {
                     await settleAttempt(prepared, { status: 'rejected' });
                     preparedCredential = undefined;
                 }
+                const effectiveContext = preparedCredential ? preparedCredential.context : context;
                 validateCredentialHeaderValue(credential);
                 await events.emit('credential.created', createCredentialCreatedPayload({
                     challenge: selectedChallenge,
@@ -322,6 +328,7 @@ export function from(config) {
                     if (!response.ok)
                         return response;
                     return MethodResponse.handle(selected.method, {
+                        context: effectiveContext,
                         challenge: selectedChallenge,
                         credential,
                         fetch: baseFetch,
@@ -753,6 +760,8 @@ export function validateCredentialHeaderValue(credential) {
 async function resolveCredential(challenge, mi, context, attempt) {
     const parsedContext = mi.context && context !== undefined ? mi.context.parse(context) : undefined;
     const parameters = parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge };
+    if (attempt?.origin)
+        MethodResponse.attachOrigin(parameters, attempt.origin);
     if (attempt)
         MethodResponse.attachAttempt(mi, parameters, attempt);
     return mi.createCredential(parameters);

package/dist/client/internal/MethodResponse.d.ts

@@ -7,6 +7,8 @@ export type AttemptOutcome = {
     status: 'accepted' | 'pending' | 'rejected';
 };
 export type Attempt = {
+    /** Authorized HTTP origin, checked before any credential is signed. */
+    origin?: string | undefined;
     /** Re-runs method preparation when serialized state changed before signing. */
     prepare: () => Promise<void>;
     /** Settles state created for one credential attempt. */
@@ -14,6 +16,8 @@ export type Attempt = {
 };
 /** Inputs available when a client method handles a successful paid response. */
 export type HandlerParameters = {
+    /** Original request policy for automatic follow-up payments. */
+    context?: unknown;
     challenge: Challenge.Challenge;
     credential: string;
     fetch: typeof globalThis.fetch;
@@ -41,4 +45,8 @@ export declare function handle(method: Method.AnyClient, parameters: HandlerPara
 export declare function registerTransactionHash<const method extends Method.AnyClient>(method: method, derive: TransactionHash): method;
 /** Returns the credential's on-chain hash when its method can derive it. */
 export declare function getTransactionHash(method: Method.AnyClient, credential: string): string | undefined;
+/** Associates an explicitly verified HTTP origin with credential creation. */
+export declare function attachOrigin(parameters: object, origin: string): void;
+/** Returns the authorized origin for direct or fetch-owned credential creation. */
+export declare function getOrigin(parameters: object): string | undefined;
 //# sourceMappingURL=MethodResponse.d.ts.map

package/dist/client/internal/MethodResponse.js

@@ -1,5 +1,6 @@
 const handlers = new WeakMap();
 const attempts = new WeakMap();
+const origins = new WeakMap();
 const transactionHashes = new WeakMap();
 /** Registers an internal response adapter without changing the public method shape. */
 export function register(method, handler) {
@@ -38,4 +39,12 @@ export function getTransactionHash(method, credential) {
         return undefined;
     }
 }
+/** Associates an explicitly verified HTTP origin with credential creation. */
+export function attachOrigin(parameters, origin) {
+    origins.set(parameters, origin);
+}
+/** Returns the authorized origin for direct or fetch-owned credential creation. */
+export function getOrigin(parameters) {
+    return origins.get(parameters) ?? attempts.get(parameters)?.origin;
+}
 //# sourceMappingURL=MethodResponse.js.map

package/dist/client/internal/ProofRealm.d.ts

@@ -1,12 +1,12 @@
 import type * as Challenge from '../../Challenge.js';
 /**
- * Pins that let a server origin request zero-amount Tempo proofs for a realm other than its
+ * Pins that let a server origin request zero-amount Tempo proofs or session payments for a realm other than its
  * hostname, keyed by origin (`scheme://host[:port]`), such as
  * `{ 'https://api.example.com': 'MPP Payment' }`.
  */
 export type TrustedRealms = Readonly<Record<string, string>>;
 /**
- * Refuses a zero-amount Tempo proof whose realm the HTTP server that sent the Challenge does not
+ * Refuses a Tempo proof or session payment whose realm the HTTP server that sent the Challenge does not
  * own. A proof authenticates the payer at the Challenge realm, so a foreign origin could otherwise
  * relay another server's Challenge and replay the signed proof there. The server owns the realm
  * when it is the request hostname, or when `trustedRealms` pins it to the request origin. Pass
@@ -14,7 +14,7 @@ export type TrustedRealms = Readonly<Record<string, string>>;
  */
 export declare function assert(challenge: Challenge.Challenge, url: URL | (() => URL), trustedRealms: TrustedRealms | undefined): void;
 /**
- * Refuses a zero-amount Tempo proof on a transport without an origin, such as MCP, unless
+ * Refuses a Tempo proof or session payment on a transport without an origin, such as MCP, unless
  * `trustedRealms` lists its realm.
  */
 export declare function assertWithoutOrigin(challenge: Challenge.Challenge, trustedRealms: readonly string[] | undefined): void;

package/dist/client/internal/ProofRealm.js

@@ -1,12 +1,12 @@
 /**
- * Refuses a zero-amount Tempo proof whose realm the HTTP server that sent the Challenge does not
+ * Refuses a Tempo proof or session payment whose realm the HTTP server that sent the Challenge does not
  * own. A proof authenticates the payer at the Challenge realm, so a foreign origin could otherwise
  * relay another server's Challenge and replay the signed proof there. The server owns the realm
  * when it is the request hostname, or when `trustedRealms` pins it to the request origin. Pass
  * `url` as a function to resolve it only for proof Challenges.
  */
 export function assert(challenge, url, trustedRealms) {
-    if (!isProof(challenge))
+    if (!isProof(challenge) && !(challenge.method === 'tempo' && challenge.intent === 'session'))
         return;
     url = typeof url === 'function' ? url() : url;
     const { realm } = challenge;
@@ -19,11 +19,11 @@ export function assert(challenge, url, trustedRealms) {
     throw new Error(`Refusing to sign Tempo proof for realm ${JSON.stringify(realm)} from ${url.origin}. Pin the realm to this origin with \`trustedTempoProofRealms\` if this server is expected to issue it.`);
 }
 /**
- * Refuses a zero-amount Tempo proof on a transport without an origin, such as MCP, unless
+ * Refuses a Tempo proof or session payment on a transport without an origin, such as MCP, unless
  * `trustedRealms` lists its realm.
  */
 export function assertWithoutOrigin(challenge, trustedRealms) {
-    if (!isProof(challenge))
+    if (!isProof(challenge) && !(challenge.method === 'tempo' && challenge.intent === 'session'))
         return;
     if (trustedRealms?.includes(challenge.realm))
         return;

package/dist/client/internal/protocols/Mcp.d.ts

@@ -1,5 +1,9 @@
 import * as Mcp from '../../../Mcp.js';
 import type { Protocol } from './Protocol.js';
+/** Metadata that delegates all payment decisions to the MCP client adapter. */
+export declare const adapterPaymentMetaKey = "mppx/payment-client";
+/** Whether the caller's MCP adapter owns approval and payment retry for this request. */
+export declare function adapterOwnsPayment(request?: RequestInit): boolean;
 type CorePaymentRequiredData = NonNullable<Mcp.ErrorObject['data']>;
 export type PaymentRequiredData = Pick<CorePaymentRequiredData, 'challenges'> & Partial<Pick<CorePaymentRequiredData, 'httpStatus' | 'problem'>>;
 /** Extracts validated payment-required data from MCP errors or tool result metadata. */

package/dist/client/internal/protocols/Mcp.js

@@ -1,6 +1,6 @@
-import { createParser } from 'eventsource-parser';
 import * as Challenge from '../../../Challenge.js';
 import * as Credential from '../../../Credential.js';
+import { createParser } from '../../../internal/sse.js';
 import * as Mcp from '../../../Mcp.js';
 import { paymentRequiredStatus } from './Shared.js';
 /** Returns the JSON-RPC request id — only requests can receive a `-32042` response. */
@@ -18,6 +18,22 @@ function jsonRpcRequestId(body) {
         return undefined;
     }
 }
+/** Metadata that delegates all payment decisions to the MCP client adapter. */
+export const adapterPaymentMetaKey = 'mppx/payment-client';
+/** Whether the caller's MCP adapter owns approval and payment retry for this request. */
+export function adapterOwnsPayment(request) {
+    if (typeof request?.body !== 'string')
+        return false;
+    try {
+        const message = JSON.parse(request.body);
+        return (message?.jsonrpc === '2.0' &&
+            message?.method === 'tools/call' &&
+            message.params?._meta?.[adapterPaymentMetaKey] === true);
+    }
+    catch {
+        return false;
+    }
+}
 // Bound automatic inspection; the caller retains the original response stream.
 const maxInspectionBytes = 1024 * 1024;
 const responseCache = new WeakMap();
@@ -99,18 +115,16 @@ async function parseSseJsonRpcResponse(response) {
     let received = 0;
     let dataEventSeen = false;
     let message;
-    const parser = createParser({
-        onEvent(event) {
-            if (dataEventSeen || !event.data)
-                return;
-            dataEventSeen = true;
-            if (event.event && event.event !== 'message')
-                return;
-            try {
-                message = parseMessage(JSON.parse(event.data));
-            }
-            catch { }
-        },
+    const parser = createParser((event) => {
+        if (dataEventSeen || !event.data)
+            return;
+        dataEventSeen = true;
+        if (event.event !== 'message')
+            return;
+        try {
+            message = parseMessage(JSON.parse(event.data));
+        }
+        catch { }
     });
     try {
         for (;;) {
@@ -119,7 +133,6 @@ async function parseSseJsonRpcResponse(response) {
             const { done, value } = await reader.read();
             if (done) {
                 parser.feed(decoder.decode());
-                parser.reset({ consume: true });
                 return message;
             }
             received += value.byteLength;

package/dist/cloudflare/ChannelStore.d.ts

@@ -0,0 +1,97 @@
+import type { Hex } from 'viem';
+import * as Store from '../Store.js';
+import { type State } from '../tempo/session/server/ChannelStore.js';
+/**
+ * Durable Object class that stores Tempo session channels, as {@link Store.durableObject}
+ * does, and settles them on-chain without a request in flight.
+ *
+ * Every channel lives in its own object. After each write of a channel state, the object
+ * checks how much a settlement could capture ({@link unsettledAmount}): from
+ * `max(10% of deposit, minUnsettledAmount)` it sends `{ channelId }` to the settlement
+ * queue at once; below that it sets an alarm that sends it once the channel has had no
+ * write for `staleAfterMs`. The Worker's `queue()` handler settles it with
+ * {@link settle}. After each send, a watchdog alarm sends it again while the channel
+ * stays unsettled (a dropped, dead-lettered or failed job), waiting twice as long each
+ * time, up to `maxAttempts` sends; settling more on-chain restarts the count. A close request,
+ * or a threshold's worth of new vouchers since the last send, sends it again at once and
+ * restarts the count, so a failed job never leaves them waiting on a long watchdog.
+ *
+ * Export a subclass from your Worker, bind it with a `new_sqlite_classes` migration and
+ * bind the queue as `MPPX_SETTLEMENT_QUEUE`, or override
+ * {@link ChannelStore.settlement} to change the queue or thresholds.
+ *
+ * @example
+ * ```ts
+ * import { DurableObject } from 'cloudflare:workers'
+ * import { ChannelStore } from 'mppx/cloudflare'
+ *
+ * export class MppxChannels extends ChannelStore.rpc(DurableObject) {}
+ * ```
+ */
+export declare class ChannelStore extends Store.DurableObjectStore {
+    /**
+     * The settlement queue and thresholds. Reads the `MPPX_SETTLEMENT_QUEUE` binding by
+     * default; a subclass overrides it to use another binding or other thresholds.
+     */
+    protected settlement(): ChannelStore.Settlement;
+    /** Schedules settlement of a written channel state, and drops it for a closed or deleted one. */
+    protected onWrite(key: string, _previous: unknown, next: unknown, transaction?: Store.DurableObjectStore.Storage | undefined): Promise<void>;
+    /** Sends a channel over the threshold or gone stale to the queue, or sends it again from the watchdog while unsettled. */
+    alarm(): Promise<void>;
+    /**
+     * Sends the channel to the settlement queue and sets the watchdog alarm, or gives up after
+     * `maxAttempts` sends. A send that fails leaves the count alone and tries again from an
+     * alarm, since the write that scheduled it has already committed.
+     */
+    private send;
+}
+export declare namespace ChannelStore {
+    /** The settlement queue and when to settle. */
+    type Settlement = {
+        /** Queue the object sends `{ channelId }` to; the Worker's `queue()` handler settles it. */
+        queue: Queue | undefined;
+        /** Raw amount a settlement must capture before it is sent at once, if 10% of the deposit is less. @default 100_000n */
+        minUnsettledAmount?: bigint | undefined;
+        /** Sends a channel below the threshold once it has had no write for this long. @default 300_000 */
+        staleAfterMs?: number | undefined;
+        /**
+         * Sends a channel again this long after a send while it stays unsettled, doubling each time.
+         * Keep the first resend well inside the escrow's close grace period (15 minutes), after which
+         * a payer who requested a close can withdraw what is unsettled; a closing channel is sent
+         * again after at most 2 minutes. @default 300_000
+         */
+        watchdogMs?: number | undefined;
+        /** Sends a channel at most this many times without on-chain progress. @default 6 */
+        maxAttempts?: number | undefined;
+        /** Tries a send that failed again this much later. @default 60_000 */
+        retryMs?: number | undefined;
+    };
+    /** The subset of a Cloudflare `Queue` binding the object uses. */
+    type Queue = {
+        send: (body: Message) => Promise<unknown>;
+    };
+    /** The settlement job the object sends. */
+    type Message = {
+        channelId: Hex;
+    };
+}
+/** Whether a stored value is a precompile-backed session channel state. */
+export declare function isChannelState(value: unknown): value is State;
+/**
+ * The raw amount a settlement of the channel would capture now: the largest accepted voucher
+ * within `spent` (as mppx's `settle` picks it) above `settledOnChain`.
+ */
+export declare function unsettledAmount(state: State): bigint;
+/**
+ * Whether the server's own cooperative close may still land: its marker stands in
+ * `closeRequestedAt` and its transaction has not expired. That close captures every voucher a
+ * settlement could, so settling meanwhile only spends gas.
+ */
+export declare function pendingClose(state: State, now?: number): boolean;
+/**
+ * When the channel needs settling: `threshold` (now) once the unsettled amount reaches
+ * `max(10% of deposit, minUnsettledAmount)`, `stale` (once idle) below it, or
+ * `undefined` when it is finalized or has nothing to settle.
+ */
+export declare function settlementDue(state: State, settlement?: Pick<ChannelStore.Settlement, 'minUnsettledAmount'>): 'stale' | 'threshold' | undefined;
+//# sourceMappingURL=ChannelStore.d.ts.map