@fantastic.dev/better-stripe 0.28.6 → 0.29.0

package/CHANGELOG.md

@@ -26,6 +26,12 @@
 - Remove internal tracker references from public documentation and add a
   regression check that prevents their reintroduction.
 
+## [0.29.0](https://github.com/FantasticDevHQ/better-stripe/compare/v0.28.6...v0.29.0) (2026-10-15)
+
+### Features
+
+- **payouts:** bind complete history and version recovery liabilities ([#222](https://github.com/FantasticDevHQ/better-stripe/issues/222)) ([65ee1e0](https://github.com/FantasticDevHQ/better-stripe/commit/65ee1e034309d687df9eb989d97437b87f607537))
+
 ## [0.28.6](https://github.com/FantasticDevHQ/better-stripe/compare/v0.28.5...v0.28.6) (2026-10-15)
 
 ### Bug Fixes

package/MIGRATION.md

@@ -198,3 +198,9 @@ A cancellation timestamp at another date is not classified as period-end cancell
 See the [read contract guide](docs/read-contracts.md) for reactive product, price and payout
 cursors, exact currency summaries, legacy backfill, payout failure details, and
 published-version adoption requirements.
+
+## Versioned payout recovery quotes
+
+Hosts with component recovery balance records must now pass `stripe.costRecovery.payoutQuote(ctx, authorizedScope)` into payout preview/release/worker options. Pass the returned `independentLiabilities` and `liabilityRevision` together for the same authorized account/currency/scope. Calls without a required version fail safely; accounts without recovery records retain the unversioned path. The example adapters are updated. Additional host-owned liabilities still require host authorization and consistency guards; the component version does not cover external databases.
+
+Do not backfill old attempted claims with guessed quotes. Reconcile their existing request, or replay an unattempted operation to cancel its exact reservations, then use a new operation and fresh quote. Obsolete read-only collection fingerprints can be discarded and recollected; financially bound or unresolved claim state must remain intact.

package/README.md

@@ -70,7 +70,7 @@ claim execution are completed.
 
 ## Status
 
-**Version**: `0.28.6` <!-- x-release-please-version --> (pre-1.0). API may change between minor versions until 1.0.
+**Version**: `0.29.0` <!-- x-release-please-version --> (pre-1.0). API may change between minor versions until 1.0.
 
 Used in production by its authors. Webhook pipeline is covered by unit tests and a live E2E harness (`npm run e2e:webhooks`) that fires real Stripe-signed events and asserts the ledger.
 
@@ -1742,3 +1742,7 @@ Holding-expiry recovery remains visible and retryable after schedule restoration
 Automatic payout status is reusable through `payoutAttemptStatus`, `payoutAttemptValidator`, and the React `PayoutAttemptStatus` workflow. Rejection reasons and retry times remain separate from eligibility previews and bank arrival dates. See [React workflow guidance](docs/react-workflows.md).
 
 Payout qualification renews source verification for the selected currency only after a complete matching provider-history check. Slower receipt scans retain the same freshness and local reservation safeguards; partial or changed history stays held. See [settlement guidance](docs/settlement.md).
+
+Automatic combined payouts use a complete paginated ledger collection above 100 historical sources or claims. The collection is checked and bound to the immutable claim before Stripe is contacted; incomplete scans resume without authorizing money. See [settlement guidance](docs/settlement.md#resumable-local-collections).
+
+Resolve recovery-backed payout liabilities with `stripe.costRecovery.payoutQuote(ctx, authorizedScope)` and pass its amount/version together to preview or automatic release. The example does this for seller refund/dispute costs; stale or missing required versions fail safely. See [versioned liability guidance](docs/settlement.md#versioned-recovery-liabilities).

package/dist/client/connect/payoutAdoptionTestHelpers.d.ts

@@ -59,13 +59,13 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
         payoutRiskEvents: import("convex/server").TableDefinition<import("convex/values").VObject<{
             accountId: string;
             key: string;
-            kind: "allocation" | "claim" | "fee" | "provider_payout" | "transfer";
+            kind: "allocation" | "claim" | "fee" | "liability" | "provider_payout" | "transfer";
             removed?: boolean | undefined;
             riskRevision: number;
         }, {
             accountId: import("convex/values").VString<string, "required">;
             riskRevision: import("convex/values").VFloat64<number, "required">;
-            kind: import("convex/values").VUnion<"allocation" | "claim" | "fee" | "provider_payout" | "transfer", [import("convex/values").VLiteral<"transfer", "required">, import("convex/values").VLiteral<"provider_payout", "required">, import("convex/values").VLiteral<"allocation", "required">, import("convex/values").VLiteral<"claim", "required">, import("convex/values").VLiteral<"fee", "required">], "required", never>;
+            kind: import("convex/values").VUnion<"allocation" | "claim" | "fee" | "liability" | "provider_payout" | "transfer", [import("convex/values").VLiteral<"transfer", "required">, import("convex/values").VLiteral<"provider_payout", "required">, import("convex/values").VLiteral<"allocation", "required">, import("convex/values").VLiteral<"claim", "required">, import("convex/values").VLiteral<"fee", "required">, import("convex/values").VLiteral<"liability", "required">], "required", never>;
             key: import("convex/values").VString<string, "required">;
             removed: import("convex/values").VBoolean<boolean | undefined, "optional">;
         }, "required", "accountId" | "key" | "kind" | "removed" | "riskRevision">, {
@@ -84,6 +84,8 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
             accountId: string;
             allocationCount: number;
             allocationCursor?: string | undefined;
+            boundOperationKey?: string | undefined;
+            boundRiskRevision?: number | undefined;
             claimCount: number;
             claimCursor?: string | undefined;
             deferredPositiveChanges: boolean;
@@ -109,6 +111,8 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
             step: number;
         }, {
             readOnly: import("convex/values").VBoolean<boolean, "required">;
+            boundOperationKey: import("convex/values").VString<string | undefined, "optional">;
+            boundRiskRevision: import("convex/values").VFloat64<number | undefined, "optional">;
             accountId: import("convex/values").VString<string, "required">;
             ownerKey: import("convex/values").VString<string, "required">;
             operationKey: import("convex/values").VString<string, "required">;
@@ -134,7 +138,7 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
             providerChanged: import("convex/values").VBoolean<boolean, "required">;
             expiresAt: import("convex/values").VFloat64<number, "required">;
             reason: import("convex/values").VString<string | undefined, "optional">;
-        }, "required", "accountId" | "allocationCount" | "allocationCursor" | "claimCount" | "claimCursor" | "deferredPositiveChanges" | "expectedRevision" | "expiresAt" | "feeCount" | "feeCursor" | "initialRevision" | "initialRiskRevision" | "observedRevision" | "operationKey" | "ownerKey" | "phase" | "policyMode" | "policyOperationKey" | "providerChanged" | "readOnly" | "reason" | "riskRevision" | "sourceCount" | "sourceCursor" | "sourceFence" | "step">, {
+        }, "required", "accountId" | "allocationCount" | "allocationCursor" | "boundOperationKey" | "boundRiskRevision" | "claimCount" | "claimCursor" | "deferredPositiveChanges" | "expectedRevision" | "expiresAt" | "feeCount" | "feeCursor" | "initialRevision" | "initialRiskRevision" | "observedRevision" | "operationKey" | "ownerKey" | "phase" | "policyMode" | "policyOperationKey" | "providerChanged" | "readOnly" | "reason" | "riskRevision" | "sourceCount" | "sourceCursor" | "sourceFence" | "step">, {
             by_account_phase: ["accountId", "phase", "_creationTime"];
             by_operation: ["operationKey", "_creationTime"];
             by_read_only: ["readOnly", "_creationTime"];
@@ -508,6 +512,8 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
             expectedRevision: number;
             feeRevision?: number | undefined;
             historical?: boolean | undefined;
+            independentLiabilities?: number | undefined;
+            liabilityRevision?: number | undefined;
             observations: {
                 currency: string;
                 ledgerFingerprint: string;
@@ -525,12 +531,16 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
                 requestId: string;
             } | undefined;
             returnTransactionId?: string | undefined;
+            snapshotId?: import("convex/values").GenericId<"payoutSnapshots"> | undefined;
             status: "canceled" | "paid" | "rejected" | "reserved" | "returned" | "submitted";
             stripePayoutId?: string | undefined;
         }, {
             accountId: import("convex/values").VString<string, "required">;
             ownerKey: import("convex/values").VString<string, "required">;
             historical: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            snapshotId: import("convex/values").VId<import("convex/values").GenericId<"payoutSnapshots"> | undefined, "optional">;
+            liabilityRevision: import("convex/values").VFloat64<number | undefined, "optional">;
+            independentLiabilities: import("convex/values").VFloat64<number | undefined, "optional">;
             operationKey: import("convex/values").VString<string, "required">;
             expectedRevision: import("convex/values").VFloat64<number, "required">;
             currency: import("convex/values").VString<string, "required">;
@@ -589,7 +599,7 @@ export declare function setup(amounts?: number[], currency?: string): Promise<{
                 requestId: import("convex/values").VString<string, "required">;
                 code: import("convex/values").VUnion<"amount_too_small" | "balance_insufficient", [import("convex/values").VLiteral<"balance_insufficient", "required">, import("convex/values").VLiteral<"amount_too_small", "required">], "required", never>;
             }, "optional", "code" | "requestId">;
-        }, "required", "accountId" | "allocations" | "amount" | "attemptedAt" | "currency" | "debitFee" | "debitTransactionId" | "destinationId" | "expectedRevision" | "feeRevision" | "historical" | "observations" | "operationKey" | "ownerKey" | "providerFee" | "rejection" | "rejection.code" | "rejection.requestId" | "returnTransactionId" | "status" | "stripePayoutId">, {
+        }, "required", "accountId" | "allocations" | "amount" | "attemptedAt" | "currency" | "debitFee" | "debitTransactionId" | "destinationId" | "expectedRevision" | "feeRevision" | "historical" | "independentLiabilities" | "liabilityRevision" | "observations" | "operationKey" | "ownerKey" | "providerFee" | "rejection" | "rejection.code" | "rejection.requestId" | "returnTransactionId" | "snapshotId" | "status" | "stripePayoutId">, {
             by_account_status: ["accountId", "status", "_creationTime"];
             by_debit_receipt: ["debitTransactionId", "_creationTime"];
             by_operation: ["operationKey", "_creationTime"];
@@ -1903,13 +1913,13 @@ export declare function historical(currency?: string): Promise<{
         payoutRiskEvents: import("convex/server").TableDefinition<import("convex/values").VObject<{
             accountId: string;
             key: string;
-            kind: "allocation" | "claim" | "fee" | "provider_payout" | "transfer";
+            kind: "allocation" | "claim" | "fee" | "liability" | "provider_payout" | "transfer";
             removed?: boolean | undefined;
             riskRevision: number;
         }, {
             accountId: import("convex/values").VString<string, "required">;
             riskRevision: import("convex/values").VFloat64<number, "required">;
-            kind: import("convex/values").VUnion<"allocation" | "claim" | "fee" | "provider_payout" | "transfer", [import("convex/values").VLiteral<"transfer", "required">, import("convex/values").VLiteral<"provider_payout", "required">, import("convex/values").VLiteral<"allocation", "required">, import("convex/values").VLiteral<"claim", "required">, import("convex/values").VLiteral<"fee", "required">], "required", never>;
+            kind: import("convex/values").VUnion<"allocation" | "claim" | "fee" | "liability" | "provider_payout" | "transfer", [import("convex/values").VLiteral<"transfer", "required">, import("convex/values").VLiteral<"provider_payout", "required">, import("convex/values").VLiteral<"allocation", "required">, import("convex/values").VLiteral<"claim", "required">, import("convex/values").VLiteral<"fee", "required">, import("convex/values").VLiteral<"liability", "required">], "required", never>;
             key: import("convex/values").VString<string, "required">;
             removed: import("convex/values").VBoolean<boolean | undefined, "optional">;
         }, "required", "accountId" | "key" | "kind" | "removed" | "riskRevision">, {
@@ -1928,6 +1938,8 @@ export declare function historical(currency?: string): Promise<{
             accountId: string;
             allocationCount: number;
             allocationCursor?: string | undefined;
+            boundOperationKey?: string | undefined;
+            boundRiskRevision?: number | undefined;
             claimCount: number;
             claimCursor?: string | undefined;
             deferredPositiveChanges: boolean;
@@ -1953,6 +1965,8 @@ export declare function historical(currency?: string): Promise<{
             step: number;
         }, {
             readOnly: import("convex/values").VBoolean<boolean, "required">;
+            boundOperationKey: import("convex/values").VString<string | undefined, "optional">;
+            boundRiskRevision: import("convex/values").VFloat64<number | undefined, "optional">;
             accountId: import("convex/values").VString<string, "required">;
             ownerKey: import("convex/values").VString<string, "required">;
             operationKey: import("convex/values").VString<string, "required">;
@@ -1978,7 +1992,7 @@ export declare function historical(currency?: string): Promise<{
             providerChanged: import("convex/values").VBoolean<boolean, "required">;
             expiresAt: import("convex/values").VFloat64<number, "required">;
             reason: import("convex/values").VString<string | undefined, "optional">;
-        }, "required", "accountId" | "allocationCount" | "allocationCursor" | "claimCount" | "claimCursor" | "deferredPositiveChanges" | "expectedRevision" | "expiresAt" | "feeCount" | "feeCursor" | "initialRevision" | "initialRiskRevision" | "observedRevision" | "operationKey" | "ownerKey" | "phase" | "policyMode" | "policyOperationKey" | "providerChanged" | "readOnly" | "reason" | "riskRevision" | "sourceCount" | "sourceCursor" | "sourceFence" | "step">, {
+        }, "required", "accountId" | "allocationCount" | "allocationCursor" | "boundOperationKey" | "boundRiskRevision" | "claimCount" | "claimCursor" | "deferredPositiveChanges" | "expectedRevision" | "expiresAt" | "feeCount" | "feeCursor" | "initialRevision" | "initialRiskRevision" | "observedRevision" | "operationKey" | "ownerKey" | "phase" | "policyMode" | "policyOperationKey" | "providerChanged" | "readOnly" | "reason" | "riskRevision" | "sourceCount" | "sourceCursor" | "sourceFence" | "step">, {
             by_account_phase: ["accountId", "phase", "_creationTime"];
             by_operation: ["operationKey", "_creationTime"];
             by_read_only: ["readOnly", "_creationTime"];
@@ -2352,6 +2366,8 @@ export declare function historical(currency?: string): Promise<{
             expectedRevision: number;
             feeRevision?: number | undefined;
             historical?: boolean | undefined;
+            independentLiabilities?: number | undefined;
+            liabilityRevision?: number | undefined;
             observations: {
                 currency: string;
                 ledgerFingerprint: string;
@@ -2369,12 +2385,16 @@ export declare function historical(currency?: string): Promise<{
                 requestId: string;
             } | undefined;
             returnTransactionId?: string | undefined;
+            snapshotId?: import("convex/values").GenericId<"payoutSnapshots"> | undefined;
             status: "canceled" | "paid" | "rejected" | "reserved" | "returned" | "submitted";
             stripePayoutId?: string | undefined;
         }, {
             accountId: import("convex/values").VString<string, "required">;
             ownerKey: import("convex/values").VString<string, "required">;
             historical: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            snapshotId: import("convex/values").VId<import("convex/values").GenericId<"payoutSnapshots"> | undefined, "optional">;
+            liabilityRevision: import("convex/values").VFloat64<number | undefined, "optional">;
+            independentLiabilities: import("convex/values").VFloat64<number | undefined, "optional">;
             operationKey: import("convex/values").VString<string, "required">;
             expectedRevision: import("convex/values").VFloat64<number, "required">;
             currency: import("convex/values").VString<string, "required">;
@@ -2433,7 +2453,7 @@ export declare function historical(currency?: string): Promise<{
                 requestId: import("convex/values").VString<string, "required">;
                 code: import("convex/values").VUnion<"amount_too_small" | "balance_insufficient", [import("convex/values").VLiteral<"balance_insufficient", "required">, import("convex/values").VLiteral<"amount_too_small", "required">], "required", never>;
             }, "optional", "code" | "requestId">;
-        }, "required", "accountId" | "allocations" | "amount" | "attemptedAt" | "currency" | "debitFee" | "debitTransactionId" | "destinationId" | "expectedRevision" | "feeRevision" | "historical" | "observations" | "operationKey" | "ownerKey" | "providerFee" | "rejection" | "rejection.code" | "rejection.requestId" | "returnTransactionId" | "status" | "stripePayoutId">, {
+        }, "required", "accountId" | "allocations" | "amount" | "attemptedAt" | "currency" | "debitFee" | "debitTransactionId" | "destinationId" | "expectedRevision" | "feeRevision" | "historical" | "independentLiabilities" | "liabilityRevision" | "observations" | "operationKey" | "ownerKey" | "providerFee" | "rejection" | "rejection.code" | "rejection.requestId" | "returnTransactionId" | "snapshotId" | "status" | "stripePayoutId">, {
             by_account_status: ["accountId", "status", "_creationTime"];
             by_debit_receipt: ["debitTransactionId", "_creationTime"];
             by_operation: ["operationKey", "_creationTime"];

package/dist/client/connect/payoutAdoptionTestHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payoutAdoptionTestHelpers.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutAdoptionTestHelpers.ts"],"names":[],"mappings":"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ACD,wBAAsB,UAAU,CAAC,QAAQ,SAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YArJ3C,oBAAoB;;;;;;;;;;;YAapB,QAAQ,6BAAmB,MAAM;;;;;;;;;YAYjC,aAAa;;;;;;YAGb,QAAQ,6BAAmB,MAAM;;;;;;;;;;;YAcjC,IAAI,iCAAuB;gBAAE,MAAM,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,CAAC,EAAE,MAAM,CAAA;aAAE;;;;;;;;;;;;;;;;YAM9D,QAAQ,6BAAmB,MAAM;;;;;;;;;;;;;;;YAKjC,QAAQ;;;;;wBAQA,IAAI;;;;;;;YAUZ,IAAI;;;;YAIJ,QAAQ,8BAAoB,MAAM;YAGlC,MAAM,iCACW;gBACb,MAAM,EAAE,MAAM,CAAC;gBACf,QAAQ,EAAE,MAAM,CAAC;gBACjB,QAAQ,EAAE,MAAM,CAAC;aAClB;;;;gBA2CG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDrB"}
+{"version":3,"file":"payoutAdoptionTestHelpers.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutAdoptionTestHelpers.ts"],"names":[],"mappings":"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;;GAsBrB;AACD,wBAAsB,UAAU,CAAC,QAAQ,SAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YArJ3C,oBAAoB;;;;;;;;;;;YAapB,QAAQ,6BAAmB,MAAM;;;;;;;;;YAYjC,aAAa;;;;;;YAGb,QAAQ,6BAAmB,MAAM;;;;;;;;;;;YAcjC,IAAI,iCAAuB;gBAAE,MAAM,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,CAAC,EAAE,MAAM,CAAA;aAAE;;;;;;;;;;;;;;;;YAM9D,QAAQ,6BAAmB,MAAM;;;;;;;;;;;;;;;YAKjC,QAAQ;;;;;wBAQA,IAAI;;;;;;;YAUZ,IAAI;;;;YAIJ,QAAQ,8BAAoB,MAAM;YAGlC,MAAM,iCACW;gBACb,MAAM,EAAE,MAAM,CAAC;gBACf,QAAQ,EAAE,MAAM,CAAC;gBACjB,QAAQ,EAAE,MAAM,CAAC;aAClB;;;;gBA2CG,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDrB"}

package/dist/client/connect/payoutCollectedInput.d.ts

@@ -0,0 +1,110 @@
+import type { Infer } from "convex/values";
+import type { Component, RunCtx } from "../helpers.js";
+import type { snapshotDoc } from "../../component/payoutSnapshots/schema.js";
+import type { transferDocValidator } from "../../component/connect/validators.js";
+import type { claimDoc } from "../../component/payoutRelease/schema.js";
+export type CollectionRef = {
+    accountId: string;
+    ownerKey: string;
+    operationKey: string;
+    snapshotId: Infer<typeof snapshotDoc>["_id"];
+};
+export type PayoutInput = {
+    status: "ready";
+    transfers: Infer<typeof transferDocValidator>[];
+    claims: Infer<typeof claimDoc>[];
+};
+export declare function collectLargePayoutInput(component: Component, ctx: RunCtx, opts: {
+    accountId: string;
+    ownerKey: string;
+    operationKey?: string;
+}, maxPages: number): Promise<{
+    status: "held";
+    reason: string;
+    transfers?: undefined;
+    claims?: undefined;
+    collection?: undefined;
+} | {
+    status: "held";
+    reason: string;
+    collection: {
+        accountId: string;
+        ownerKey: string;
+        operationKey: string;
+        snapshotId: import("convex/values").GenericId<"payoutSnapshots">;
+    };
+    transfers?: undefined;
+    claims?: undefined;
+} | {
+    reason?: undefined;
+    status: "ready";
+    transfers: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"transfers">;
+        amount: number;
+        currency: string;
+        destinationAccountId: string;
+        metadata?: any;
+        paymentId?: string | undefined;
+        reinstatement?: boolean | undefined;
+        reversalClaimedAmount?: number | undefined;
+        reversalStatus?: "fully_reversed" | "partially_reversed" | undefined;
+        reversedAmount?: number | undefined;
+        role?: "affiliate" | "other" | "store" | undefined;
+        sourceChargeId?: string | undefined;
+        sourceInvoiceId?: string | undefined;
+        status: "failed" | "paid" | "pending" | "reversed";
+        stripeTransferId: string;
+        totalsRecorded?: true | undefined;
+    }[];
+    claims: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"payoutReleaseClaims">;
+        accountId: string;
+        allocations: {
+            amount: number;
+            role?: "affiliate" | "other" | "store" | undefined;
+            stripeTransferId: string;
+        }[];
+        amount: number;
+        attemptedAt?: number | undefined;
+        currency: string;
+        debitFee?: number | undefined;
+        debitTransactionId?: string | undefined;
+        destinationId?: string | undefined;
+        expectedRevision: number;
+        feeRevision?: number | undefined;
+        historical?: boolean | undefined;
+        independentLiabilities?: number | undefined;
+        liabilityRevision?: number | undefined;
+        observations: {
+            currency: string;
+            ledgerFingerprint: string;
+            matureNet: number;
+            observedAt: number;
+            pendingCredits: number;
+            stripeTransferId: string;
+            transactionIds: string[];
+        }[];
+        operationKey: string;
+        ownerKey: string;
+        providerFee?: number | undefined;
+        rejection?: {
+            code: "amount_too_small" | "balance_insufficient";
+            requestId: string;
+        } | undefined;
+        returnTransactionId?: string | undefined;
+        snapshotId?: import("convex/values").GenericId<"payoutSnapshots"> | undefined;
+        status: "canceled" | "paid" | "rejected" | "reserved" | "returned" | "submitted";
+        stripePayoutId?: string | undefined;
+    }[];
+    collection: {
+        accountId: string;
+        ownerKey: string;
+        operationKey: string;
+        snapshotId: import("convex/values").GenericId<"payoutSnapshots">;
+    };
+}>;
+/** Bound unattempted claims retain their cache. Attempted/terminal claims keep their own immutable financial proof. */
+export declare function discardQualificationInput(component: Component, ctx: RunCtx, collection?: CollectionRef, keep?: boolean): Promise<void>;
+//# sourceMappingURL=payoutCollectedInput.d.ts.map

package/dist/client/connect/payoutCollectedInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payoutCollectedInput.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutCollectedInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAMxE,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC;CAC9C,CAAC;AACF,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,KAAK,CAAC,OAAO,oBAAoB,CAAC,EAAE,CAAC;IAChD,MAAM,EAAE,KAAK,CAAC,OAAO,QAAQ,CAAC,EAAE,CAAC;CAClC,CAAC;AACF,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,EACpE,QAAQ,EAAE,MAAM;YAGG,MAAM;;;;;;YA2Bb,MAAM;;;;;;;;;;;;YAiCR,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQlB;AACD,uHAAuH;AACvH,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,UAAU,CAAC,EAAE,aAAa,EAC1B,IAAI,UAAQ,iBAiBb"}

package/dist/client/connect/payoutCollectedInput.js

@@ -0,0 +1,70 @@
+import { componentRef } from "../webhooks/helpers.js";
+import { collectPayoutSnapshot, discardPayoutSnapshot, } from "./payoutCollection.js";
+export async function collectLargePayoutInput(component, ctx, opts, maxPages) {
+    if (!ctx.runMutation)
+        return { status: "held", reason: "collection_requires_action" };
+    const policy = (await ctx.runQuery(componentRef(component, "payoutPolicy/queries/get"), { accountId: opts.accountId, ownerKey: opts.ownerKey }));
+    const scope = {
+        accountId: opts.accountId,
+        ownerKey: opts.ownerKey,
+        operationKey: opts.operationKey ?? crypto.randomUUID(),
+    };
+    let h = await collectPayoutSnapshot(component, ctx, {
+        ...scope,
+        expectedRevision: policy?.revision ?? -1,
+    });
+    for (let i = 0; i < maxPages * 25 && h.phase !== "local_ready" && h.phase !== "invalidated"; i++)
+        h = await collectPayoutSnapshot(component, ctx, {
+            ...scope,
+            expectedRevision: h.expectedRevision,
+            expectedStep: h.step,
+        });
+    const collection = { ...scope, snapshotId: h._id };
+    if (h.phase !== "local_ready")
+        return {
+            status: "held",
+            reason: h.phase === "invalidated"
+                ? "collection_invalidated"
+                : "collection_pending",
+            collection,
+        };
+    async function pages(kind, count) {
+        const rows = [];
+        let cursor = null;
+        for (let i = 0; i <= Math.ceil(count / 25); i++) {
+            const page = (await ctx.runQuery(componentRef(component, `payoutSnapshots/queries/${kind}`), { ...scope, paginationOpts: { cursor, numItems: 25 } }));
+            rows.push(...page.page);
+            if (page.isDone) {
+                if (rows.length !== count)
+                    throw new Error("Collected payout membership changed.");
+                return rows;
+            }
+            if (!page.continueCursor || page.continueCursor === cursor)
+                throw new Error("Collected payout cursor did not advance.");
+            cursor = page.continueCursor;
+        }
+        throw new Error("Collected payout page budget exhausted; preserve collection for retry.");
+    }
+    return {
+        status: "ready",
+        transfers: await pages("sources", h.sourceCount),
+        claims: await pages("claims", h.claimCount),
+        collection,
+    };
+}
+/** Bound unattempted claims retain their cache. Attempted/terminal claims keep their own immutable financial proof. */
+export async function discardQualificationInput(component, ctx, collection, keep = false) {
+    if (!collection || keep || !ctx.runMutation)
+        return;
+    const { snapshotId: _, ...scope } = collection;
+    const h = (await ctx.runQuery(componentRef(component, "payoutSnapshots/queries/get"), scope));
+    if (!h?.readOnly)
+        return;
+    for (let i = 0; i < 1000; i++)
+        if (!(await discardPayoutSnapshot(component, ctx, {
+            ...scope,
+            batchSize: 100,
+        })))
+            return;
+}
+//# sourceMappingURL=payoutCollectedInput.js.map

package/dist/client/connect/payoutCollectedInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payoutCollectedInput.js","sourceRoot":"","sources":["../../../src/client/connect/payoutCollectedInput.ts"],"names":[],"mappings":"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"}

package/dist/client/connect/payoutExecution.d.ts

@@ -11,6 +11,7 @@ export type PayoutReleaseOptions = {
     currency: string;
     /** Host supplies all authorized off-provider debts/reserves, without double counting provider receipt debits. */
     independentLiabilities: number;
+    liabilityRevision?: number;
     maxPages?: number;
 };
 type Held = {

package/dist/client/connect/payoutExecution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payoutExecution.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutExecution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAGxE,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAEnC,KAAK,MAAM,GAAG,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACtC,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,iHAAiH;IACjH,sBAAsB,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,KAAK,IAAI,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAC/C,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG,IAAI,CAAC;AAC9D;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,MAAM,OAAO,CACnB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAC5D,GACA,OAAO,CAAC,mBAAmB,CAAC,CAyI9B"}
+{"version":3,"file":"payoutExecution.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutExecution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAGxE,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAEnC,KAAK,MAAM,GAAG,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACtC,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,iHAAiH;IACjH,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,KAAK,IAAI,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAC/C,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,GAAG,IAAI,CAAC;AAC9D;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,oBAAoB,EAC1B,MAAM,EAAE,MAAM,OAAO,CACnB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAC5D,GACA,OAAO,CAAC,mBAAmB,CAAC,CAuK9B"}

package/dist/client/connect/payoutExecution.js

@@ -1,3 +1,4 @@
+import { discardQualificationInput } from "./payoutCollectedInput.js";
 import { runMutationOrThrow } from "../helpers.js";
 import { componentRef } from "../webhooks/helpers.js";
 import { validateIdentity } from "../../component/payoutRelease/helpers.js";
@@ -29,86 +30,112 @@ export async function releaseRecipientPayout(stripe, component, ctx, opts, verif
     if (existing) {
         if (existing.currency !== opts.currency)
             throw new Error("Payout claim currency cannot be changed.");
-        if (existing.attemptedAt !== undefined || existing.status !== "reserved")
-            return reconcileRecipientPayout(stripe, component, ctx, {
-                ...identity,
-                maxPages,
-            });
+        if (existing.attemptedAt !== undefined || existing.status !== "reserved") {
+            try {
+                return await reconcileRecipientPayout(stripe, component, ctx, {
+                    ...identity,
+                    maxPages,
+                });
+            }
+            finally {
+                if (existing.snapshotId)
+                    await discardQualificationInput(component, ctx, {
+                        ...identity,
+                        snapshotId: existing.snapshotId,
+                    });
+            }
+        }
         // A crash before the attempt has no provider side effect. Release its exact
         // reservations; the next scheduled operation must collect fresh receipts.
         const claim = (await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/cancelUnattempted"), identity));
+        if (existing.snapshotId)
+            await discardQualificationInput(component, ctx, {
+                ...identity,
+                snapshotId: existing.snapshotId,
+            });
         return { status: "terminal", claim };
     }
     const controls = await verify();
     if (controls.status !== "verified" || !("policy" in controls))
         return { status: "held", reason: controls.status };
     const proof = await collectPayoutQualification(stripe, component, ctx, opts, maxPages);
-    if (proof.status !== "verified")
-        return proof;
-    const claim = (await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/claim"), {
-        ...identity,
-        expectedRevision: controls.policy.revision,
-        currency: opts.currency,
-        destinationId: proof.destinationId,
-        providerAvailable: proof.providerAvailable,
-        independentLiabilities: opts.independentLiabilities,
-        observations: proof.observations,
-    }));
-    if (claim.status === "held")
-        return claim;
-    // Another caller can win this operation while receipts were being collected.
-    if (claim.attemptedAt !== undefined || claim.status !== "reserved")
-        return reconcileRecipientPayout(stripe, component, ctx, {
+    try {
+        if (proof.status !== "verified")
+            return { status: "held", reason: proof.reason };
+        const claim = (await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/claim"), {
+            ...identity,
+            expectedRevision: controls.policy.revision,
+            currency: opts.currency,
+            destinationId: proof.destinationId,
+            providerAvailable: proof.providerAvailable,
+            independentLiabilities: opts.independentLiabilities,
+            observations: proof.observations,
+            ...(opts.liabilityRevision === undefined
+                ? {}
+                : { liabilityRevision: opts.liabilityRevision }),
+            ...(proof.collection
+                ? { snapshotId: proof.collection.snapshotId }
+                : {}),
+        }));
+        if (claim.status === "held")
+            return claim;
+        // Another caller can win this operation while receipts were being collected.
+        if (claim.attemptedAt !== undefined || claim.status !== "reserved")
+            return reconcileRecipientPayout(stripe, component, ctx, {
+                ...identity,
+                maxPages,
+            });
+        const latest = await verify();
+        if (latest.status !== "verified" ||
+            !("policy" in latest) ||
+            latest.policy.revision !== controls.policy.revision) {
+            await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/cancelUnattempted"), identity);
+            return {
+                status: "held",
+                reason: latest.status === "verified" ? "policy_changed" : latest.status,
+            };
+        }
+        await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/beginAttempt"), identity);
+        let payout;
+        try {
+            payout = await stripe.payouts.create({
+                amount: claim.amount,
+                currency: claim.currency,
+                destination: claim.destinationId,
+                method: "standard",
+                source_type: "card",
+                metadata: { bsPayoutClaim: claim.operationKey },
+            }, {
+                stripeAccount: claim.accountId,
+                idempotencyKey: `bs:payout-release:${claim.operationKey}`,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "type" in error &&
+                error.type === "StripeInvalidRequestError" &&
+                "code" in error &&
+                ["balance_insufficient", "amount_too_small"].includes(String(error.code)) &&
+                "requestId" in error &&
+                typeof error.requestId === "string" &&
+                /^req_\w+$/.test(error.requestId)) {
+                const saved = (await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/recordRejection"), {
+                    ...identity,
+                    requestId: error.requestId,
+                    code: error.code,
+                }));
+                return { status: "terminal", claim: saved };
+            }
+            throw error;
+        }
+        return await reconcileRecipientPayout(stripe, component, ctx, {
             ...identity,
+            stripePayoutId: payout.id,
             maxPages,
         });
-    const latest = await verify();
-    if (latest.status !== "verified" ||
-        !("policy" in latest) ||
-        latest.policy.revision !== controls.policy.revision) {
-        await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/cancelUnattempted"), identity);
-        return {
-            status: "held",
-            reason: latest.status === "verified" ? "policy_changed" : latest.status,
-        };
     }
-    await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/beginAttempt"), identity);
-    let payout;
-    try {
-        payout = await stripe.payouts.create({
-            amount: claim.amount,
-            currency: claim.currency,
-            destination: claim.destinationId,
-            method: "standard",
-            source_type: "card",
-            metadata: { bsPayoutClaim: claim.operationKey },
-        }, {
-            stripeAccount: claim.accountId,
-            idempotencyKey: `bs:payout-release:${claim.operationKey}`,
-        });
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            "type" in error &&
-            error.type === "StripeInvalidRequestError" &&
-            "code" in error &&
-            ["balance_insufficient", "amount_too_small"].includes(String(error.code)) &&
-            "requestId" in error &&
-            typeof error.requestId === "string" &&
-            /^req_\w+$/.test(error.requestId)) {
-            const saved = (await runMutationOrThrow(ctx, componentRef(component, "payoutRelease/mutations/recordRejection"), {
-                ...identity,
-                requestId: error.requestId,
-                code: error.code,
-            }));
-            return { status: "terminal", claim: saved };
-        }
-        throw error;
+    finally {
+        await discardQualificationInput(component, ctx, proof.collection, proof.status === "held" && proof.reason === "collection_pending");
     }
-    return reconcileRecipientPayout(stripe, component, ctx, {
-        ...identity,
-        stripePayoutId: payout.id,
-        maxPages,
-    });
 }
 //# sourceMappingURL=payoutExecution.js.map