@fantastic.dev/better-stripe 0.23.2 → 0.24.0

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

@@ -14,6 +14,222 @@ type Sync = (stripe: Stripe, component: Component, ctx: RunCtx, opts: {
 export declare function operation(): Promise<Sync>;
 export declare function setup(scope?: Scope): Promise<{
     t: import("convex-test").TestConvex<import("convex/server").SchemaDefinition<{
+        affiliateObligations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            accounted?: boolean | undefined;
+            activeOperationId?: import("convex/values").GenericId<"affiliateRecoveryOperations"> | undefined;
+            affiliateAccountId: string;
+            chargeAmount: number;
+            creditAmount?: number | undefined;
+            currency: string;
+            debtAmount?: number | undefined;
+            debtStatus?: "open" | "settled" | undefined;
+            disputeId?: string | undefined;
+            disputeState?: "lost" | "open" | "won" | undefined;
+            disputedPrincipal: number;
+            earningId?: import("convex/values").GenericId<"affiliateEarnings"> | undefined;
+            finalizedAmount: number;
+            lastError?: string | undefined;
+            lastRefundId?: string | undefined;
+            lastState?: string | undefined;
+            legacyReceiptIds?: string[] | undefined;
+            legacyRestorationIds?: string[] | undefined;
+            lostPrincipal: number;
+            needsReconciliation: boolean;
+            offsetAmount?: number | undefined;
+            operationSequence?: number | undefined;
+            operatorNote?: string | undefined;
+            originalCommission: number;
+            paymentId?: string | undefined;
+            paymentIntentId?: string | undefined;
+            provisionalAmount: number;
+            recoveredAmount: number;
+            refundedPrincipal: number;
+            releasedCommission?: number | undefined;
+            reservedRecovery?: number | undefined;
+            reservedRestoration?: number | undefined;
+            restoredAmount?: number | undefined;
+            sourceChargeId: string;
+            sourceInvoiceId?: string | undefined;
+            storeAccountId?: string | undefined;
+            stripeTransferId?: string | undefined;
+        }, {
+            stripeTransferId: import("convex/values").VString<string | undefined, "optional">;
+            sourceChargeId: import("convex/values").VString<string, "required">;
+            sourceInvoiceId: import("convex/values").VString<string | undefined, "optional">;
+            paymentIntentId: import("convex/values").VString<string | undefined, "optional">;
+            paymentId: import("convex/values").VString<string | undefined, "optional">;
+            storeAccountId: import("convex/values").VString<string | undefined, "optional">;
+            lastRefundId: import("convex/values").VString<string | undefined, "optional">;
+            affiliateAccountId: import("convex/values").VString<string, "required">;
+            currency: import("convex/values").VString<string, "required">;
+            chargeAmount: import("convex/values").VFloat64<number, "required">;
+            originalCommission: import("convex/values").VFloat64<number, "required">;
+            refundedPrincipal: import("convex/values").VFloat64<number, "required">;
+            disputedPrincipal: import("convex/values").VFloat64<number, "required">;
+            lostPrincipal: import("convex/values").VFloat64<number, "required">;
+            finalizedAmount: import("convex/values").VFloat64<number, "required">;
+            provisionalAmount: import("convex/values").VFloat64<number, "required">;
+            recoveredAmount: import("convex/values").VFloat64<number, "required">;
+            needsReconciliation: import("convex/values").VBoolean<boolean, "required">;
+            accounted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            legacyReceiptIds: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+            legacyRestorationIds: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+            operatorNote: import("convex/values").VString<string | undefined, "optional">;
+            earningId: import("convex/values").VId<import("convex/values").GenericId<"affiliateEarnings"> | undefined, "optional">;
+            releasedCommission: import("convex/values").VFloat64<number | undefined, "optional">;
+            offsetAmount: import("convex/values").VFloat64<number | undefined, "optional">;
+            restoredAmount: import("convex/values").VFloat64<number | undefined, "optional">;
+            reservedRecovery: import("convex/values").VFloat64<number | undefined, "optional">;
+            reservedRestoration: import("convex/values").VFloat64<number | undefined, "optional">;
+            debtAmount: import("convex/values").VFloat64<number | undefined, "optional">;
+            creditAmount: import("convex/values").VFloat64<number | undefined, "optional">;
+            debtStatus: import("convex/values").VUnion<"open" | "settled" | undefined, [import("convex/values").VLiteral<"open", "required">, import("convex/values").VLiteral<"settled", "required">], "optional", never>;
+            disputeState: import("convex/values").VUnion<"lost" | "open" | "won" | undefined, [import("convex/values").VLiteral<"open", "required">, import("convex/values").VLiteral<"lost", "required">, import("convex/values").VLiteral<"won", "required">], "optional", never>;
+            disputeId: import("convex/values").VString<string | undefined, "optional">;
+            activeOperationId: import("convex/values").VId<import("convex/values").GenericId<"affiliateRecoveryOperations"> | undefined, "optional">;
+            lastState: import("convex/values").VString<string | undefined, "optional">;
+            lastError: import("convex/values").VString<string | undefined, "optional">;
+            operationSequence: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "required", "accounted" | "activeOperationId" | "affiliateAccountId" | "chargeAmount" | "creditAmount" | "currency" | "debtAmount" | "debtStatus" | "disputeId" | "disputeState" | "disputedPrincipal" | "earningId" | "finalizedAmount" | "lastError" | "lastRefundId" | "lastState" | "legacyReceiptIds" | "legacyRestorationIds" | "lostPrincipal" | "needsReconciliation" | "offsetAmount" | "operationSequence" | "operatorNote" | "originalCommission" | "paymentId" | "paymentIntentId" | "provisionalAmount" | "recoveredAmount" | "refundedPrincipal" | "releasedCommission" | "reservedRecovery" | "reservedRestoration" | "restoredAmount" | "sourceChargeId" | "sourceInvoiceId" | "storeAccountId" | "stripeTransferId">, {
+            by_affiliate_currency: ["affiliateAccountId", "currency", "_creationTime"];
+            by_affiliate_currency_debt: ["affiliateAccountId", "currency", "debtStatus", "_creationTime"];
+            by_charge: ["sourceChargeId", "_creationTime"];
+            by_transfer: ["stripeTransferId", "_creationTime"];
+        }, {}, {}>;
+        affiliateRecoveryOperations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            amount: number;
+            attempted: boolean;
+            createdAt: number;
+            error?: string | undefined;
+            kind: "recovery" | "restoration";
+            obligationId: import("convex/values").GenericId<"affiliateObligations">;
+            providerBaseline?: number | undefined;
+            receiptId?: string | undefined;
+            sourceEventId?: string | undefined;
+            state: "canceled" | "failed" | "insufficient_balance" | "pending" | "succeeded" | "unknown" | "unsupported";
+        }, {
+            obligationId: import("convex/values").VId<import("convex/values").GenericId<"affiliateObligations">, "required">;
+            sourceEventId: import("convex/values").VString<string | undefined, "optional">;
+            kind: import("convex/values").VUnion<"recovery" | "restoration", [import("convex/values").VLiteral<"recovery", "required">, import("convex/values").VLiteral<"restoration", "required">], "required", never>;
+            amount: import("convex/values").VFloat64<number, "required">;
+            state: import("convex/values").VUnion<"canceled" | "failed" | "insufficient_balance" | "pending" | "succeeded" | "unknown" | "unsupported", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"unknown", "required">, import("convex/values").VLiteral<"insufficient_balance", "required">, import("convex/values").VLiteral<"unsupported", "required">, import("convex/values").VLiteral<"failed", "required">, import("convex/values").VLiteral<"succeeded", "required">, import("convex/values").VLiteral<"canceled", "required">], "required", never>;
+            receiptId: import("convex/values").VString<string | undefined, "optional">;
+            error: import("convex/values").VString<string | undefined, "optional">;
+            attempted: import("convex/values").VBoolean<boolean, "required">;
+            providerBaseline: import("convex/values").VFloat64<number | undefined, "optional">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "amount" | "attempted" | "createdAt" | "error" | "kind" | "obligationId" | "providerBaseline" | "receiptId" | "sourceEventId" | "state">, {
+            by_obligation: ["obligationId", "_creationTime"];
+            by_state: ["state", "_creationTime"];
+        }, {}, {}>;
+        affiliatePayoutReleases: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            affiliateAccountId: string;
+            amount: number;
+            createdAt: number;
+            currency: string;
+            minimumAmount: number;
+            operationKey: string;
+            state: "failed" | "pending" | "submitted" | "unknown";
+            stripePayoutId?: string | undefined;
+        }, {
+            affiliateAccountId: import("convex/values").VString<string, "required">;
+            currency: import("convex/values").VString<string, "required">;
+            operationKey: import("convex/values").VString<string, "required">;
+            amount: import("convex/values").VFloat64<number, "required">;
+            minimumAmount: import("convex/values").VFloat64<number, "required">;
+            state: import("convex/values").VUnion<"failed" | "pending" | "submitted" | "unknown", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"unknown", "required">, import("convex/values").VLiteral<"submitted", "required">, import("convex/values").VLiteral<"failed", "required">], "required", never>;
+            stripePayoutId: import("convex/values").VString<string | undefined, "optional">;
+            createdAt: import("convex/values").VFloat64<number, "required">;
+        }, "required", "affiliateAccountId" | "amount" | "createdAt" | "currency" | "minimumAmount" | "operationKey" | "state" | "stripePayoutId">, {
+            by_key: ["operationKey", "_creationTime"];
+            by_state: ["state", "_creationTime"];
+        }, {}, {}>;
+        affiliateEarnings: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            affiliateAccountId: string;
+            currency: string;
+            originalCommission: number;
+            paymentIntentId?: string | undefined;
+            releaseAmount: number;
+            sourceChargeId: string;
+            sourceInvoiceId?: string | undefined;
+            status: "paid" | "reserved";
+            stripeTransferId?: string | undefined;
+            withheldAmount: number;
+        }, {
+            sourceChargeId: import("convex/values").VString<string, "required">;
+            affiliateAccountId: import("convex/values").VString<string, "required">;
+            currency: import("convex/values").VString<string, "required">;
+            originalCommission: import("convex/values").VFloat64<number, "required">;
+            withheldAmount: import("convex/values").VFloat64<number, "required">;
+            releaseAmount: import("convex/values").VFloat64<number, "required">;
+            sourceInvoiceId: import("convex/values").VString<string | undefined, "optional">;
+            paymentIntentId: import("convex/values").VString<string | undefined, "optional">;
+            stripeTransferId: import("convex/values").VString<string | undefined, "optional">;
+            status: import("convex/values").VUnion<"paid" | "reserved", [import("convex/values").VLiteral<"reserved", "required">, import("convex/values").VLiteral<"paid", "required">], "required", never>;
+        }, "required", "affiliateAccountId" | "currency" | "originalCommission" | "paymentIntentId" | "releaseAmount" | "sourceChargeId" | "sourceInvoiceId" | "status" | "stripeTransferId" | "withheldAmount">, {
+            by_affiliate_currency: ["affiliateAccountId", "currency", "_creationTime"];
+            by_charge_affiliate: ["sourceChargeId", "affiliateAccountId", "_creationTime"];
+        }, {}, {}>;
+        affiliateOffsets: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            amount: number;
+            earningId: import("convex/values").GenericId<"affiliateEarnings">;
+            obligationId: import("convex/values").GenericId<"affiliateObligations">;
+        }, {
+            earningId: import("convex/values").VId<import("convex/values").GenericId<"affiliateEarnings">, "required">;
+            obligationId: import("convex/values").VId<import("convex/values").GenericId<"affiliateObligations">, "required">;
+            amount: import("convex/values").VFloat64<number, "required">;
+        }, "required", "amount" | "earningId" | "obligationId">, {
+            by_earning: ["earningId", "_creationTime"];
+            by_obligation: ["obligationId", "_creationTime"];
+        }, {}, {}>;
+        affiliateRecoveryBalances: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            activePayoutKey?: string | undefined;
+            affiliateAccountId: string;
+            currency: string;
+            netPayable: number;
+            offsetAmount: number;
+            originalCommission: number;
+            outstandingDebt: number;
+            pendingPayoutAmount?: number | undefined;
+            recoveredAmount: number;
+            reservedRecovery: number;
+            reservedRestoration: number;
+            restorationDue: number;
+            restoredAmount: number;
+            withheldAmount: number;
+        }, {
+            activePayoutKey: import("convex/values").VString<string | undefined, "optional">;
+            pendingPayoutAmount: import("convex/values").VFloat64<number | undefined, "optional">;
+            affiliateAccountId: import("convex/values").VString<string, "required">;
+            currency: import("convex/values").VString<string, "required">;
+            originalCommission: import("convex/values").VFloat64<number, "required">;
+            recoveredAmount: import("convex/values").VFloat64<number, "required">;
+            offsetAmount: import("convex/values").VFloat64<number, "required">;
+            restoredAmount: import("convex/values").VFloat64<number, "required">;
+            outstandingDebt: import("convex/values").VFloat64<number, "required">;
+            reservedRecovery: import("convex/values").VFloat64<number, "required">;
+            reservedRestoration: import("convex/values").VFloat64<number, "required">;
+            restorationDue: import("convex/values").VFloat64<number, "required">;
+            withheldAmount: import("convex/values").VFloat64<number, "required">;
+            netPayable: import("convex/values").VFloat64<number, "required">;
+        }, "required", "activePayoutKey" | "affiliateAccountId" | "currency" | "netPayable" | "offsetAmount" | "originalCommission" | "outstandingDebt" | "pendingPayoutAmount" | "recoveredAmount" | "reservedRecovery" | "reservedRestoration" | "restorationDue" | "restoredAmount" | "withheldAmount">, {
+            by_affiliate_currency: ["affiliateAccountId", "currency", "_creationTime"];
+        }, {}, {}>;
+        affiliateReversalReceipts: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            amount: number;
+            operationId: string;
+            stripeReversalId: string;
+            stripeTransferId: string;
+        }, {
+            stripeReversalId: import("convex/values").VString<string, "required">;
+            stripeTransferId: import("convex/values").VString<string, "required">;
+            operationId: import("convex/values").VString<string, "required">;
+            amount: import("convex/values").VFloat64<number, "required">;
+        }, "required", "amount" | "operationId" | "stripeReversalId" | "stripeTransferId">, {
+            by_receipt: ["stripeReversalId", "_creationTime"];
+            by_transfer: ["stripeTransferId", "_creationTime"];
+            by_transfer_operation: ["stripeTransferId", "operationId", "_creationTime"];
+        }, {}, {}>;
         payoutSyncClaims: import("convex/server").TableDefinition<import("convex/values").VObject<{
             acceptedAt?: number | undefined;
             acceptedFingerprint?: string | undefined;
@@ -1134,6 +1350,16 @@ export declare function setup(scope?: Scope): Promise<{
             by_stripe_transfer_id: ["stripeTransferId", "_creationTime"];
         }, {}, {}>;
         transferReversalOps: import("convex/server").TableDefinition<import("convex/values").VObject<{
+            commissionExposure?: {
+                chargeAmount: number;
+                disputeId?: string | undefined;
+                disputeState?: "lost" | "open" | "won" | undefined;
+                finalized: boolean;
+                kind: "dispute" | "refund";
+                principal: number;
+                refundId?: string | undefined;
+                refundedPrincipal?: number | undefined;
+            } | undefined;
             operationId: string;
             slices: {
                 from: number;
@@ -1157,8 +1383,28 @@ export declare function setup(scope?: Scope): Promise<{
                 from: import("convex/values").VFloat64<number, "required">;
                 to: import("convex/values").VFloat64<number, "required">;
             }, "required", "from" | "stripeTransferId" | "to">, "required">;
-        }, "required", "operationId" | "slices" | "sourceChargeId">, {
+            commissionExposure: import("convex/values").VObject<{
+                chargeAmount: number;
+                disputeId?: string | undefined;
+                disputeState?: "lost" | "open" | "won" | undefined;
+                finalized: boolean;
+                kind: "dispute" | "refund";
+                principal: number;
+                refundId?: string | undefined;
+                refundedPrincipal?: number | undefined;
+            } | undefined, {
+                kind: import("convex/values").VUnion<"dispute" | "refund", [import("convex/values").VLiteral<"refund", "required">, import("convex/values").VLiteral<"dispute", "required">], "required", never>;
+                chargeAmount: import("convex/values").VFloat64<number, "required">;
+                principal: import("convex/values").VFloat64<number, "required">;
+                finalized: import("convex/values").VBoolean<boolean, "required">;
+                disputeState: import("convex/values").VUnion<"lost" | "open" | "won" | undefined, [import("convex/values").VLiteral<"open", "required">, import("convex/values").VLiteral<"lost", "required">, import("convex/values").VLiteral<"won", "required">], "optional", never>;
+                disputeId: import("convex/values").VString<string | undefined, "optional">;
+                refundedPrincipal: import("convex/values").VFloat64<number | undefined, "optional">;
+                refundId: import("convex/values").VString<string | undefined, "optional">;
+            }, "optional", "chargeAmount" | "disputeId" | "disputeState" | "finalized" | "kind" | "principal" | "refundId" | "refundedPrincipal">;
+        }, "required", "commissionExposure" | "commissionExposure.chargeAmount" | "commissionExposure.disputeId" | "commissionExposure.disputeState" | "commissionExposure.finalized" | "commissionExposure.kind" | "commissionExposure.principal" | "commissionExposure.refundId" | "commissionExposure.refundedPrincipal" | "operationId" | "slices" | "sourceChargeId">, {
             by_operation_id: ["operationId", "_creationTime"];
+            by_source_charge: ["sourceChargeId", "_creationTime"];
         }, {}, {}>;
         webhookEvents: import("convex/server").TableDefinition<import("convex/values").VObject<{
             eventType: string;

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

@@ -1 +1 @@
-{"version":3,"file":"payoutSyncTestHelpers.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutSyncTestHelpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvD,eAAO,MAAM,SAAS,EAIN,SAAS,CAAC;AAC1B,MAAM,MAAM,KAAK,GACf;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAClE,KAAK,IAAI,GAAG,CACV,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,KAC3C,OAAO,CAAC,OAAO,CAAC,CAAC;AACtB,wBAAsB,SAAS,kBAU9B;AACD,wBAAsB,KAAK,CACzB,KAAK,GAAE,KAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCzC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQtC"}
+{"version":3,"file":"payoutSyncTestHelpers.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payoutSyncTestHelpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvD,eAAO,MAAM,SAAS,EAIN,SAAS,CAAC;AAC1B,MAAM,MAAM,KAAK,GACf;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAClE,KAAK,IAAI,GAAG,CACV,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,KAC3C,OAAO,CAAC,OAAO,CAAC,CAAC;AACtB,wBAAsB,SAAS,kBAU9B;AACD,wBAAsB,KAAK,CACzB,KAAK,GAAE,KAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCzC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQtC"}

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

@@ -27,6 +27,8 @@ export declare function getAccountBalance(stripe: Stripe, opts: {
     stripeAccountId: string;
 }): Promise<AccountBalance[]>;
 export type CreatePayoutOptions = {
+    /** Host-authorized minimum in the payout currency. */
+    minimumAmount?: number;
     stripeAccountId: string;
     amount: number;
     currency?: string;
@@ -34,7 +36,7 @@ export type CreatePayoutOptions = {
     /** Stripe idempotency key for retry-safe payout creation. */
     idempotencyKey?: string;
 };
-export declare function createPayout(stripe: Stripe, _ctx: RunCtx, opts: CreatePayoutOptions): Promise<{
+export declare function createPayout(stripe: Stripe, ctx: RunCtx, opts: CreatePayoutOptions, component?: Component): Promise<{
     stripePayoutId: string;
 }>;
 export declare function getPayout(component: Component, ctx: RunCtx, opts: {

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

@@ -1 +1 @@
-{"version":3,"file":"payouts.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payouts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAOvD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,cAAc,EAAE,CAAC,CAiB3B;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,mBAAmB;;GAgB1B;AAED,wBAAsB,SAAS,CAC7B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,gBAM3B;AAED,wBAAsB,WAAW,CAC/B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,gBAO3E"}
+{"version":3,"file":"payouts.d.ts","sourceRoot":"","sources":["../../../src/client/connect/payouts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAOvD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,cAAc,EAAE,CAAC,CAiB3B;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,mBAAmB,EACzB,SAAS,CAAC,EAAE,SAAS;;GAmEtB;AAED,wBAAsB,SAAS,CAC7B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,gBAM3B;AAED,wBAAsB,WAAW,CAC/B,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,gBAO3E"}

package/dist/client/connect/payouts.js

@@ -1,3 +1,5 @@
+import { reserveAffiliatePayout, completeAffiliatePayout, reconcileAffiliatePayout, } from "../affiliateRecovery/payoutGate.js";
+import { classifyRecoveryError } from "../affiliateRecovery/provider.js";
 import { componentRef } from "../webhooks/helpers.js";
 /**
  * Retrieve a connected account's balance (BTS-65), scoped to that account via
@@ -26,18 +28,49 @@ export async function getAccountBalance(stripe, opts) {
         entryFor(p.currency).pending += p.amount;
     return [...byCurrency.values()];
 }
-export async function createPayout(stripe, _ctx, opts) {
-    const payout = await stripe.payouts.create({
-        amount: opts.amount,
-        currency: opts.currency ?? "usd",
-        metadata: opts.metadata ?? undefined,
-    }, {
-        stripeAccount: opts.stripeAccountId,
-        ...(opts.idempotencyKey !== undefined
-            ? { idempotencyKey: opts.idempotencyKey }
-            : {}),
-    });
-    return { stripePayoutId: payout.id };
+export async function createPayout(stripe, ctx, opts, component) {
+    const release = component
+        ? await reserveAffiliatePayout(component, ctx, opts)
+        : null;
+    if (release?.state === "submitted")
+        return { stripePayoutId: release.stripePayoutId };
+    if (release?.state === "failed")
+        throw new Error("Affiliate payout failed; use a new authorized operation key.");
+    try {
+        if (release) {
+            const receiptId = await reconcileAffiliatePayout(stripe, release);
+            if (receiptId) {
+                await completeAffiliatePayout(component, ctx, release.operationKey, "submitted", receiptId);
+                return { stripePayoutId: receiptId };
+            }
+        }
+        if (release) {
+            if (Date.now() - release.createdAt >= 23 * 60 * 60 * 1000)
+                throw new Error("Affiliate payout idempotency window expired; reconcile the provider receipt before retrying.");
+            // Receipt lookup may yield while a refund records new debt.
+            await reserveAffiliatePayout(component, ctx, opts);
+        }
+        const payout = await stripe.payouts.create({
+            amount: opts.amount,
+            currency: opts.currency ?? "usd",
+            metadata: release
+                ? { ...opts.metadata, bsAffiliatePayout: release._id }
+                : (opts.metadata ?? undefined),
+        }, {
+            stripeAccount: opts.stripeAccountId,
+            ...(opts.idempotencyKey !== undefined
+                ? { idempotencyKey: opts.idempotencyKey }
+                : {}),
+        });
+        if (release)
+            await completeAffiliatePayout(component, ctx, release.operationKey, "submitted", payout.id);
+        return { stripePayoutId: payout.id };
+    }
+    catch (error) {
+        if (release)
+            await completeAffiliatePayout(component, ctx, release.operationKey, classifyRecoveryError(error).state === "unknown" ? "unknown" : "failed");
+        throw error;
+    }
 }
 export async function getPayout(component, ctx, opts) {
     return ctx.runQuery(componentRef(component, "connect/queries/getPayout"), opts);

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

@@ -1 +1 @@
-{"version":3,"file":"payouts.js","sourceRoot":"","sources":["../../../src/client/connect/payouts.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAqBtD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,MAAc,EACd,IAAiC;IAEjC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE;QACvD,aAAa,EAAE,IAAI,CAAC,eAAe;KACpC,CAAC,CAAC;IAEH,MAAM,UAAU,GAAG,IAAI,GAAG,EAA0B,CAAC;IACrD,MAAM,QAAQ,GAAG,CAAC,QAAgB,EAAkB,EAAE;QACpD,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACrC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC;YAC/C,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS;QAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC;IAC9E,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,OAAO;QAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC;IAC1E,OAAO,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;AAClC,CAAC;AAWD,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAAc,EACd,IAAY,EACZ,IAAyB;IAEzB,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,CACxC;QACE,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,KAAK;QAChC,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,SAAS;KACrC,EACD;QACE,aAAa,EAAE,IAAI,CAAC,eAAe;QACnC,GAAG,CAAC,IAAI,CAAC,cAAc,KAAK,SAAS;YACnC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE;YACzC,CAAC,CAAC,EAAE,CAAC;KACR,CACF,CAAC;IACF,OAAO,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;AACvC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,SAAoB,EACpB,GAAW,EACX,IAA0B;IAE1B,OAAO,GAAG,CAAC,QAAQ,CACjB,YAAY,CAAC,SAAS,EAAE,2BAA2B,CAAC,EACpD,IAAI,CACL,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,SAAoB,EACpB,GAAW,EACX,IAA0E;IAE1E,MAAM,EAAE,eAAe,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;IAChD,OAAO,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,6BAA6B,CAAC,EAAE;QAC1E,GAAG,IAAI;QACP,GAAG,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzE,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"payouts.js","sourceRoot":"","sources":["../../../src/client/connect/payouts.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+import type Stripe from "stripe";
+/** Charge.amount_refunded also includes pending refunds; only success is final. */
+export declare function successfulRefundPrincipal(stripe: Stripe, chargeId: string): Promise<number>;
+//# sourceMappingURL=refundPrincipal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refundPrincipal.d.ts","sourceRoot":"","sources":["../../../src/client/connect/refundPrincipal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,mFAAmF;AACnF,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,mBAoBjB"}

package/dist/client/connect/refundPrincipal.js

@@ -0,0 +1,21 @@
+/** Charge.amount_refunded also includes pending refunds; only success is final. */
+export async function successfulRefundPrincipal(stripe, chargeId) {
+    let principal = 0;
+    let count = 0;
+    for await (const refund of stripe.refunds.list({
+        charge: chargeId,
+        limit: 100,
+    })) {
+        if (++count > 1000)
+            throw new Error("Successful refund lookup limit exceeded.");
+        if (refund.status !== "succeeded")
+            continue;
+        if (!Number.isSafeInteger(refund.amount) ||
+            refund.amount < 0 ||
+            !Number.isSafeInteger(principal + refund.amount))
+            throw new Error("Invalid successful refund principal.");
+        principal += refund.amount;
+    }
+    return principal;
+}
+//# sourceMappingURL=refundPrincipal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refundPrincipal.js","sourceRoot":"","sources":["../../../src/client/connect/refundPrincipal.ts"],"names":[],"mappings":"AAEA,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC7C,MAAc,EACd,QAAgB;IAEhB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,EAAE,MAAM,MAAM,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;QAC7C,MAAM,EAAE,QAAQ;QAChB,KAAK,EAAE,GAAG;KACX,CAAC,EAAE,CAAC;QACH,IAAI,EAAE,KAAK,GAAG,IAAI;YAChB,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW;YAAE,SAAS;QAC5C,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC;YACpC,MAAM,CAAC,MAAM,GAAG,CAAC;YACjB,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;YAEhD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC;IAC7B,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,47 @@
+import type Stripe from "stripe";
+import type { Component, RunCtx } from "../helpers.js";
+export type ClaimedSlice = {
+    stripeTransferId: string;
+    /** Cumulative reversed amount this slice starts from. */
+    from: number;
+    /** Cumulative reversed amount this slice raises the leg to. */
+    to: number;
+    /** The leg's confirmed `reversedAmount` at claim time. */
+    confirmed: number;
+    commissionTracked?: boolean;
+};
+export type ReversalClaim = {
+    replay: boolean;
+    slices: ClaimedSlice[];
+};
+/**
+ * Execute the slices an operation claimed via `claimReversalSlices` (BTS-63).
+ * The claim already reserved this money atomically, so all that's left is
+ * moving it: one `bs_rev_<operationId>_<transferId>` reversal per slice, then
+ * confirming the new cumulative total in the ledger. A replayed claim always
+ * re-sends byte-identical params under the same key, which Stripe answers
+ * from its idempotency cache without moving money twice.
+ *
+ * Because Stripe prunes idempotency keys after ~24h (and a crash can land
+ * between the Stripe call and the ledger confirm), a replay first checks the
+ * transfer's live `amount_reversed`: if the slice's money already moved, it
+ * just confirms the ledger instead of re-sending the reversal.
+ *
+ * A slice only executes once every predecessor slice on its leg is confirmed
+ * (`confirmed ≥ from`). Without that gate, a sibling operation landing behind
+ * a transiently-failed claim would execute and confirm PAST the hole; the
+ * failed operation's retry would then see `confirmed ≥ to` and silently skip
+ * — its money would never move while the ledger says it did. Throwing instead
+ * fails this operation's webhook event, and at-least-once delivery retries
+ * both operations until the predecessor fills its hole and each claimed slice
+ * has actually moved. The ledger's `reversedAmount` therefore always covers a
+ * solid, hole-free prefix of the reversed axis — which is exactly what makes
+ * the `confirmed`/`amount_reversed` checks above sound.
+ */
+export declare function executeClaimedSlices(stripe: Stripe, component: Component, ctx: RunCtx, operationId: string, claim: ReversalClaim): Promise<{
+    reversals: {
+        stripeTransferId: string;
+        amount: number;
+    }[];
+}>;
+//# sourceMappingURL=reversalExecution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reversalExecution.d.ts","sourceRoot":"","sources":["../../../src/client/connect/reversalExecution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAKvD,MAAM,MAAM,YAAY,GAAG;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,EAAE,EAAE,MAAM,CAAC;IACX,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC;IAAE,SAAS,EAAE;QAAE,gBAAgB,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC,CAgFxE"}

package/dist/client/connect/reversalExecution.js

@@ -0,0 +1,84 @@
+import { runMutationOrThrow } from "../helpers.js";
+import { componentRef } from "../webhooks/helpers.js";
+import { findCommissionReversal } from "./commissionReceipts.js";
+/**
+ * Execute the slices an operation claimed via `claimReversalSlices` (BTS-63).
+ * The claim already reserved this money atomically, so all that's left is
+ * moving it: one `bs_rev_<operationId>_<transferId>` reversal per slice, then
+ * confirming the new cumulative total in the ledger. A replayed claim always
+ * re-sends byte-identical params under the same key, which Stripe answers
+ * from its idempotency cache without moving money twice.
+ *
+ * Because Stripe prunes idempotency keys after ~24h (and a crash can land
+ * between the Stripe call and the ledger confirm), a replay first checks the
+ * transfer's live `amount_reversed`: if the slice's money already moved, it
+ * just confirms the ledger instead of re-sending the reversal.
+ *
+ * A slice only executes once every predecessor slice on its leg is confirmed
+ * (`confirmed ≥ from`). Without that gate, a sibling operation landing behind
+ * a transiently-failed claim would execute and confirm PAST the hole; the
+ * failed operation's retry would then see `confirmed ≥ to` and silently skip
+ * — its money would never move while the ledger says it did. Throwing instead
+ * fails this operation's webhook event, and at-least-once delivery retries
+ * both operations until the predecessor fills its hole and each claimed slice
+ * has actually moved. The ledger's `reversedAmount` therefore always covers a
+ * solid, hole-free prefix of the reversed axis — which is exactly what makes
+ * the `confirmed`/`amount_reversed` checks above sound.
+ */
+export async function executeClaimedSlices(stripe, component, ctx, operationId, claim) {
+    const reversals = [];
+    for (const slice of claim.slices) {
+        const receiptAmount = slice.to - slice.from;
+        if (slice.commissionTracked && claim.replay) {
+            const receipt = await findCommissionReversal(stripe, slice.stripeTransferId, operationId, receiptAmount);
+            if (receipt) {
+                await runMutationOrThrow(ctx, componentRef(component, "connect/mutations/recordTransferReversal"), {
+                    stripeTransferId: slice.stripeTransferId,
+                    reversedAmount: slice.to,
+                    receipt: {
+                        stripeReversalId: receipt.id,
+                        operationId,
+                        amount: receiptAmount,
+                    },
+                });
+                continue;
+            }
+            if (slice.confirmed >= slice.to)
+                throw new Error("Commission reversal requires receipt reconciliation.");
+        }
+        if (slice.confirmed >= slice.to)
+            continue; // executed and recorded already
+        if (slice.confirmed < slice.from) {
+            throw new Error(`reversal slice [${slice.from},${slice.to}) on ${slice.stripeTransferId} ` +
+                `blocked: predecessor claim unexecuted (confirmed=${slice.confirmed})`);
+        }
+        if (claim.replay && !slice.commissionTracked) {
+            const transfer = await stripe.transfers.retrieve(slice.stripeTransferId);
+            if ((transfer.amount_reversed ?? 0) >= slice.to) {
+                // The money moved on a previous attempt that died before confirming.
+                await runMutationOrThrow(ctx, componentRef(component, "connect/mutations/recordTransferReversal"), {
+                    stripeTransferId: slice.stripeTransferId,
+                    reversedAmount: slice.to,
+                });
+                continue;
+            }
+        }
+        const amount = slice.to - slice.from;
+        const receipt = await stripe.transfers.createReversal(slice.stripeTransferId, {
+            amount,
+            ...(slice.commissionTracked
+                ? { metadata: { bsReversalOperation: operationId } }
+                : {}),
+        }, { idempotencyKey: `bs_rev_${operationId}_${slice.stripeTransferId}` });
+        await runMutationOrThrow(ctx, componentRef(component, "connect/mutations/recordTransferReversal"), {
+            stripeTransferId: slice.stripeTransferId,
+            reversedAmount: slice.to,
+            ...(slice.commissionTracked
+                ? { receipt: { stripeReversalId: receipt.id, operationId, amount } }
+                : {}),
+        });
+        reversals.push({ stripeTransferId: slice.stripeTransferId, amount });
+    }
+    return { reversals };
+}
+//# sourceMappingURL=reversalExecution.js.map

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

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

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

@@ -104,9 +104,9 @@ export declare function reverseTransfers(stripe: Stripe, component: Component, c
     }[];
 }>;
 /**
- * Reverse a split sale's transfers pro-rata to the cumulatively refunded
- * amount (BTS-34) — the refund counterpart of the dispute clawback. Every leg
- * converges on a cumulative reversal TARGET, `round(leg × amountRefunded /
+ * Reverse a split sale's transfers pro-rata to cumulative succeeded refunds.
+ * Affiliate legs retain the larger refund/dispute commission exposure. Other
+ * legs converge on a cumulative reversal TARGET, `round(leg × amountRefunded /
  * chargeAmount)`, and only the delta above the ledger's recorded
  * `reversedAmount` is reversed. Delta-to-target (rather than percent-of-
  * original like {@link reverseTransfers}) is what makes at-least-once webhook
@@ -127,7 +127,7 @@ export declare function reverseTransfersForRefund(stripe: Stripe, component: Com
     refundId: string;
     /** The original charge amount (minor units). */
     chargeAmount: number;
-    /** Stripe's cumulative `charge.amount_refunded`, including this refund. */
+    /** Cumulative principal of succeeded refunds; exclude pending/failed refunds. */
     amountRefunded: number;
 }): Promise<{
     reversals: {
@@ -135,6 +135,7 @@ export declare function reverseTransfersForRefund(stripe: Stripe, component: Com
         amount: number;
     }[];
 }>;
+export { reverseTransfersForDispute } from "../affiliateRecovery/disputes.js";
 /**
  * Webhook-driven split transfer engine (BTS-22). After a charge succeeds for a
  * separate-charges sale, fan funds out to each split recipient: compute the
@@ -163,6 +164,9 @@ export declare function reinstateTransfers(stripe: Stripe, component: Component,
     sourceChargeId: string;
     operationId: string;
     currency: string;
+    excludeAffiliates?: boolean;
+    chargeAmount?: number;
+    refundedPrincipal?: number;
 }): Promise<{
     reinstated: {
         destinationAccountId: string;