@fantastic.dev/better-stripe 0.62.0 → 0.64.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +17 -0
- package/README.md +22 -2
- package/dist/client/connect/payoutAdoptionTestHelpers.d.ts +550 -0
- package/dist/client/connect/payoutAdoptionTestHelpers.d.ts.map +1 -1
- package/dist/client/connect/payoutExecutionTestHelpers.d.ts +275 -0
- package/dist/client/connect/payoutExecutionTestHelpers.d.ts.map +1 -1
- package/dist/client/connect/payoutLargeAdoptionTestHelpers.d.ts +550 -0
- package/dist/client/connect/payoutLargeAdoptionTestHelpers.d.ts.map +1 -1
- package/dist/client/connect/payoutSyncTestHelpers.d.ts +275 -0
- package/dist/client/connect/payoutSyncTestHelpers.d.ts.map +1 -1
- package/dist/client/financialOwnership.d.ts +2 -2
- package/dist/client/financialOwnership.d.ts.map +1 -1
- package/dist/client/financialOwnership.js +2 -2
- package/dist/client/financialOwnership.js.map +1 -1
- package/dist/client/paymentSource/resolver.d.ts +1 -0
- package/dist/client/paymentSource/resolver.d.ts.map +1 -1
- package/dist/client/paymentSource/resolver.js +11 -2
- package/dist/client/paymentSource/resolver.js.map +1 -1
- package/dist/client/paymentSource/zeroTierLines.d.ts +4 -0
- package/dist/client/paymentSource/zeroTierLines.d.ts.map +1 -0
- package/dist/client/paymentSource/zeroTierLines.js +35 -0
- package/dist/client/paymentSource/zeroTierLines.js.map +1 -0
- package/dist/client/payoutRevisionMigration.d.ts +37 -0
- package/dist/client/payoutRevisionMigration.d.ts.map +1 -0
- package/dist/client/payoutRevisionMigration.js +49 -0
- package/dist/client/payoutRevisionMigration.js.map +1 -0
- package/dist/client/publicTypes.d.ts +2 -0
- package/dist/client/publicTypes.d.ts.map +1 -1
- package/dist/client/reversalObservations.d.ts +62 -0
- package/dist/client/reversalObservations.d.ts.map +1 -0
- package/dist/client/reversalObservations.js +79 -0
- package/dist/client/reversalObservations.js.map +1 -0
- package/dist/client/usage/configuration.d.ts +13 -0
- package/dist/client/usage/configuration.d.ts.map +1 -0
- package/dist/client/usage/configuration.js +2 -0
- package/dist/client/usage/configuration.js.map +1 -0
- package/dist/client/usage/deliveryProvider.d.ts.map +1 -1
- package/dist/client/usage/deliveryProvider.js +16 -0
- package/dist/client/usage/deliveryProvider.js.map +1 -1
- package/dist/client/usage/index.d.ts +2 -0
- package/dist/client/usage/index.d.ts.map +1 -1
- package/dist/client/usage/invoiceSale.d.ts.map +1 -1
- package/dist/client/usage/invoiceSale.js +15 -2
- package/dist/client/usage/invoiceSale.js.map +1 -1
- package/dist/client/usage/observationClient.d.ts +2 -2
- package/dist/client/usage/observationClient.d.ts.map +1 -1
- package/dist/client/usage/views.d.ts +24 -0
- package/dist/client/usage/views.d.ts.map +1 -0
- package/dist/client/usage/views.js +2 -0
- package/dist/client/usage/views.js.map +1 -0
- package/dist/component/_generated/api.d.ts +28 -0
- package/dist/component/_generated/api.d.ts.map +1 -1
- package/dist/component/_generated/api.js.map +1 -1
- package/dist/component/_generated/component.d.ts +354 -0
- package/dist/component/_generated/component.d.ts.map +1 -1
- package/dist/component/balanceFunding/internal/actions.d.ts +11 -11
- package/dist/component/balanceFunding/stateHandlers.d.ts +8 -8
- package/dist/component/connect/mutations.d.ts.map +1 -1
- package/dist/component/connect/mutations.js +2 -0
- package/dist/component/connect/mutations.js.map +1 -1
- package/dist/component/connect/reversalClaims.d.ts.map +1 -1
- package/dist/component/connect/reversalClaims.js +10 -1
- package/dist/component/connect/reversalClaims.js.map +1 -1
- package/dist/component/earnings/triggers.d.ts +408 -16
- package/dist/component/earnings/triggers.d.ts.map +1 -1
- package/dist/component/financialObservations/transferSchema.d.ts +1 -0
- package/dist/component/financialObservations/transferSchema.d.ts.map +1 -1
- package/dist/component/financialObservations/transferSchema.js +1 -0
- package/dist/component/financialObservations/transferSchema.js.map +1 -1
- package/dist/component/payoutRevisionJournal/mutations.d.ts +15 -0
- package/dist/component/payoutRevisionJournal/mutations.d.ts.map +1 -0
- package/dist/component/payoutRevisionJournal/mutations.js +11 -0
- package/dist/component/payoutRevisionJournal/mutations.js.map +1 -0
- package/dist/component/payoutRevisionJournal/schema.d.ts +45 -0
- package/dist/component/payoutRevisionJournal/schema.d.ts.map +1 -0
- package/dist/component/payoutRevisionJournal/schema.js +22 -0
- package/dist/component/payoutRevisionJournal/schema.js.map +1 -0
- package/dist/component/payoutRevisionJournal/state.d.ts +36 -0
- package/dist/component/payoutRevisionJournal/state.d.ts.map +1 -0
- package/dist/component/payoutRevisionJournal/state.js +111 -0
- package/dist/component/payoutRevisionJournal/state.js.map +1 -0
- package/dist/component/payoutRevisionMigration/mutations.d.ts +36 -0
- package/dist/component/payoutRevisionMigration/mutations.d.ts.map +1 -0
- package/dist/component/payoutRevisionMigration/mutations.js +126 -0
- package/dist/component/payoutRevisionMigration/mutations.js.map +1 -0
- package/dist/component/payoutRevisionMigration/queries.d.ts +38 -0
- package/dist/component/payoutRevisionMigration/queries.d.ts.map +1 -0
- package/dist/component/payoutRevisionMigration/queries.js +39 -0
- package/dist/component/payoutRevisionMigration/queries.js.map +1 -0
- package/dist/component/payoutRevisionMigration/schema.d.ts +115 -0
- package/dist/component/payoutRevisionMigration/schema.d.ts.map +1 -0
- package/dist/component/payoutRevisionMigration/schema.js +52 -0
- package/dist/component/payoutRevisionMigration/schema.js.map +1 -0
- package/dist/component/payoutSnapshots/legacyRevisionWriter.d.ts +4 -0
- package/dist/component/payoutSnapshots/legacyRevisionWriter.d.ts.map +1 -0
- package/dist/component/payoutSnapshots/legacyRevisionWriter.js +33 -0
- package/dist/component/payoutSnapshots/legacyRevisionWriter.js.map +1 -0
- package/dist/component/payoutSnapshots/revisions.d.ts.map +1 -1
- package/dist/component/payoutSnapshots/revisions.js +23 -29
- package/dist/component/payoutSnapshots/revisions.js.map +1 -1
- package/dist/component/processingCostReconciliation/rollback.d.ts +1 -1
- package/dist/component/refundSync/mutations.d.ts +1 -1
- package/dist/component/refundSync/mutations.d.ts.map +1 -1
- package/dist/component/reversalObservations/capture.d.ts +6 -0
- package/dist/component/reversalObservations/capture.d.ts.map +1 -0
- package/dist/component/reversalObservations/capture.js +96 -0
- package/dist/component/reversalObservations/capture.js.map +1 -0
- package/dist/component/reversalObservations/indexSlice.d.ts +29 -0
- package/dist/component/reversalObservations/indexSlice.d.ts.map +1 -0
- package/dist/component/reversalObservations/indexSlice.js +101 -0
- package/dist/component/reversalObservations/indexSlice.js.map +1 -0
- package/dist/component/reversalObservations/integrity.d.ts +25 -0
- package/dist/component/reversalObservations/integrity.d.ts.map +1 -0
- package/dist/component/reversalObservations/integrity.js +19 -0
- package/dist/component/reversalObservations/integrity.js.map +1 -0
- package/dist/component/reversalObservations/mutations.d.ts +37 -0
- package/dist/component/reversalObservations/mutations.d.ts.map +1 -0
- package/dist/component/reversalObservations/mutations.js +181 -0
- package/dist/component/reversalObservations/mutations.js.map +1 -0
- package/dist/component/reversalObservations/pagination.d.ts +34 -0
- package/dist/component/reversalObservations/pagination.d.ts.map +1 -0
- package/dist/component/reversalObservations/pagination.js +31 -0
- package/dist/component/reversalObservations/pagination.js.map +1 -0
- package/dist/component/reversalObservations/queries.d.ts +221 -0
- package/dist/component/reversalObservations/queries.d.ts.map +1 -0
- package/dist/component/reversalObservations/queries.js +114 -0
- package/dist/component/reversalObservations/queries.js.map +1 -0
- package/dist/component/reversalObservations/references.d.ts +17 -0
- package/dist/component/reversalObservations/references.d.ts.map +1 -0
- package/dist/component/reversalObservations/references.js +95 -0
- package/dist/component/reversalObservations/references.js.map +1 -0
- package/dist/component/reversalObservations/schema.d.ts +525 -0
- package/dist/component/reversalObservations/schema.d.ts.map +1 -0
- package/dist/component/reversalObservations/schema.js +92 -0
- package/dist/component/reversalObservations/schema.js.map +1 -0
- package/dist/component/reversalObservations/selectors.d.ts +3 -0
- package/dist/component/reversalObservations/selectors.d.ts.map +1 -0
- package/dist/component/reversalObservations/selectors.js +8 -0
- package/dist/component/reversalObservations/selectors.js.map +1 -0
- package/dist/component/reversalObservations/state.d.ts +34 -0
- package/dist/component/reversalObservations/state.d.ts.map +1 -0
- package/dist/component/reversalObservations/state.js +34 -0
- package/dist/component/reversalObservations/state.js.map +1 -0
- package/dist/component/schema.d.ts +275 -0
- package/dist/component/schema.js +10 -0
- package/dist/component/schema.js.map +1 -1
- package/dist/component/usage/allowance.fixtures.d.ts +291 -16
- package/dist/component/usage/allowance.fixtures.d.ts.map +1 -1
- package/dist/component/usageCredits/accounting.fixtures.d.ts +275 -0
- package/dist/component/usageCredits/accounting.fixtures.d.ts.map +1 -1
- package/dist/react/workflows/Usage.types.d.ts +2 -23
- package/dist/react/workflows/Usage.types.d.ts.map +1 -1
- package/dist/react/workflows/Usage.types.js.map +1 -1
- package/dist/react/workflows/UsageConfiguration.types.d.ts +3 -11
- package/dist/react/workflows/UsageConfiguration.types.d.ts.map +1 -1
- package/docs/README.md +4 -1
- package/docs/client-api.md +6 -0
- package/docs/financial-observations.md +51 -8
- package/docs/payout-revision-migration.md +54 -0
- package/docs/react-workflows-audit.md +73 -2
- package/docs/usage-configuration.md +4 -0
- package/docs/usage-delivery.md +4 -0
- package/docs/usage-example.md +250 -0
- package/docs/usage-react.md +4 -0
- package/docs/usage-settlement.md +8 -3
- package/package.json +4 -2
- package/src/client/financialOwnership.ts +2 -2
- package/src/client/paymentSource/resolver.ts +14 -2
- package/src/client/paymentSource/zeroTierLines.ts +42 -0
- package/src/client/payoutRevisionMigration.test.ts +40 -0
- package/src/client/payoutRevisionMigration.ts +96 -0
- package/src/client/publicTypes.ts +15 -0
- package/src/client/reversalObservations.test.ts +69 -0
- package/src/client/reversalObservations.ts +151 -0
- package/src/client/usage/configuration.ts +9 -0
- package/src/client/usage/deliveryProvider.test.ts +77 -37
- package/src/client/usage/deliveryProvider.ts +19 -0
- package/src/client/usage/index.ts +4 -0
- package/src/client/usage/invoiceSale.test.ts +68 -0
- package/src/client/usage/invoiceSale.ts +20 -2
- package/src/client/usage/views.ts +23 -0
- package/src/component/_generated/api.ts +28 -0
- package/src/component/_generated/component.ts +423 -0
- package/src/component/connect/mutations.ts +2 -0
- package/src/component/connect/reversalClaims.ts +13 -1
- package/src/component/financialObservations/transferSchema.ts +1 -0
- package/src/component/payoutRevisionJournal/mutations.ts +11 -0
- package/src/component/payoutRevisionJournal/schema.ts +34 -0
- package/src/component/payoutRevisionJournal/state.ts +141 -0
- package/src/component/payoutRevisionMigration/mutations.ts +135 -0
- package/src/component/payoutRevisionMigration/queries.ts +50 -0
- package/src/component/payoutRevisionMigration/schema.ts +51 -0
- package/src/component/payoutSnapshots/legacy-revisions.test.ts +246 -0
- package/src/component/payoutSnapshots/legacyRevisionWriter.ts +39 -0
- package/src/component/payoutSnapshots/revision-journal-callbacks.test.ts +160 -0
- package/src/component/payoutSnapshots/revision-journal-held.test.ts +94 -0
- package/src/component/payoutSnapshots/revision-journal.test.ts +310 -0
- package/src/component/payoutSnapshots/revision-migration.test.ts +128 -0
- package/src/component/payoutSnapshots/revisions.ts +22 -30
- package/src/component/reversalObservations/boundaries.test.ts +62 -0
- package/src/component/reversalObservations/capture-integrity.test.ts +119 -0
- package/src/component/reversalObservations/capture.ts +129 -0
- package/src/component/reversalObservations/continuation.test.ts +131 -0
- package/src/component/reversalObservations/indexSlice.ts +124 -0
- package/src/component/reversalObservations/integrity.ts +31 -0
- package/src/component/reversalObservations/lifecycle.test.ts +81 -0
- package/src/component/reversalObservations/mutations.ts +211 -0
- package/src/component/reversalObservations/pagination.ts +40 -0
- package/src/component/reversalObservations/provenance.test.ts +167 -0
- package/src/component/reversalObservations/queries.ts +121 -0
- package/src/component/reversalObservations/references.ts +134 -0
- package/src/component/reversalObservations/schema.ts +100 -0
- package/src/component/reversalObservations/selectors.ts +9 -0
- package/src/component/reversalObservations/state.ts +42 -0
- package/src/component/schema.ts +18 -0
- package/src/react/workflows/Usage.types.ts +5 -29
- package/src/react/workflows/UsageConfiguration.types.ts +3 -11
|
@@ -1,5 +1,279 @@
|
|
|
1
1
|
export declare function setupCredits(): Promise<{
|
|
2
2
|
t: import("convex-test").TestConvex<import("convex/server").SchemaDefinition<{
|
|
3
|
+
reversalObservations: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
4
|
+
deleted: boolean;
|
|
5
|
+
fingerprint: string;
|
|
6
|
+
generation: number;
|
|
7
|
+
indexTransferGeneration: number | null;
|
|
8
|
+
indexedCount: number;
|
|
9
|
+
isContradictory: boolean;
|
|
10
|
+
latestIdentityFingerprint: string;
|
|
11
|
+
latestPayloadId: import("convex/values").GenericId<"reversalObservationPayloads">;
|
|
12
|
+
legacy: boolean;
|
|
13
|
+
nextIndex: number;
|
|
14
|
+
operationDigest: string;
|
|
15
|
+
originalFingerprint: string;
|
|
16
|
+
originalIdentityFingerprint: string;
|
|
17
|
+
originalOperationId: import("convex/values").GenericId<"transferReversalOps">;
|
|
18
|
+
originalPayloadId: import("convex/values").GenericId<"reversalObservationPayloads">;
|
|
19
|
+
producer: "reversal_claim_lifecycle";
|
|
20
|
+
producerVersion: 1;
|
|
21
|
+
referenceFingerprints: string[];
|
|
22
|
+
sliceCount: number;
|
|
23
|
+
sourceChargeDigest: string;
|
|
24
|
+
sourceCreatedAt: number;
|
|
25
|
+
status: "complete" | "held" | "pending" | "validating";
|
|
26
|
+
}, {
|
|
27
|
+
originalOperationId: import("convex/values").VId<import("convex/values").GenericId<"transferReversalOps">, "required">;
|
|
28
|
+
sourceCreatedAt: import("convex/values").VFloat64<number, "required">;
|
|
29
|
+
producer: import("convex/values").VLiteral<"reversal_claim_lifecycle", "required">;
|
|
30
|
+
producerVersion: import("convex/values").VLiteral<1, "required">;
|
|
31
|
+
originalPayloadId: import("convex/values").VId<import("convex/values").GenericId<"reversalObservationPayloads">, "required">;
|
|
32
|
+
latestPayloadId: import("convex/values").VId<import("convex/values").GenericId<"reversalObservationPayloads">, "required">;
|
|
33
|
+
referenceFingerprints: import("convex/values").VArray<string[], import("convex/values").VString<string, "required">, "required">;
|
|
34
|
+
originalFingerprint: import("convex/values").VString<string, "required">;
|
|
35
|
+
latestIdentityFingerprint: import("convex/values").VString<string, "required">;
|
|
36
|
+
originalIdentityFingerprint: import("convex/values").VString<string, "required">;
|
|
37
|
+
fingerprint: import("convex/values").VString<string, "required">;
|
|
38
|
+
operationDigest: import("convex/values").VString<string, "required">;
|
|
39
|
+
sourceChargeDigest: import("convex/values").VString<string, "required">;
|
|
40
|
+
generation: import("convex/values").VFloat64<number, "required">;
|
|
41
|
+
deleted: import("convex/values").VBoolean<boolean, "required">;
|
|
42
|
+
sliceCount: import("convex/values").VFloat64<number, "required">;
|
|
43
|
+
indexedCount: import("convex/values").VFloat64<number, "required">;
|
|
44
|
+
nextIndex: import("convex/values").VFloat64<number, "required">;
|
|
45
|
+
status: import("convex/values").VUnion<"complete" | "held" | "pending" | "validating", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"validating", "required">, import("convex/values").VLiteral<"complete", "required">, import("convex/values").VLiteral<"held", "required">], "required", never>;
|
|
46
|
+
legacy: import("convex/values").VBoolean<boolean, "required">;
|
|
47
|
+
isContradictory: import("convex/values").VBoolean<boolean, "required">;
|
|
48
|
+
indexTransferGeneration: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
|
|
49
|
+
}, "required", "deleted" | "fingerprint" | "generation" | "indexTransferGeneration" | "indexedCount" | "isContradictory" | "latestIdentityFingerprint" | "latestPayloadId" | "legacy" | "nextIndex" | "operationDigest" | "originalFingerprint" | "originalIdentityFingerprint" | "originalOperationId" | "originalPayloadId" | "producer" | "producerVersion" | "referenceFingerprints" | "sliceCount" | "sourceChargeDigest" | "sourceCreatedAt" | "status">, {
|
|
50
|
+
by_operation_digest: ["operationDigest", "_creationTime"];
|
|
51
|
+
by_original_operation: ["originalOperationId", "_creationTime"];
|
|
52
|
+
by_source_charge_digest: ["sourceChargeDigest", "_creationTime"];
|
|
53
|
+
}, {}, {}>;
|
|
54
|
+
reversalObservationPayloads: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
55
|
+
commissionExposure?: {
|
|
56
|
+
chargeAmount: number;
|
|
57
|
+
disputeId?: string | undefined;
|
|
58
|
+
disputeState?: "lost" | "open" | "won" | undefined;
|
|
59
|
+
finalized: boolean;
|
|
60
|
+
kind: "dispute" | "refund";
|
|
61
|
+
principal: number;
|
|
62
|
+
refundId?: string | undefined;
|
|
63
|
+
refundedPrincipal?: number | undefined;
|
|
64
|
+
} | undefined;
|
|
65
|
+
operationId: string;
|
|
66
|
+
slices: {
|
|
67
|
+
from: number;
|
|
68
|
+
stripeTransferId: string;
|
|
69
|
+
to: number;
|
|
70
|
+
}[];
|
|
71
|
+
sourceChargeId: string;
|
|
72
|
+
}, {
|
|
73
|
+
operationId: import("convex/values").VString<string, "required">;
|
|
74
|
+
sourceChargeId: import("convex/values").VString<string, "required">;
|
|
75
|
+
slices: import("convex/values").VArray<{
|
|
76
|
+
from: number;
|
|
77
|
+
stripeTransferId: string;
|
|
78
|
+
to: number;
|
|
79
|
+
}[], import("convex/values").VObject<{
|
|
80
|
+
from: number;
|
|
81
|
+
stripeTransferId: string;
|
|
82
|
+
to: number;
|
|
83
|
+
}, {
|
|
84
|
+
stripeTransferId: import("convex/values").VString<string, "required">;
|
|
85
|
+
from: import("convex/values").VFloat64<number, "required">;
|
|
86
|
+
to: import("convex/values").VFloat64<number, "required">;
|
|
87
|
+
}, "required", "from" | "stripeTransferId" | "to">, "required">;
|
|
88
|
+
commissionExposure: import("convex/values").VObject<{
|
|
89
|
+
chargeAmount: number;
|
|
90
|
+
disputeId?: string | undefined;
|
|
91
|
+
disputeState?: "lost" | "open" | "won" | undefined;
|
|
92
|
+
finalized: boolean;
|
|
93
|
+
kind: "dispute" | "refund";
|
|
94
|
+
principal: number;
|
|
95
|
+
refundId?: string | undefined;
|
|
96
|
+
refundedPrincipal?: number | undefined;
|
|
97
|
+
} | undefined, {
|
|
98
|
+
kind: import("convex/values").VUnion<"dispute" | "refund", [import("convex/values").VLiteral<"refund", "required">, import("convex/values").VLiteral<"dispute", "required">], "required", never>;
|
|
99
|
+
chargeAmount: import("convex/values").VFloat64<number, "required">;
|
|
100
|
+
principal: import("convex/values").VFloat64<number, "required">;
|
|
101
|
+
finalized: import("convex/values").VBoolean<boolean, "required">;
|
|
102
|
+
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>;
|
|
103
|
+
disputeId: import("convex/values").VString<string | undefined, "optional">;
|
|
104
|
+
refundedPrincipal: import("convex/values").VFloat64<number | undefined, "optional">;
|
|
105
|
+
refundId: import("convex/values").VString<string | undefined, "optional">;
|
|
106
|
+
}, "optional", "chargeAmount" | "disputeId" | "disputeState" | "finalized" | "kind" | "principal" | "refundId" | "refundedPrincipal">;
|
|
107
|
+
}, "required", "commissionExposure" | "commissionExposure.chargeAmount" | "commissionExposure.disputeId" | "commissionExposure.disputeState" | "commissionExposure.finalized" | "commissionExposure.kind" | "commissionExposure.principal" | "commissionExposure.refundId" | "commissionExposure.refundedPrincipal" | "operationId" | "slices" | "sourceChargeId">, {}, {}, {}>;
|
|
108
|
+
reversalObservationRefs: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
109
|
+
chunkIndex: number;
|
|
110
|
+
observationId: import("convex/values").GenericId<"reversalObservations">;
|
|
111
|
+
refs: ({
|
|
112
|
+
ambiguous: boolean;
|
|
113
|
+
bucketDigest: string;
|
|
114
|
+
identityFingerprint: string;
|
|
115
|
+
markerGeneration?: number | undefined;
|
|
116
|
+
markerId?: import("convex/values").GenericId<"financialTransferObservations"> | undefined;
|
|
117
|
+
markerIdentityFingerprint?: string | undefined;
|
|
118
|
+
ownerDigest?: string | undefined;
|
|
119
|
+
ownershipFingerprint?: string | undefined;
|
|
120
|
+
registrationId?: import("convex/values").GenericId<"financialOwnership"> | undefined;
|
|
121
|
+
transferId: import("convex/values").GenericId<"transfers">;
|
|
122
|
+
} | null)[];
|
|
123
|
+
}, {
|
|
124
|
+
observationId: import("convex/values").VId<import("convex/values").GenericId<"reversalObservations">, "required">;
|
|
125
|
+
chunkIndex: import("convex/values").VFloat64<number, "required">;
|
|
126
|
+
refs: import("convex/values").VArray<({
|
|
127
|
+
ambiguous: boolean;
|
|
128
|
+
bucketDigest: string;
|
|
129
|
+
identityFingerprint: string;
|
|
130
|
+
markerGeneration?: number | undefined;
|
|
131
|
+
markerId?: import("convex/values").GenericId<"financialTransferObservations"> | undefined;
|
|
132
|
+
markerIdentityFingerprint?: string | undefined;
|
|
133
|
+
ownerDigest?: string | undefined;
|
|
134
|
+
ownershipFingerprint?: string | undefined;
|
|
135
|
+
registrationId?: import("convex/values").GenericId<"financialOwnership"> | undefined;
|
|
136
|
+
transferId: import("convex/values").GenericId<"transfers">;
|
|
137
|
+
} | null)[], import("convex/values").VUnion<{
|
|
138
|
+
ambiguous: boolean;
|
|
139
|
+
bucketDigest: string;
|
|
140
|
+
identityFingerprint: string;
|
|
141
|
+
markerGeneration?: number | undefined;
|
|
142
|
+
markerId?: import("convex/values").GenericId<"financialTransferObservations"> | undefined;
|
|
143
|
+
markerIdentityFingerprint?: string | undefined;
|
|
144
|
+
ownerDigest?: string | undefined;
|
|
145
|
+
ownershipFingerprint?: string | undefined;
|
|
146
|
+
registrationId?: import("convex/values").GenericId<"financialOwnership"> | undefined;
|
|
147
|
+
transferId: import("convex/values").GenericId<"transfers">;
|
|
148
|
+
} | null, [import("convex/values").VObject<{
|
|
149
|
+
ambiguous: boolean;
|
|
150
|
+
bucketDigest: string;
|
|
151
|
+
identityFingerprint: string;
|
|
152
|
+
markerGeneration?: number | undefined;
|
|
153
|
+
markerId?: import("convex/values").GenericId<"financialTransferObservations"> | undefined;
|
|
154
|
+
markerIdentityFingerprint?: string | undefined;
|
|
155
|
+
ownerDigest?: string | undefined;
|
|
156
|
+
ownershipFingerprint?: string | undefined;
|
|
157
|
+
registrationId?: import("convex/values").GenericId<"financialOwnership"> | undefined;
|
|
158
|
+
transferId: import("convex/values").GenericId<"transfers">;
|
|
159
|
+
}, {
|
|
160
|
+
transferId: import("convex/values").VId<import("convex/values").GenericId<"transfers">, "required">;
|
|
161
|
+
bucketDigest: import("convex/values").VString<string, "required">;
|
|
162
|
+
ownerDigest: import("convex/values").VString<string | undefined, "optional">;
|
|
163
|
+
identityFingerprint: import("convex/values").VString<string, "required">;
|
|
164
|
+
ambiguous: import("convex/values").VBoolean<boolean, "required">;
|
|
165
|
+
markerId: import("convex/values").VId<import("convex/values").GenericId<"financialTransferObservations"> | undefined, "optional">;
|
|
166
|
+
markerGeneration: import("convex/values").VFloat64<number | undefined, "optional">;
|
|
167
|
+
markerIdentityFingerprint: import("convex/values").VString<string | undefined, "optional">;
|
|
168
|
+
ownershipFingerprint: import("convex/values").VString<string | undefined, "optional">;
|
|
169
|
+
registrationId: import("convex/values").VId<import("convex/values").GenericId<"financialOwnership"> | undefined, "optional">;
|
|
170
|
+
}, "required", "ambiguous" | "bucketDigest" | "identityFingerprint" | "markerGeneration" | "markerId" | "markerIdentityFingerprint" | "ownerDigest" | "ownershipFingerprint" | "registrationId" | "transferId">, import("convex/values").VNull<null, "required">], "required", "ambiguous" | "bucketDigest" | "identityFingerprint" | "markerGeneration" | "markerId" | "markerIdentityFingerprint" | "ownerDigest" | "ownershipFingerprint" | "registrationId" | "transferId">, "required">;
|
|
171
|
+
}, "required", "chunkIndex" | "observationId" | "refs">, {
|
|
172
|
+
by_observation_chunk: ["observationId", "chunkIndex", "_creationTime"];
|
|
173
|
+
}, {}, {}>;
|
|
174
|
+
reversalObservationSlices: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
175
|
+
bucketDigest?: string | undefined;
|
|
176
|
+
bucketKey?: string | undefined;
|
|
177
|
+
generation: number;
|
|
178
|
+
identityStatus: "contradictory" | "matched" | "unknown";
|
|
179
|
+
observationId: import("convex/values").GenericId<"reversalObservations">;
|
|
180
|
+
orgId?: string | undefined;
|
|
181
|
+
originalOperationId: import("convex/values").GenericId<"transferReversalOps">;
|
|
182
|
+
ownerDigest?: string | undefined;
|
|
183
|
+
ownershipStatus: "ambiguous" | "contradictory" | "registered" | "unknown";
|
|
184
|
+
registrationId?: import("convex/values").GenericId<"financialOwnership"> | undefined;
|
|
185
|
+
sliceIndex: number;
|
|
186
|
+
transferGeneration: number | null;
|
|
187
|
+
transferId?: import("convex/values").GenericId<"transfers"> | undefined;
|
|
188
|
+
userId?: string | undefined;
|
|
189
|
+
}, {
|
|
190
|
+
originalOperationId: import("convex/values").VId<import("convex/values").GenericId<"transferReversalOps">, "required">;
|
|
191
|
+
observationId: import("convex/values").VId<import("convex/values").GenericId<"reversalObservations">, "required">;
|
|
192
|
+
sliceIndex: import("convex/values").VFloat64<number, "required">;
|
|
193
|
+
generation: import("convex/values").VFloat64<number, "required">;
|
|
194
|
+
bucketDigest: import("convex/values").VString<string | undefined, "optional">;
|
|
195
|
+
ownerDigest: import("convex/values").VString<string | undefined, "optional">;
|
|
196
|
+
transferId: import("convex/values").VId<import("convex/values").GenericId<"transfers"> | undefined, "optional">;
|
|
197
|
+
bucketKey: import("convex/values").VString<string | undefined, "optional">;
|
|
198
|
+
registrationId: import("convex/values").VId<import("convex/values").GenericId<"financialOwnership"> | undefined, "optional">;
|
|
199
|
+
userId: import("convex/values").VString<string | undefined, "optional">;
|
|
200
|
+
orgId: import("convex/values").VString<string | undefined, "optional">;
|
|
201
|
+
ownershipStatus: import("convex/values").VUnion<"ambiguous" | "contradictory" | "registered" | "unknown", [import("convex/values").VLiteral<"registered", "required">, import("convex/values").VLiteral<"unknown", "required">, import("convex/values").VLiteral<"ambiguous", "required">, import("convex/values").VLiteral<"contradictory", "required">], "required", never>;
|
|
202
|
+
identityStatus: import("convex/values").VUnion<"contradictory" | "matched" | "unknown", [import("convex/values").VLiteral<"matched", "required">, import("convex/values").VLiteral<"unknown", "required">, import("convex/values").VLiteral<"contradictory", "required">], "required", never>;
|
|
203
|
+
transferGeneration: import("convex/values").VUnion<number | null, [import("convex/values").VFloat64<number, "required">, import("convex/values").VNull<null, "required">], "required", never>;
|
|
204
|
+
}, "required", "bucketDigest" | "bucketKey" | "generation" | "identityStatus" | "observationId" | "orgId" | "originalOperationId" | "ownerDigest" | "ownershipStatus" | "registrationId" | "sliceIndex" | "transferGeneration" | "transferId" | "userId">, {
|
|
205
|
+
by_bucket: ["bucketDigest", "_creationTime"];
|
|
206
|
+
by_observation_slice: ["observationId", "sliceIndex", "_creationTime"];
|
|
207
|
+
by_owner: ["ownerDigest", "_creationTime"];
|
|
208
|
+
}, {}, {}>;
|
|
209
|
+
payoutRevisionJournal: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
210
|
+
accountId: string;
|
|
211
|
+
fenceStream: boolean;
|
|
212
|
+
financialPresent: boolean;
|
|
213
|
+
financialRiskRevision: number;
|
|
214
|
+
kind: "baseline" | "bump";
|
|
215
|
+
legacyFinancialId?: import("convex/values").GenericId<"payoutFinancialRevisions"> | undefined;
|
|
216
|
+
legacyRiskId?: import("convex/values").GenericId<"payoutRiskRevisions"> | undefined;
|
|
217
|
+
revision: number;
|
|
218
|
+
riskRevision: number;
|
|
219
|
+
}, {
|
|
220
|
+
accountId: import("convex/values").VString<string, "required">;
|
|
221
|
+
revision: import("convex/values").VFloat64<number, "required">;
|
|
222
|
+
riskRevision: import("convex/values").VFloat64<number, "required">;
|
|
223
|
+
financialRiskRevision: import("convex/values").VFloat64<number, "required">;
|
|
224
|
+
financialPresent: import("convex/values").VBoolean<boolean, "required">;
|
|
225
|
+
fenceStream: import("convex/values").VBoolean<boolean, "required">;
|
|
226
|
+
kind: import("convex/values").VUnion<"baseline" | "bump", [import("convex/values").VLiteral<"baseline", "required">, import("convex/values").VLiteral<"bump", "required">], "required", never>;
|
|
227
|
+
legacyFinancialId: import("convex/values").VId<import("convex/values").GenericId<"payoutFinancialRevisions"> | undefined, "optional">;
|
|
228
|
+
legacyRiskId: import("convex/values").VId<import("convex/values").GenericId<"payoutRiskRevisions"> | undefined, "optional">;
|
|
229
|
+
}, "required", "accountId" | "fenceStream" | "financialPresent" | "financialRiskRevision" | "kind" | "legacyFinancialId" | "legacyRiskId" | "revision" | "riskRevision">, {
|
|
230
|
+
by_account_fence_revision: ["accountId", "fenceStream", "revision", "_creationTime"];
|
|
231
|
+
by_account_revision: ["accountId", "revision", "_creationTime"];
|
|
232
|
+
}, {}, {}>;
|
|
233
|
+
payoutRevisionMigrations: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
234
|
+
activated: number;
|
|
235
|
+
cursor: string | null;
|
|
236
|
+
held: number;
|
|
237
|
+
operationKey: string;
|
|
238
|
+
phase: number;
|
|
239
|
+
scanned: number;
|
|
240
|
+
status: "finished" | "running";
|
|
241
|
+
step: number;
|
|
242
|
+
unchanged: number;
|
|
243
|
+
visited: number;
|
|
244
|
+
}, {
|
|
245
|
+
operationKey: import("convex/values").VString<string, "required">;
|
|
246
|
+
phase: import("convex/values").VFloat64<number, "required">;
|
|
247
|
+
cursor: import("convex/values").VUnion<string | null, [import("convex/values").VString<string, "required">, import("convex/values").VNull<null, "required">], "required", never>;
|
|
248
|
+
step: import("convex/values").VFloat64<number, "required">;
|
|
249
|
+
status: import("convex/values").VUnion<"finished" | "running", [import("convex/values").VLiteral<"running", "required">, import("convex/values").VLiteral<"finished", "required">], "required", never>;
|
|
250
|
+
scanned: import("convex/values").VFloat64<number, "required">;
|
|
251
|
+
visited: import("convex/values").VFloat64<number, "required">;
|
|
252
|
+
activated: import("convex/values").VFloat64<number, "required">;
|
|
253
|
+
unchanged: import("convex/values").VFloat64<number, "required">;
|
|
254
|
+
held: import("convex/values").VFloat64<number, "required">;
|
|
255
|
+
}, "required", "activated" | "cursor" | "held" | "operationKey" | "phase" | "scanned" | "status" | "step" | "unchanged" | "visited">, {
|
|
256
|
+
by_operation: ["operationKey", "_creationTime"];
|
|
257
|
+
}, {}, {}>;
|
|
258
|
+
payoutRevisionMigrationResults: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
259
|
+
accountDigest: string;
|
|
260
|
+
accountId?: string | undefined;
|
|
261
|
+
jobId: import("convex/values").GenericId<"payoutRevisionMigrations">;
|
|
262
|
+
reason?: "legacy_ambiguous" | "legacy_disagreement" | "legacy_invalid" | "representation_unavailable" | undefined;
|
|
263
|
+
sourceId: string;
|
|
264
|
+
sourceTable: string;
|
|
265
|
+
status: "activated" | "held" | "unchanged";
|
|
266
|
+
}, {
|
|
267
|
+
status: import("convex/values").VUnion<"activated" | "held" | "unchanged", [import("convex/values").VLiteral<"activated", "required">, import("convex/values").VLiteral<"unchanged", "required">, import("convex/values").VLiteral<"held", "required">], "required", never>;
|
|
268
|
+
reason: import("convex/values").VUnion<"legacy_ambiguous" | "legacy_disagreement" | "legacy_invalid" | "representation_unavailable" | undefined, [import("convex/values").VLiteral<"legacy_ambiguous", "required">, import("convex/values").VLiteral<"legacy_invalid", "required">, import("convex/values").VLiteral<"legacy_disagreement", "required">, import("convex/values").VLiteral<"representation_unavailable", "required">], "optional", never>;
|
|
269
|
+
jobId: import("convex/values").VId<import("convex/values").GenericId<"payoutRevisionMigrations">, "required">;
|
|
270
|
+
accountId: import("convex/values").VString<string | undefined, "optional">;
|
|
271
|
+
accountDigest: import("convex/values").VString<string, "required">;
|
|
272
|
+
sourceId: import("convex/values").VString<string, "required">;
|
|
273
|
+
sourceTable: import("convex/values").VString<string, "required">;
|
|
274
|
+
}, "required", "accountDigest" | "accountId" | "jobId" | "reason" | "sourceId" | "sourceTable" | "status">, {
|
|
275
|
+
by_job_account: ["jobId", "accountDigest", "_creationTime"];
|
|
276
|
+
}, {}, {}>;
|
|
3
277
|
usageCorrectionClaims: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
4
278
|
key: string;
|
|
5
279
|
operationKey: string;
|
|
@@ -2118,6 +2392,7 @@ export declare function setupCredits(): Promise<{
|
|
|
2118
2392
|
}, "required", "bucketKey" | "fingerprint" | "generation" | "isContradictory" | "observedFingerprint" | "orgId" | "ownershipFingerprint" | "ownershipStatus" | "producer" | "producerVersion" | "registrationId" | "role" | "sourceChargeId" | "sourceInvoiceId" | "stripeTransferId" | "transferId" | "userId">, {
|
|
2119
2393
|
by_bucket_key: ["bucketKey", "_creationTime"];
|
|
2120
2394
|
by_owner: ["userId", "orgId", "_creationTime"];
|
|
2395
|
+
by_source_charge_id: ["sourceChargeId", "_creationTime"];
|
|
2121
2396
|
by_transfer_id: ["transferId", "_creationTime"];
|
|
2122
2397
|
}, {}, {}>;
|
|
2123
2398
|
financialTransferBatches: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"accounting.fixtures.d.ts","sourceRoot":"","sources":["../../../src/component/usageCredits/accounting.fixtures.ts"],"names":[],"mappings":"AAgBA,wBAAsB,YAAY
|
|
1
|
+
{"version":3,"file":"accounting.fixtures.d.ts","sourceRoot":"","sources":["../../../src/component/usageCredits/accounting.fixtures.ts"],"names":[],"mappings":"AAgBA,wBAAsB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAS1B,GAAG,EAAE,OAAO;yBACZ,OAAO,EAAE,IAAI;yBACb,KAAK,EAAE,SAAS;yBAChB,IAAI;6BAAI,IAAI,EAAE,MAAM;6BAAE,SAAS,EAAE,CAAC;;yBAClC,IAAI;6BAAI,QAAQ,EAAE,KAAK;6BAAE,iBAAiB,EAAE,GAAG;;yBAC/C,mBAAmB,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuDvB,KAAK;YAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAU5B"}
|
|
@@ -1,25 +1,4 @@
|
|
|
1
|
-
import type {
|
|
2
|
-
|
|
3
|
-
import type { UsageAggregateObservation } from "../../client/usage/observationTypes.js";
|
|
4
|
-
import type { UsageAllowanceStatus } from "../../client/usage/allowanceTerms.js";
|
|
5
|
-
import type { UsageCreditBalance, UsageCreditPurchase } from "../../client/usage/creditTerms.js";
|
|
6
|
-
import type { UsageCreditReconciliation } from "../../client/usage/creditObservation.js";
|
|
7
|
-
/** Cache identity only. The authenticated host must resolve and authorize original native bindings. */
|
|
8
|
-
export type UsageViewScope = {
|
|
9
|
-
identityKey: string;
|
|
10
|
-
accountKey: string;
|
|
11
|
-
/** Include original plan/price version in this opaque host meter key. */
|
|
12
|
-
meterKey: string;
|
|
13
|
-
period: UsagePeriod;
|
|
14
|
-
currency: string;
|
|
15
|
-
};
|
|
16
|
-
export type UsageBillingSnapshot = {
|
|
17
|
-
summary: UsageAvailability<UsageLocalSummary>;
|
|
18
|
-
provider?: UsageAggregateObservation;
|
|
19
|
-
allowance?: UsageAvailability<UsageAllowanceStatus | null>;
|
|
20
|
-
credits?: UsageAvailability<UsageCreditBalance>;
|
|
21
|
-
purchase?: UsageCreditPurchase | null;
|
|
22
|
-
creditApplication?: UsageAvailability<UsageCreditReconciliation>;
|
|
23
|
-
};
|
|
1
|
+
import type { UsageViewScope } from "../../client/usage/views.js";
|
|
2
|
+
export type { UsageViewScope, UsageBillingSnapshot, } from "../../client/usage/views.js";
|
|
24
3
|
export declare function usageViewKey(scope: UsageViewScope): string;
|
|
25
4
|
//# sourceMappingURL=Usage.types.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Usage.types.d.ts","sourceRoot":"","sources":["../../../src/react/workflows/Usage.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,
|
|
1
|
+
{"version":3,"file":"Usage.types.d.ts","sourceRoot":"","sources":["../../../src/react/workflows/Usage.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,YAAY,EACV,cAAc,EACd,oBAAoB,GACrB,MAAM,6BAA6B,CAAC;AACrC,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,UASjD"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Usage.types.js","sourceRoot":"","sources":["../../../src/react/workflows/Usage.types.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"Usage.types.js","sourceRoot":"","sources":["../../../src/react/workflows/Usage.types.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,YAAY,CAAC,KAAqB;IAChD,OAAO,IAAI,CAAC,SAAS,CAAC;QACpB,KAAK,CAAC,WAAW;QACjB,KAAK,CAAC,UAAU;QAChB,KAAK,CAAC,QAAQ;QACd,KAAK,CAAC,MAAM,CAAC,KAAK;QAClB,KAAK,CAAC,MAAM,CAAC,GAAG;QAChB,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE;KAC7B,CAAC,CAAC;AACL,CAAC"}
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
import type { ReactNode } from "react";
|
|
2
|
-
import type {
|
|
2
|
+
import type { UsageConfigurationValue } from "../../client/usage/configuration.js";
|
|
3
|
+
export type { UsageConfigurationValue } from "../../client/usage/configuration.js";
|
|
4
|
+
import type { UsageBillingModel } from "../../client/usage/contracts.js";
|
|
3
5
|
/** Display/cache context from an authenticated host. Never use this as server authorization. */
|
|
4
6
|
export type UsageConfigurationScope = {
|
|
5
7
|
identityKey: string;
|
|
@@ -11,16 +13,6 @@ export type UsageConfigurationScope = {
|
|
|
11
13
|
/** Host has verified the configured issuer realm and supported native catalog. */
|
|
12
14
|
capability: "issuer_native" | "unsupported";
|
|
13
15
|
};
|
|
14
|
-
export type UsageConfigurationValue = {
|
|
15
|
-
plan: UsagePlan;
|
|
16
|
-
eventName: string;
|
|
17
|
-
displayName: string;
|
|
18
|
-
meterId?: string;
|
|
19
|
-
creditPackage?: {
|
|
20
|
-
quantity: string;
|
|
21
|
-
topUp: "manual";
|
|
22
|
-
};
|
|
23
|
-
};
|
|
24
16
|
export type UsageMeterChoice = {
|
|
25
17
|
id: string;
|
|
26
18
|
active: boolean;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"UsageConfiguration.types.d.ts","sourceRoot":"","sources":["../../../src/react/workflows/UsageConfiguration.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,
|
|
1
|
+
{"version":3,"file":"UsageConfiguration.types.d.ts","sourceRoot":"","sources":["../../../src/react/workflows/UsageConfiguration.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,YAAY,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,gGAAgG;AAChG,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,kFAAkF;IAClF,UAAU,EAAE,eAAe,GAAG,aAAa,CAAC;CAC7C,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,aAAa,EAAE,uBAAuB,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,iBAAiB,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,uBAAuB,CAAC;IAC/B,OAAO,EAAE,uBAAuB,CAAC;IACjC,gGAAgG;IAChG,MAAM,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACpC,8FAA8F;IAC9F,MAAM,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,SAAS,CAAC;CAC1D,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,wBAAwB,CAAC;IACjC,QAAQ,EAAE,CAAC,CAAC,SAAS,MAAM,wBAAwB,EACjD,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,wBAAwB,CAAC,CAAC,CAAC,KAC/B,IAAI,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9B,CAAC"}
|
package/docs/README.md
CHANGED
|
@@ -34,7 +34,8 @@ guide for your integration.
|
|
|
34
34
|
- [Refund context](refund-context.md) and [refund command evidence](refund-command-evidence.md).
|
|
35
35
|
- [Processing cost reconciliation](processing-cost-reconciliation.md).
|
|
36
36
|
- [Personal account mapping](personal-account-mapping.md).
|
|
37
|
-
- [Financial ownership](financial-ownership.md) and [financial observations](financial-observations.md).
|
|
37
|
+
- [Financial ownership](financial-ownership.md) and [financial observations](financial-observations.md), including claimed reversal history.
|
|
38
|
+
- [Payout revision migration](payout-revision-migration.md), explicit bounded activation before large reversal operations.
|
|
38
39
|
- [Example recovery cutover](example-recovery-cutover.md).
|
|
39
40
|
|
|
40
41
|
## Architecture and contributing
|
|
@@ -80,3 +81,5 @@ Start with the [native Stripe setup guide](metering-setup.md), then read the
|
|
|
80
81
|
- [Reusable metered billing UI](usage-react.md) covers all three models, render props, authenticated adapters and bounded history.
|
|
81
82
|
|
|
82
83
|
- [Native usage configuration UI](usage-configuration.md) covers reusable forms, managed meter selection, price rows and authorized adapters.
|
|
84
|
+
|
|
85
|
+
- [Native metered billing example](usage-example.md), three runnable models, paid evidence and scoped cleanup.
|
package/docs/client-api.md
CHANGED
|
@@ -584,3 +584,9 @@ This does not establish customer-only preview eligibility for another account.
|
|
|
584
584
|
See the [sandbox setup findings](accounts-v2-preview.md#connect-sandbox-setup-findings-2026-10-15),
|
|
585
585
|
[authentication and reuse results](react-workflows.md#live-authentication-and-reuse-results-2026-10-15),
|
|
586
586
|
and [uploaded screenshots and provider records](https://github.com/FantasticDevHQ/better-stripe/pull/166#issuecomment-6185124292).
|
|
587
|
+
|
|
588
|
+
## Reversal history and revision maintenance
|
|
589
|
+
|
|
590
|
+
`stripe.reversalObservations` reads original claimed-slice history and maintains a bounded diagnostic index. Its physical operation references survive release/deletion and distinguish reuse of a business operation ID. Exact bucket/owner pages, original/latest payloads and generation-aware continuation remain unknown coverage. These methods do not execute reversals, certify current ownership or authorize closure. See [financial observations](financial-observations.md#claimed-reversal-history).
|
|
591
|
+
|
|
592
|
+
`stripe.payoutRevisionMigration` exposes trusted-host `activateAccount`, `begin`, `resume`, `get` and `results`. Existing destinations keep legacy revision authority until explicitly activated. Activation and inventory are bounded storage maintenance, with held outcomes for ambiguous or unrepresentable legacy authority. Installing the package does not run a migration. See the [migration guide](payout-revision-migration.md) before relying on the tested large-operation path or changing component versions.
|
|
@@ -102,9 +102,12 @@ Native checks preserve the previously supported 1,000-transfer claim across four
|
|
|
102
102
|
shared destination buckets, with registered personal/organization and unknown
|
|
103
103
|
ownership, and the 100-transfer synchronous boundary. Historical public claims
|
|
104
104
|
with 1,001 transfers can still be released without per-row observation work.
|
|
105
|
-
The
|
|
106
|
-
1,000 distinct destinations
|
|
107
|
-
|
|
105
|
+
The published 0.50.1 baseline separately exceeds native read limits for a claim
|
|
106
|
+
with 1,000 distinct destinations. The explicitly activated payout revision
|
|
107
|
+
journal now preserves that shape in the tested native fixture. See the
|
|
108
|
+
[payout revision migration](./payout-revision-migration.md) for its operational
|
|
109
|
+
precondition and aggregate-limit caveats. Transfer observations alone do not
|
|
110
|
+
provide that capacity.
|
|
108
111
|
|
|
109
112
|
Observations rely on package-owned append/patch writers and their transactional
|
|
110
113
|
generation changes. They do not certify arbitrary privileged database edits,
|
|
@@ -237,8 +240,48 @@ a final patch; zero-count deletion and malformed-summary errors remain required.
|
|
|
237
240
|
Moved buckets, unrecorded transfers, payout summaries and financial/risk callbacks
|
|
238
241
|
retain their existing behavior.
|
|
239
242
|
|
|
240
|
-
This
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
243
|
+
This private derived-summary optimization alone does not resolve the
|
|
244
|
+
1,000-distinct-destination read limit. The separately activated
|
|
245
|
+
[payout revision journal](./payout-revision-migration.md) supplies the tested
|
|
246
|
+
large-operation path. Neither optimization grants complete observation coverage
|
|
247
|
+
or changes financial admission or money calculations.
|
|
248
|
+
|
|
249
|
+
## Claimed reversal slice history
|
|
250
|
+
|
|
251
|
+
`stripe.reversalObservations` reports the lifecycle of actual component reversal claims. Claim, exposure replay, frontier updates, release and deletion capture diagnostic history in the same transaction as the existing financial writer, including direct calls to the registered handler. The writer keeps its existing slice arithmetic, financial selectors, rollback and provider behavior.
|
|
252
|
+
|
|
253
|
+
History is keyed by the **original operation document ID**, not its reusable business `operationId`. A released operation retains a tombstone. Reusing the business ID creates a separate history entry. Exact original and latest operation bodies live in separate payload records, with full and identity fingerprints checked before returning or indexing their contents. The original body, transfer references and owner evidence are immutable across exposure updates and deletion.
|
|
254
|
+
|
|
255
|
+
```ts
|
|
256
|
+
const history = await stripe.reversalObservations.history(ctx, {
|
|
257
|
+
selector: "sourceChargeId", // or "operationId" for the business identifier
|
|
258
|
+
value: chargeId,
|
|
259
|
+
paginationOpts: { numItems: 25, cursor: null },
|
|
260
|
+
});
|
|
261
|
+
const originalOperationId = history.page[0].originalOperationId;
|
|
262
|
+
let observed = await stripe.reversalObservations.operation(ctx, {
|
|
263
|
+
operationId: originalOperationId,
|
|
264
|
+
});
|
|
265
|
+
// Schedule separate bounded host mutations until complete or held.
|
|
266
|
+
observed = await stripe.reversalObservations.resume(ctx, {
|
|
267
|
+
operationId: originalOperationId,
|
|
268
|
+
expectedGeneration: observed.observation!.generation,
|
|
269
|
+
batchSize: 10, // 1–20 original positions per transaction
|
|
270
|
+
});
|
|
271
|
+
const slices = await stripe.reversalObservations.slices(ctx, {
|
|
272
|
+
operationId: originalOperationId,
|
|
273
|
+
paginationOpts: { numItems: 25, cursor: null },
|
|
274
|
+
});
|
|
275
|
+
```
|
|
276
|
+
|
|
277
|
+
`bucket` discovers original destination references using an exact bucket selector. `owner` accepts `userId` and optional `orgId` for historical owner evidence. Both use bounded component-compatible pagination. Each slice includes `originalOperationId`, so a hit can be opened with `operation` and `payload`. `payload` accepts `version: "original" | "latest"`.
|
|
278
|
+
|
|
279
|
+
All original slice positions are retained, including empty operations without invented recipients. Compact, chunked references retain original transfer document IDs and identity digests. Destination digests keep the original bucket discoverable if its transfer later disappears. A single byte-bounded marker page may capture existing owner evidence atomically. Missing, omitted, contradictory or ambiguous original pins remain unknown. A later registration never retroactively fills an originally unpinned owner.
|
|
280
|
+
|
|
281
|
+
Continuation checks the exact original transfer, global transfer and marker correspondence, captured owner evidence and immutable registration. Missing or changed sources remain `unknown` or `contradictory`; they do not get reassigned to replacements. Legacy operations first observed on replay or release have no invented claim-time provenance and stay held. No public backfill declares historical coverage complete.
|
|
282
|
+
|
|
283
|
+
Bucket and owner discovery use digests and fixed source/registration references. Literal bucket, user and organization labels are included only when each fits within 256 UTF-8 bytes, avoiding oversized diagnostic documents. A digest is a lookup aid, never proof of authorization. Resolve original references through the trusted host and treat missing sources conservatively.
|
|
284
|
+
|
|
285
|
+
The bounded indexer writes each exact slice slot, then validates its prefix in a second traversal. Each original reference chunk is checked against its immutable header digest before use, including when the original transfer is missing. `expectedGeneration` fences the source lifecycle version; it is not a per-step acknowledgement. Repeating a successful `resume` call may advance another bounded batch of diagnostic work. No money operation is performed or duplicated. Read headroom may reduce the actual batch size; invoke steps in fresh dedicated host transactions rather than an unbounded loop inside one transaction. Exposure changes and deletion advance the operation generation and restart enrichment over the same immutable references. A slice's `generation` is the operation generation when it was indexed. Fetch its owning operation to compare the current generation and indexing status; intermediate pages may contain older-generation slots. Global diagnostic `generation` and `transferGeneration` also expose later transfer facts without pretending a cached slice is the latest receipt. `complete` describes this historical index traversal, not current ownership, current liabilities, financial closure or producer coverage.
|
|
286
|
+
|
|
287
|
+
Every result remains `coverage: "unknown"`, including completed and exhausted pages. These methods are trusted-host diagnostics. They grant no provider permission, payout eligibility, reversal admission or attempt fencing, and do not replace receipt reconciliation. No Stripe API request is made by the readers or indexer.
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
# Payout revision journal migration
|
|
2
|
+
|
|
3
|
+
BetterStripe can move an account's internal financial and risk revision counters to an append-only journal. This is a storage migration, not a payment, transfer, payout, reconciliation result, or financial coverage certificate. It makes the latest account revision a single indexed read while retaining a separate risk-only read range. Ordinary positive funding does not change that risk range.
|
|
4
|
+
|
|
5
|
+
Existing accounts keep using the legacy counters until explicitly activated. Financial writes do not silently migrate an account. Activate every destination before an operation that relies on the journal's lower read cost, including new destinations added after an inventory pass. Native read and byte limits still apply. A completed migration does not independently guarantee that an operation fits those limits.
|
|
6
|
+
|
|
7
|
+
## Trusted host API
|
|
8
|
+
|
|
9
|
+
Authorize these methods in your server application. Do not expose unrestricted migration endpoints to customers. No Stripe API key or provider request is needed.
|
|
10
|
+
|
|
11
|
+
```ts
|
|
12
|
+
// Smallest primitive, useful when provisioning a new destination.
|
|
13
|
+
const result = await betterStripe.payoutRevisionMigration.activateAccount(ctx, {
|
|
14
|
+
accountId: destinationAccountId,
|
|
15
|
+
});
|
|
16
|
+
// result.status is activated, unchanged, or held.
|
|
17
|
+
|
|
18
|
+
// A server-owned inventory pass over the existing component data.
|
|
19
|
+
let job = await betterStripe.payoutRevisionMigration.begin(ctx, {
|
|
20
|
+
operationKey: "revision-layout-rollout-1",
|
|
21
|
+
});
|
|
22
|
+
// Schedule each step as a separate durable host mutation.
|
|
23
|
+
// Do not execute an unbounded loop inside one Convex transaction.
|
|
24
|
+
job = await betterStripe.payoutRevisionMigration.resume(ctx, {
|
|
25
|
+
jobId: job._id,
|
|
26
|
+
expectedStep: job.step,
|
|
27
|
+
});
|
|
28
|
+
```
|
|
29
|
+
|
|
30
|
+
Each resume reads at most one inventory row and activates at most one account in the same transaction. The component owns the cursor and inventory phase. A repeated stale step returns the current job without processing another row; a future or invalid step fails. Repeating `begin` with the same operation key returns the existing pass. Use a new key for a new pass.
|
|
31
|
+
|
|
32
|
+
The inventory covers both legacy revision tables and accounts in transfers, payouts, recovery balances, payout source allocations, payout release claims, and payout fee balances. Per-pass account digests prevent duplicate counts. Result rows retain the source table and original document ID. They include the account key only when it fits within 256 UTF-8 bytes; larger keys remain in their original source record rather than being duplicated into a potentially oversized diagnostic row. `get` reads the job; `results` pages account outcomes with normal Convex pagination options, bounded to 100 rows and a private byte budget.
|
|
33
|
+
|
|
34
|
+
A finished pass only means its server-owned cursors exhausted the inventory they saw. Records can be added during or after a pass. Re-run inventory and explicitly activate new destinations as part of provisioning. A finished pass and an exhausted results page grant no payout eligibility, closure, attempt admission, or complete financial history.
|
|
35
|
+
|
|
36
|
+
## Held accounts and compatibility
|
|
37
|
+
|
|
38
|
+
Activation preserves the exact legacy row IDs, timestamps, counters, and source records. It inserts a baseline without incrementing counters or creating risk events. Financial-only, risk-only, absent, signed, and safe maximum counters retain their existing reader semantics. Existing financial callbacks append actual bumps and continue to write the same risk events. The old counters become frozen historical evidence for activated accounts.
|
|
39
|
+
|
|
40
|
+
Duplicate legacy authorities, disagreeing counters, unsafe numeric values, and representations that cannot safely fit a baseline return `held`. Such accounts remain on the existing path. The migration does not repair, normalize, merge, or discard those records. Malformed canonical journal authority aborts the step atomically instead of returning `held`. Inspect outcomes and arrange a separate reviewed repair; do not count held accounts as activated. Re-run a new pass after a repair.
|
|
41
|
+
|
|
42
|
+
An old SDK calling a newly deployed component is different from deploying old component writer code. After activation, the legacy counters are no longer current. **Do not roll component code back to legacy-only writers without a separately reviewed restore migration.** Deploying old writers directly would resume from stale counters.
|
|
43
|
+
|
|
44
|
+
## Verification boundary
|
|
45
|
+
|
|
46
|
+
The journal's large-operation capacity must be verified on a native Convex backend with the actual callbacks enabled. JavaScript database mocks do not prove native read limits or OCC behavior. Same-database claim, replay, release, rollback, risk-range isolation, and concurrent activation/source writes are required before claiming the capacity issue fixed. No application deployment is migrated by installing the package.
|
|
47
|
+
|
|
48
|
+
## Native regression results
|
|
49
|
+
|
|
50
|
+
The isolated native regression retained the same SQLite database and 1,000 original transfers across published 0.50.1 and the candidate. The published claim failed the 4,096-read limit with full rollback. After explicit activation of all destinations, claim, matching replay and release succeeded with every original slice and per-currency earnings preserved. Original row IDs, frozen legacy counters and transfer observations remained intact. Claim wrote exactly 1,000 risk events; releasing unused claims advanced financial counters again while preserving risk revision 1.
|
|
51
|
+
|
|
52
|
+
Release used 4,077 of 4,096 reads in that fixture. This narrow margin is evidence for the tested shape, not a promise that arbitrary near-limit documents or extra host work fit. Run large financial operations in dedicated transactions. Do not increase limits, skip callbacks, truncate recipients or count held destinations as activated. The admitted claim limit remains 1,000 transfers. A historical imported operation with 1,001 positive slices also released successfully; its missing original diagnostic provenance remained held and unknown.
|
|
53
|
+
|
|
54
|
+
Native controls also verified 250/500/750 distinct destinations, 1,000 legs sharing four destinations, a complete 8,711-step inventory pass with stale-step replay and paginated outcomes, and actual OCC retries. Ordinary positive funding left the risk-only read range stable. A real risk change retried the reader; activation racing a source write retried against the changed legacy counter. These are local backend checks with synthetic data and zero Stripe requests. They do not replace application authorization, deployment-specific capacity testing or independent release acceptance.
|