@comfyorg/account-core 1.0.0-alpha.0 → 1.0.0-alpha.1

package/dist/core/billing/operationLifecycle.js

@@ -16,14 +16,17 @@
  * wiring onto the scope source, the scope tracker, and the generated
  * contract is new.
  */
-import { zBillingOpStatusResponse } from '@comfyorg/ingest-types/zod';
 import { BILLING_OPERATION_TELEMETRY_EVENT } from '../../telemetry.js';
 import { createBillingScopeTracker } from './billingScope.js';
 import { NO_POINTER_STORE, createOperationPointerStore } from './operationPointer.js';
-import { hasExhaustedPollBudget, nextPollDelayMs } from './operationPolicy.js';
-import { isTerminal, reduceBillingOperation, validateActionUrl } from './operationState.js';
+import { hasExhaustedPollBudget, isWaitingOnCustomerWithoutAction, nextPollDelayMs } from './operationPolicy.js';
+import { BillingOpStatusSchema, isGrantLanding, isTerminal, reduceBillingOperation, validateActionUrl } from './operationState.js';
 import { selectBillingPresentation } from './presentation.js';
 import { readValidatedBillingResponse } from './sharedRead.js';
+/** Settled, but a later read may still change what the operation reports. */
+function isStillSettling(state) {
+    return state.phase === 'reconciliation_needed' || isGrantLanding(state);
+}
 export function operationRoute(operationId) {
     return `/billing/ops/${encodeURIComponent(operationId)}`;
 }
@@ -35,6 +38,10 @@ const SUPERSEDED = {
     status: 'error',
     code: 'SUPERSEDED'
 };
+const OPERATION_ALREADY_PENDING = {
+    status: 'error',
+    code: 'OPERATION_ALREADY_PENDING'
+};
 function continuationOf(issued) {
     return {
         ...(issued.actionUrl === undefined ? {} : { actionUrl: issued.actionUrl }),
@@ -67,6 +74,7 @@ function initialPendingState(input, observedAt, presentation) {
         ...presentation,
         observedAt,
         attemptStartedAt: input.attemptStartedAt,
+        ...(input.awaitedHere ? { awaitedHere: true } : {}),
         phase: 'pending',
         ...(actionUrl === undefined ? {} : { actionUrl }),
         ...(challenge === undefined ? {} : { challenge }),
@@ -96,7 +104,9 @@ export function createBillingOperationLifecycle(options) {
     const { transport, scopeSource, statusReader, embeddedCheckoutAvailable = () => false, hostedDestination = () => 'stripe', onTelemetry, now = Date.now } = options;
     const pointers = options.pointerStorage === undefined
         ? NO_POINTER_STORE
-        : createOperationPointerStore(options.pointerStorage, now);
+        : createOperationPointerStore(options.pointerStorage, now, {
+            retainSettled: options.retainSettledPointer === true
+        });
     const operations = new Map();
     const inFlightCommands = new Map();
     const listeners = new Set();
@@ -114,7 +124,7 @@ export function createBillingOperationLifecycle(options) {
         return !lifetime.disposed && scopeTracker.isCurrent(context);
     }
     function publish(record) {
-        for (const listener of [...listeners])
+        for (const listener of Array.from(listeners))
             listener(record.state);
     }
     function stopTimer(record) {
@@ -152,7 +162,7 @@ export function createBillingOperationLifecycle(options) {
         record.state = next;
         if (isTerminal(next)) {
             stopTimer(record);
-            pointers.clearIfTerminal(next);
+            pointers.settle(next);
             emitTerminalTelemetry(record);
             record.resolveSettled(next);
         }
@@ -162,7 +172,12 @@ export function createBillingOperationLifecycle(options) {
         if (record.state.phase !== 'pending')
             return;
         stopTimer(record);
-        const delayMs = nextPollDelayMs(record.state, record.delayMs);
+        record.waitingWithoutActionSince = isWaitingOnCustomerWithoutAction(record.state)
+            ? (record.waitingWithoutActionSince ?? now())
+            : undefined;
+        const delayMs = nextPollDelayMs(record.state, record.delayMs, record.waitingWithoutActionSince === undefined
+            ? 0
+            : now() - record.waitingWithoutActionSince);
         record.delayMs = delayMs;
         record.timer = setTimeout(() => void poll(record), delayMs);
     }
@@ -185,11 +200,12 @@ export function createBillingOperationLifecycle(options) {
             operationId: state.id,
             kind: state.kind,
             presentation: state.presentation,
-            attemptStartedAt: state.attemptStartedAt
+            attemptStartedAt: state.attemptStartedAt,
+            ...(state.awaitedHere ? { awaited: true } : {})
         });
     }
     function readOperation(operationId) {
-        return readValidatedBillingResponse(transport, { method: 'GET', route: operationRoute(operationId) }, (body) => zBillingOpStatusResponse.safeParse(body));
+        return readValidatedBillingResponse(transport, { method: 'GET', route: operationRoute(operationId) }, (body) => BillingOpStatusSchema.safeParse(body));
     }
     function continueOrExpire(record) {
         if (record.state.phase !== 'pending')
@@ -248,11 +264,19 @@ export function createBillingOperationLifecycle(options) {
             ? { presentation, hostedDestination: hostedDestination() }
             : { presentation };
     }
-    function adopt(input) {
+    /**
+     * An id is observed afresh once this tab has stopped learning anything new
+     * about it: its poll budget ran out or it left the scope. One the server
+     * parked for reconciliation, or a success whose credits were still landing,
+     * is observed afresh only for a caller reading settled operations, since
+     * the server may since have settled it or recorded the grant.
+     */
+    function adopt(input, includeSettled = false) {
         const existing = operations.get(input.id);
         if (existing !== undefined &&
             existing.state.phase !== 'timed_out' &&
-            existing.state.phase !== 'superseded') {
+            existing.state.phase !== 'superseded' &&
+            !(includeSettled && isStillSettling(existing.state))) {
             return existing;
         }
         const state = initialPendingState(input, now(), destinationFor(input.presentation));
@@ -265,6 +289,7 @@ export function createBillingOperationLifecycle(options) {
             context: input.context,
             resumed: input.resumed,
             delayMs: undefined,
+            waitingWithoutActionSince: undefined,
             timer: undefined,
             inFlightPoll: undefined,
             settled,
@@ -279,15 +304,22 @@ export function createBillingOperationLifecycle(options) {
             presentation: input.presentation,
             resumed: input.resumed
         });
-        publish(record);
-        if (input.initialStatus === undefined) {
-            void poll(record);
-        }
-        else {
+        startObserving(record, input, state);
+        return record;
+    }
+    // A resumed operation without a served link is announced by its first
+    // status, never before it: the status read names it but not what it waits
+    // on, and a checkout parked on a card must not be announced as processing
+    // for the length of a poll. A served link already says what it waits on.
+    function startObserving(record, input, state) {
+        if (input.initialStatus !== undefined) {
             dispatch(record, { type: 'status_polled', status: input.initialStatus });
             continueOrExpire(record);
+            return;
         }
-        return record;
+        if (!input.resumed || state.actionUrl !== undefined)
+            publish(record);
+        void poll(record);
     }
     function routeFor(rail, issued) {
         return selectBillingPresentation({
@@ -311,34 +343,21 @@ export function createBillingOperationLifecycle(options) {
         if (status.status === 'error')
             return status;
         const rail = status.value.status.billing_rail;
-        const pending = pendingFromStatus(status.value.status);
-        if (pending !== undefined && pending.kind === kind) {
-            const record = adopt({
-                ...pending,
-                context,
-                presentation: routeFor(rail, pending),
-                attemptStartedAt: now(),
-                resumed: true
-            });
-            return { status: 'ok', value: record.state };
-        }
+        const parked = await resubmitTarget(pendingFromStatus(status.value.status), kind);
+        if (!isLive(context))
+            return SUPERSEDED;
+        if (parked === 'refused')
+            return OPERATION_ALREADY_PENDING;
         const attemptStartedAt = now();
         const issued = await issue(context.scope);
         if (!isLive(context)) {
-            // The operation exists server-side under the scope this tab just left;
-            // the pointer waits there so a return recovers it rather than reissuing.
-            if (issued.status === 'ok') {
-                pointers.write(context.scope, {
-                    operationId: issued.value.operationId,
-                    kind,
-                    presentation: routeFor(rail, issued.value),
-                    attemptStartedAt
-                });
-            }
-            return SUPERSEDED;
+            return leftScope(context, kind, rail, issued, attemptStartedAt);
         }
         if (issued.status === 'error')
             return issued;
+        const resumed = parked === undefined ? undefined : resumeParked(parked, issued.value);
+        if (resumed !== undefined)
+            return { status: 'ok', value: resumed };
         const record = adopt({
             id: issued.value.operationId,
             kind,
@@ -346,10 +365,66 @@ export function createBillingOperationLifecycle(options) {
             presentation: routeFor(rail, issued.value),
             ...continuationOf(issued.value),
             attemptStartedAt,
-            resumed: false
+            resumed: false,
+            awaitedHere: true
         });
         return { status: 'ok', value: record.state };
     }
+    // The operation exists server-side under the scope this tab just left; the
+    // pointer waits there so a return recovers it rather than reissuing.
+    function leftScope(context, kind, rail, issued, attemptStartedAt) {
+        if (issued.status === 'ok') {
+            pointers.write(context.scope, {
+                operationId: issued.value.operationId,
+                kind,
+                presentation: routeFor(rail, issued.value),
+                attemptStartedAt,
+                awaited: true
+            });
+        }
+        return SUPERSEDED;
+    }
+    /**
+     * Declines rather than joins an operation of this kind the server already
+     * has pending, because the status names no plan: this caller asked for one
+     * outcome and the parked attempt settles another, so reporting that one as
+     * this command's result would tell the customer they bought something they
+     * did not choose. recover() is where a deliberate return to it belongs.
+     *
+     * The exception is a checkout this tab watches parked on a card. The server
+     * keeps no link back to it, and a resubmit is how it resumes that checkout
+     * or replaces it, so the command goes through with that record in hand.
+     */
+    async function resubmitTarget(pending, kind) {
+        if (pending?.kind !== kind)
+            return undefined;
+        const record = operations.get(pending.id);
+        if (record?.state.phase === 'pending' &&
+            record.state.serverPhase === undefined) {
+            const read = await readOperation(pending.id);
+            if (read.status === 'ok') {
+                dispatch(record, { type: 'status_polled', status: read.value.data });
+            }
+        }
+        return record?.state.phase === 'pending' &&
+            record.state.serverPhase === 'awaiting_payment_method'
+            ? record
+            : 'refused';
+    }
+    /**
+     * The same id is the parked checkout resumed, with the fresh hosted step the
+     * server minted for it; another id replaced it, so this tab stops watching.
+     */
+    function resumeParked(parked, issued) {
+        if (parked.state.id !== issued.operationId) {
+            dispatch(parked, { type: 'superseded' });
+            return undefined;
+        }
+        if (issued.actionUrl !== undefined) {
+            dispatch(parked, { type: 'action_reissued', actionUrl: issued.actionUrl });
+        }
+        return parked.state;
+    }
     function begin(kind, issue) {
         if (lifetime.disposed)
             return Promise.resolve(SUPERSEDED);
@@ -370,38 +445,43 @@ export function createBillingOperationLifecycle(options) {
         inFlightCommands.set(kind, { context, promise: attempt });
         return attempt;
     }
-    // Unreachable is not "nothing pending": the pointer is the only evidence
-    // left, and observing it costs a poll while reissuing could cost a charge.
-    function recoverFromPointer(failure, pointer, context) {
-        if (failure.code !== 'REQUEST_FAILED' || pointer === undefined) {
-            return failure;
-        }
-        const record = adopt({
+    function fromPointer(pointer, context) {
+        return {
             id: pointer.operationId,
             kind: pointer.kind,
             context,
             presentation: pointer.presentation,
             attemptStartedAt: pointer.attemptStartedAt,
-            resumed: true
-        });
+            resumed: true,
+            awaitedHere: pointer.awaited === true
+        };
+    }
+    // Unreachable is not "nothing pending": the pointer is the only evidence
+    // left, and observing it costs a poll while reissuing could cost a charge.
+    function recoverFromPointer(failure, pointer, context, includeSettled) {
+        if (failure.code !== 'REQUEST_FAILED' || pointer === undefined) {
+            return failure;
+        }
+        const record = adopt(fromPointer(pointer, context), includeSettled);
         return { status: 'ok', value: record.state };
     }
-    function resumeServerPending(pending, rail, pointer, context) {
+    function resumeServerPending(pending, rail, pointer, context, includeSettled) {
         const known = pointer?.operationId === pending.id ? pointer : undefined;
         const record = adopt({
             ...pending,
             context,
             presentation: known?.presentation ?? routeFor(rail, pending),
             attemptStartedAt: known?.attemptStartedAt ?? now(),
-            resumed: true
-        });
+            resumed: true,
+            awaitedHere: known?.awaited === true
+        }, includeSettled);
         return { status: 'ok', value: record.state };
     }
     // The server reports nothing pending, so the pointed-at operation has
     // either settled since this tab last saw it or never belonged to this
     // scope. One read decides which; a stale pointer is dropped, never
     // re-observed on a schedule.
-    async function probePointer(pointer, context) {
+    async function probePointer(pointer, context, includeSettled) {
         const probe = await readOperation(pointer.operationId);
         if (!isLive(context))
             return SUPERSEDED;
@@ -411,18 +491,17 @@ export function createBillingOperationLifecycle(options) {
             pointers.clear(context.scope, pointer.operationId);
             return { status: 'ok', value: undefined };
         }
-        const record = adopt({
-            id: pointer.operationId,
-            kind: pointer.kind,
-            context,
-            presentation: pointer.presentation,
-            attemptStartedAt: pointer.attemptStartedAt,
-            resumed: true,
-            initialStatus: probe.value.data
-        });
+        const record = adopt({ ...fromPointer(pointer, context), initialStatus: probe.value.data }, includeSettled);
         return { status: 'ok', value: record.state };
     }
-    async function recover() {
+    /** A settled pointer answers only a caller that asked for it. */
+    function readPointer(scope, includeSettled) {
+        const pointer = pointers.read(scope);
+        return pointer?.settled === undefined || includeSettled
+            ? pointer
+            : undefined;
+    }
+    async function recover({ includeSettled = false } = {}) {
         if (lifetime.disposed)
             return SUPERSEDED;
         const context = scopeTracker.capture();
@@ -431,17 +510,17 @@ export function createBillingOperationLifecycle(options) {
         const status = await statusReader.read();
         if (!isLive(context))
             return SUPERSEDED;
-        const pointer = pointers.read(context.scope);
+        const pointer = readPointer(context.scope, includeSettled);
         if (status.status === 'error') {
-            return recoverFromPointer(status, pointer, context);
+            return recoverFromPointer(status, pointer, context, includeSettled);
         }
         const pending = pendingFromStatus(status.value.status);
         if (pending !== undefined) {
-            return resumeServerPending(pending, status.value.status.billing_rail, pointer, context);
+            return resumeServerPending(pending, status.value.status.billing_rail, pointer, context, includeSettled);
         }
         if (pointer === undefined)
             return { status: 'ok', value: undefined };
-        return probePointer(pointer, context);
+        return probePointer(pointer, context, includeSettled);
     }
     function wake() {
         for (const record of operations.values()) {

package/dist/core/billing/operationPointer.d.ts

@@ -22,16 +22,24 @@ declare const PointerSchema: z.ZodObject<{
     kind: z.ZodEnum<["subscription", "topup", "cancel"]>;
     presentation: z.ZodEnum<["embedded", "hosted"]>;
     attemptStartedAt: z.ZodNumber;
+    /** This tab issued the operation and has not yet seen it succeed. */
+    awaited: z.ZodOptional<z.ZodLiteral<true>>;
+    /** The end this tab saw it reach, kept only by a store that retains settled pointers. */
+    settled: z.ZodOptional<z.ZodEnum<["succeeded", "reconciliation_needed"]>>;
 }, "strip", z.ZodTypeAny, {
     kind: "cancel" | "subscription" | "topup";
     attemptStartedAt: number;
     presentation: "embedded" | "hosted";
     operationId: string;
+    awaited?: true | undefined;
+    settled?: "succeeded" | "reconciliation_needed" | undefined;
 }, {
     kind: "cancel" | "subscription" | "topup";
     attemptStartedAt: number;
     presentation: "embedded" | "hosted";
     operationId: string;
+    awaited?: true | undefined;
+    settled?: "succeeded" | "reconciliation_needed" | undefined;
 }>;
 export type BillingOperationPointer = z.infer<typeof PointerSchema>;
 export declare function operationPointerKey(scope: BillingScope): string;
@@ -40,9 +48,26 @@ export interface OperationPointerStore {
     write: (scope: BillingScope, pointer: BillingOperationPointer) => void;
     /** Clears only when the stored pointer names `operationId`, or unconditionally without one. */
     clear: (scope: BillingScope, operationId?: string) => void;
-    clearIfTerminal: (state: BillingOperationState) => void;
+    /**
+     * What the operation's phase does to the pointer naming it. A client-side
+     * timeout is this tab giving up, not the server finishing: an operation
+     * awaiting bank authentication stays pending for hours, so the pointer
+     * outlives it. A superseded operation belongs to a scope this tab left, and
+     * its pointer waits under that scope's key for a return. A failure clears
+     * it, so a reload offers a fresh attempt. A success, or an operation the
+     * server parked for reconciliation, clears it too, unless the store retains
+     * settled pointers.
+     */
+    settle: (state: BillingOperationState) => void;
 }
-export declare function createOperationPointerStore(storage: BillingOperationPointerStorage, now?: () => number): OperationPointerStore;
+export interface OperationPointerStoreOptions {
+    /**
+     * Keep a settled pointer, marked with how it ended, so a page that is the
+     * checkout itself can read it back after a reload.
+     */
+    readonly retainSettled?: boolean;
+}
+export declare function createOperationPointerStore(storage: BillingOperationPointerStorage, now?: () => number, { retainSettled }?: OperationPointerStoreOptions): OperationPointerStore;
 /** A store for hosts without tab-local storage: nothing is ever recovered. */
 export declare const NO_POINTER_STORE: OperationPointerStore;
 export {};

package/dist/core/billing/operationPointer.js

@@ -15,24 +15,12 @@ const PointerSchema = z.object({
     operationId: z.string().min(1),
     kind: z.enum(['subscription', 'topup', 'cancel']),
     presentation: z.enum(['embedded', 'hosted']),
-    attemptStartedAt: z.number().finite()
+    attemptStartedAt: z.number().finite(),
+    /** This tab issued the operation and has not yet seen it succeed. */
+    awaited: z.literal(true).optional(),
+    /** The end this tab saw it reach, kept only by a store that retains settled pointers. */
+    settled: z.enum(['succeeded', 'reconciliation_needed']).optional()
 });
-/**
- * A client-side timeout is this tab giving up, not the server finishing:
- * an operation awaiting bank authentication stays pending for hours, so the
- * pointer outlives it. A superseded operation belongs to a scope this tab
- * left, and its pointer waits under that scope's key for a return.
- * `reconciliation_needed` is terminal for polling, so retaining its pointer
- * would re-poll a settled operation on every reload.
- */
-const CLEARS_POINTER = {
-    pending: false,
-    timed_out: false,
-    superseded: false,
-    succeeded: true,
-    failed: true,
-    reconciliation_needed: true
-};
 export function operationPointerKey(scope) {
     return `${POINTER_KEY_PREFIX}:${scope.userId}:${scope.workspaceId}`;
 }
@@ -56,7 +44,14 @@ function decodePointer(raw, now) {
         ? parsed.data
         : undefined;
 }
-export function createOperationPointerStore(storage, now = Date.now) {
+/** A success is no longer awaited; an operation still being reconciled is. */
+function settledPointer(pointer, phase) {
+    if (phase === 'reconciliation_needed')
+        return { ...pointer, settled: phase };
+    const { awaited: _seen, ...rest } = pointer;
+    return { ...rest, settled: phase };
+}
+export function createOperationPointerStore(storage, now = Date.now, { retainSettled = false } = {}) {
     const read = (scope) => {
         const key = operationPointerKey(scope);
         const pointer = decodePointer(attempt(() => storage.getItem(key), null), now());
@@ -64,26 +59,42 @@ export function createOperationPointerStore(storage, now = Date.now) {
             attempt(() => storage.removeItem(key), undefined);
         return pointer;
     };
+    const write = (scope, pointer) => attempt(() => storage.setItem(operationPointerKey(scope), JSON.stringify(pointer)), undefined);
     const clear = (scope, operationId) => {
         if (operationId !== undefined && read(scope)?.operationId !== operationId) {
             return;
         }
         attempt(() => storage.removeItem(operationPointerKey(scope)), undefined);
     };
-    return {
-        read,
-        write: (scope, pointer) => attempt(() => storage.setItem(operationPointerKey(scope), JSON.stringify(pointer)), undefined),
-        clear,
-        clearIfTerminal: (state) => {
-            if (CLEARS_POINTER[state.phase])
+    const retain = (state, phase) => {
+        const pointer = read(state.scope);
+        if (pointer?.operationId !== state.id)
+            return;
+        write(state.scope, settledPointer(pointer, phase));
+    };
+    const settle = (state) => {
+        switch (state.phase) {
+            case 'pending':
+            case 'timed_out':
+            case 'superseded':
+                return;
+            case 'failed':
                 clear(state.scope, state.id);
+                return;
+            case 'succeeded':
+            case 'reconciliation_needed':
+                if (retainSettled)
+                    retain(state, state.phase);
+                else
+                    clear(state.scope, state.id);
         }
     };
+    return { read, write, clear, settle };
 }
 /** A store for hosts without tab-local storage: nothing is ever recovered. */
 export const NO_POINTER_STORE = {
     read: () => undefined,
     write: () => { },
     clear: () => { },
-    clearIfTerminal: () => { }
+    settle: () => { }
 };

package/dist/core/billing/operationPolicy.d.ts

@@ -1,10 +1,12 @@
-import type { PendingBillingOperation } from './operationState.js';
+import type { BillingAuthenticationState, EmbeddedChallenge, PendingBillingOperation } from './operationState.js';
 export declare const OPERATION_POLL_TIMING: {
     readonly initialMs: 1000;
     readonly maxMs: 8000;
     readonly multiplier: 1.5;
     /** An operation parked on the customer is checked on a slow, flat cadence. */
     readonly parkedMs: 30000;
+    /** Fast backoff for an actionless blocked wait: 20 turns of the 3 s PI status cache. */
+    readonly actionDiscoveryMs: 60000;
 };
 export declare const OPERATION_POLL_BUDGET: {
     readonly defaultMs: 120000;
@@ -14,13 +16,48 @@ export declare const OPERATION_POLL_BUDGET: {
     readonly customerActionMs: number;
 };
 /**
- * Waiting on the customer, not on the backend: a challenge to complete
- * elsewhere, a hosted page to finish, a phase the server reports as blocked on
- * them, or a declined attempt awaiting their retry. Once this tab's own
- * challenge completes the state reads processing and nothing waits on the
- * customer anymore.
+ * What one tab holds for the customer on a pending operation. Each rail
+ * builds it from its own state, because each renders a different surface:
+ * the legacy cloud store offers the hosted link beside the embedded
+ * challenge, while the SDK renders exactly one presentation.
+ */
+export interface CustomerActionHold {
+    readonly authenticationState?: BillingAuthenticationState | null;
+    /** A hosted page this tab would open for the customer. */
+    readonly offersHostedPage: boolean;
+    /** The embedded challenge this tab holds, whatever became of it. */
+    readonly challenge?: EmbeddedChallenge['status'];
+}
+/**
+ * The one "customer can act here" rule both billing rails park on: a
+ * retryable failure to retry, a hosted page to visit, or an embedded
+ * challenge the server still says is required. A non-retryable decline never
+ * reaches it; the operation is terminal by then.
+ */
+export declare function customerCanActHere(hold: CustomerActionHold): boolean;
+/**
+ * The SDK renders one presentation: a hosted operation offers only its page,
+ * an embedded one only its challenge. The cloud app's
+ * `legacyOperationActionHold` names the rows where the two surfaces differ.
+ */
+export declare function pendingOperationActionHold(state: PendingBillingOperation): CustomerActionHold;
+/**
+ * Parked only while the customer can act here. The server can report a
+ * blocked phase and a client secret before its cached `authentication_state`
+ * catches up, and the slow cadence would then hold a screen with no action.
  */
 export declare function isParkedOnCustomer(state: PendingBillingOperation): boolean;
-export declare function nextPollDelayMs(state: PendingBillingOperation, previousDelayMs: number | undefined): number;
+/**
+ * Blocked on the customer with nothing to offer them yet: either the action
+ * is still on its way, or it belongs to someone else (a member without
+ * billing permission, a tab without embedded checkout).
+ */
+export declare function isWaitingOnCustomerWithoutAction(state: PendingBillingOperation): boolean;
+/**
+ * `waitedWithoutActionMs` is how long the operation has continuously been
+ * {@link isWaitingOnCustomerWithoutAction}; past the discovery window it
+ * parks too, so an action that never arrives here costs the slow cadence.
+ */
+export declare function nextPollDelayMs(state: PendingBillingOperation, previousDelayMs: number | undefined, waitedWithoutActionMs?: number): number;
 export declare function pollBudgetMs(state: PendingBillingOperation): number;
 export declare function hasExhaustedPollBudget(state: PendingBillingOperation, now: number): boolean;