@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/_dts/commerce/src/purchase/checkoutCommitPlan.d.ts

@@ -6,7 +6,7 @@ export type CheckoutCommitOrderRecord = Readonly<{
     reconciliationState: OrderCheckoutReconciliationState;
 }>;
 export type CheckoutCommitOrderItemRecord = Readonly<Pick<OrderItemPlanningRecord, 'kind' | 'commitState' | 'reconciliationState' | 'fulfilledAt' | 'cancelledAt' | 'customerMembershipId'>>;
-export type CheckoutCommitPlanStepKind = 'consume_credit_reservation' | 'provision_memberships' | 'fulfill_order_items' | 'redeem_discount' | 'record_order_payment';
+export type CheckoutCommitPlanStepKind = 'consume_credit_reservation' | 'provision_memberships' | 'fulfill_order_items' | 'redeem_discount';
 export type NormalizedOrderCommitItem<TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
     item: TItem;
     commitState: OrderItemCommitState;
@@ -18,23 +18,68 @@ export type NormalizedOrderCommitSnapshot<TOrder extends CheckoutCommitOrderReco
     reconciliationState: OrderCheckoutReconciliationState;
     items: readonly NormalizedOrderCommitItem<TItem>[];
 }>;
-export type CheckoutCommitPlanStep = Readonly<{
-    kind: CheckoutCommitPlanStepKind;
+/** Bypass checkouts take no Stripe session, so nothing provisions memberships from one. */
+export type BypassCheckoutCommitPlanStepKind = Exclude<CheckoutCommitPlanStepKind, 'provision_memberships'>;
+export type CheckoutCommitPlanStep<TStep extends CheckoutCommitPlanStepKind = CheckoutCommitPlanStepKind> = Readonly<{
+    kind: TStep;
 }>;
-export type CheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
-    paymentRail: CheckoutPaymentRail;
+/** A bypass commit never records a payment: there is no cash to record. */
+export type BypassCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
+    paymentRail: Extract<CheckoutPaymentRail, 'bypass'>;
+    normalized: NormalizedOrderCommitSnapshot<TOrder, TItem>;
+    steps: readonly CheckoutCommitPlanStep<BypassCheckoutCommitPlanStepKind>[];
+    paymentRecord: Extract<CheckoutCommitPaymentRecord, 'not_needed'>;
+}>;
+export type StripeCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = Readonly<{
+    paymentRail: Extract<CheckoutPaymentRail, 'stripe'>;
     normalized: NormalizedOrderCommitSnapshot<TOrder, TItem>;
     steps: readonly CheckoutCommitPlanStep[];
+    paymentRecord: CheckoutCommitPaymentRecord;
 }>;
-export declare function normalizeOrderCommitSnapshot<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: {
-    order: TOrder;
-    items: readonly TItem[];
-}): NormalizedOrderCommitSnapshot<TOrder, TItem>;
-export declare function buildCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: {
-    paymentRail: CheckoutPaymentRail;
+export type CheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord = CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord = CheckoutCommitOrderItemRecord> = BypassCheckoutCommitPlan<TOrder, TItem> | StripeCheckoutCommitPlan<TOrder, TItem>;
+type CheckoutCommitPlanInputBase<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord> = Readonly<{
     order: TOrder;
     items: readonly TItem[];
     creditReservationState: ReservationFinalizationState;
     hasDiscountRedemption: boolean;
-    paymentRecorded: boolean;
-}): CheckoutCommitPlan<TOrder, TItem>;
+}>;
+export type BypassCheckoutCommitPlanInput<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord> = CheckoutCommitPlanInputBase<TOrder, TItem> & Readonly<{
+    paymentRail: Extract<CheckoutPaymentRail, 'bypass'>;
+}>;
+export type StripeCheckoutCommitPlanInput<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord> = CheckoutCommitPlanInputBase<TOrder, TItem> & Readonly<{
+    paymentRail: Extract<CheckoutPaymentRail, 'stripe'>;
+    /**
+     * True when the commit has no payment of its own to record: the webhook
+     * recorded the session's receipt before the plan ran, or a subscription
+     * invoice owns the cash (its invoice.paid webhook records it).
+     */
+    paymentOwnedElsewhere: boolean;
+}>;
+/**
+ * Whether the commit records the order's payment once every step has
+ * completed. A Stripe checkout records here only when nothing else owns its
+ * payment (see `paymentOwnedElsewhere`): in practice a zero-total checkout,
+ * whose record completes the order without a cash receipt.
+ */
+export type CheckoutCommitPaymentRecord = 'record_after_steps' | 'not_needed';
+/**
+ * What a checkout commit has done so far that a failure has to undo. The two
+ * facts move independently: a resumed commit can start with fulfillment
+ * already committed and credit still held. `held` also covers a checkout
+ * with no credit reservation, since there is nothing consumed to refund.
+ */
+export type CheckoutCommitProgress = Readonly<{
+    credit: 'held' | 'consumed';
+    fulfillment: Extract<CheckoutCommitState, 'pending' | 'committed'>;
+}>;
+/** Progress before the first step: items an earlier run committed count as fulfilled. */
+export declare function initialCheckoutCommitProgress(normalized: Pick<NormalizedOrderCommitSnapshot, 'items'>): CheckoutCommitProgress;
+/** Progress after `step` completes. */
+export declare function advanceCheckoutCommitProgress(progress: CheckoutCommitProgress, step: CheckoutCommitPlanStepKind): CheckoutCommitProgress;
+export declare function normalizeOrderCommitSnapshot<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: {
+    order: TOrder;
+    items: readonly TItem[];
+}): NormalizedOrderCommitSnapshot<TOrder, TItem>;
+export declare function buildCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: BypassCheckoutCommitPlanInput<TOrder, TItem>): BypassCheckoutCommitPlan<TOrder, TItem>;
+export declare function buildCheckoutCommitPlan<TOrder extends CheckoutCommitOrderRecord, TItem extends CheckoutCommitOrderItemRecord>(input: StripeCheckoutCommitPlanInput<TOrder, TItem>): StripeCheckoutCommitPlan<TOrder, TItem>;
+export {};

package/dist/_dts/commerce/src/purchase/checkoutErrorCodes.d.ts

@@ -1 +1 @@
-export type CheckoutErrorCode = "appointment_not_found" | "appointment_slot_unavailable" | "appointment_payment_terms_not_supported" | "booking_payment_terms_not_supported" | "checkout_amount_below_minimum" | "sliding_amount_required" | "sliding_amount_invalid" | "sliding_amount_below_min" | "sliding_amount_above_max" | "not_found" | "site_mismatch" | "registration_disabled" | "invalid_payment_method" | "payment_already_completed" | "invalid_payment_status" | "no_event_association" | "payment_not_required" | "customer_not_found" | "stripe_not_configured" | "stripe_commission_not_supported" | "stripe_tax_not_ready" | "stripe_tax_status_unavailable" | "whole_series_pricing_option_not_available" | "product_not_available" | "product_not_eligible" | "insufficient_credits" | "invalid_discount_code" | "unsupported_discount_scope" | "checkout_in_progress" | "stripe_error" | "internal_error";
+export type CheckoutErrorCode = "appointment_not_found" | "appointment_slot_unavailable" | "booking_payment_terms_not_supported" | "checkout_amount_below_minimum" | "sliding_amount_required" | "sliding_amount_invalid" | "sliding_amount_below_min" | "sliding_amount_above_max" | "not_found" | "site_mismatch" | "registration_disabled" | "invalid_payment_method" | "payment_already_completed" | "invalid_payment_status" | "no_event_association" | "payment_not_required" | "customer_not_found" | "stripe_not_configured" | "stripe_commission_not_supported" | "stripe_tax_not_ready" | "stripe_tax_status_unavailable" | "whole_series_pricing_option_not_available" | "product_not_available" | "product_not_eligible" | "insufficient_credits" | "invalid_discount_code" | "unsupported_discount_scope" | "checkout_in_progress" | "stripe_error" | "internal_error";

package/dist/_dts/commerce/src/purchase/checkoutPaymentPlanPlanning.d.ts

@@ -1,30 +1,25 @@
-import { type BookingFlexibleBalanceConfig } from '../../../core/src/index';
-export type CheckoutStripeRequiredPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+import { type BookingFlexibleBalanceConfig, type BookingInstalmentPlanConfig } from '../../../core/src/index';
+import type { BookingPaymentSelection } from './bookingPaymentSelection';
+/**
+ * What a paid checkout has to collect, given its payment selection. Paying in
+ * full, having nothing due and not choosing at all are all collected as one
+ * card payment; the free and credit-covered cases bypass before this matters.
+ */
+export type CheckoutPaymentObligation = Readonly<{
     kind: 'stripe';
+}> | Readonly<{
+    kind: 'deferred_manual';
 }> | Readonly<{
     kind: 'instalment_plan';
-    planDefinition: TInstalmentPlan;
+    planDefinition: BookingInstalmentPlanConfig;
 }> | Readonly<{
     kind: 'flexible_balance';
-    config: TFlexibleBalanceConfig;
-    initialPaymentCents: number;
+    config: BookingFlexibleBalanceConfig;
+    configuredPaymentDueNowCents: number;
     bookingStartAt: string;
     dueAt: string;
 }>;
-export type CheckoutStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
-    kind: 'standard';
-}> | Readonly<{
-    kind: 'instalment_plan';
-    planDefinition: TInstalmentPlan;
-}> | Readonly<{
-    kind: 'flexible_balance';
-    selection: Readonly<{
-        config: TFlexibleBalanceConfig;
-        bookingStartAt: string;
-        dueAt: string;
-    }>;
-}>;
-export declare function planStripeRequiredCheckoutPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig>(input: Readonly<{
+export declare function planCheckoutPaymentObligation(input: Readonly<{
     totalAfterDiscountCents: number;
-    paymentTerms?: CheckoutStripeRequiredPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>;
-}>): CheckoutStripeRequiredPaymentObligation<TInstalmentPlan, TFlexibleBalanceConfig>;
+    paymentSelection: BookingPaymentSelection;
+}>): CheckoutPaymentObligation;

package/dist/_dts/commerce/src/purchase/checkoutPaymentTerms.d.ts

@@ -1,53 +1,36 @@
-import { type BookingFlexibleBalanceConfig } from '../../../core/src/index';
-import { type Result } from '../../../core/src/index';
-export type CheckoutPaymentTermCollectionOptionKind = 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
+import { type BookingPaymentCollectionOptionKind, type Result } from '../../../core/src/index';
+import { type BookingPaymentSelection } from './bookingPaymentSelection';
+export type CheckoutPaymentTermCollectionOptionKind = BookingPaymentCollectionOptionKind;
 export type CheckoutPaymentTermsError = Readonly<{
     _tag: 'instalment_plan_not_supported';
 }> | Readonly<{
     _tag: 'flexible_balance_empty_cart';
-}> | Readonly<{
-    _tag: 'flexible_balance_requires_single_item';
 }> | Readonly<{
     _tag: 'flexible_balance_not_supported';
 }>;
-export type CheckoutAppointmentPaymentTermSelection<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
-    kind: 'upfront' | 'deferred_manual';
-}> | Readonly<{
-    kind: 'instalment_plan';
-    plan: TInstalmentPlan;
-}> | Readonly<{
-    kind: 'flexible_balance';
-    config: TFlexibleBalanceConfig;
-}> | null;
-export type CheckoutAttendeeBookingPaymentTermSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
-    kind: 'upfront' | 'deferred_manual';
-}> | Readonly<{
-    kind: 'flexible_balance';
-    config: TFlexibleBalanceConfig;
-}> | null;
-export type CheckoutPaymentTermLine<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
-    kind: 'appointment';
-    bookingStartAt: string;
-    selectedCollectionOption: CheckoutAppointmentPaymentTermSelection<TInstalmentPlan, TFlexibleBalanceConfig>;
-}> | Readonly<{
-    kind: 'attendee_booking';
-    bookingStartAt?: string | null;
-    selectedCollectionOption: CheckoutAttendeeBookingPaymentTermSelection<TFlexibleBalanceConfig>;
+/**
+ * A checkout line as payment terms see it. Bookings carry the selection their
+ * own terms resolved to; products and passes carry none.
+ */
+export type CheckoutPaymentTermLine = Readonly<{
+    kind: 'booking';
+    selection: BookingPaymentSelection;
 }> | Readonly<{
     kind: 'other';
 }>;
-export type CheckoutFlexibleBalanceSelection<TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
-    config: TFlexibleBalanceConfig;
-    bookingStartAt: string;
-    dueAt: string;
-}>;
-export type CheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig> = Readonly<{
-    instalmentPlanDefinition: TInstalmentPlan | null;
-    flexibleBalanceSelection: CheckoutFlexibleBalanceSelection<TFlexibleBalanceConfig> | null;
-}>;
-type CheckoutPaymentTermsInput<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig> = Readonly<{
+type CheckoutPaymentTermsInput = Readonly<{
     requestedCollectionOptionKind?: CheckoutPaymentTermCollectionOptionKind;
-    items: readonly CheckoutPaymentTermLine<TInstalmentPlan, TFlexibleBalanceConfig>[];
+    items: readonly CheckoutPaymentTermLine[];
 }>;
-export declare function resolveCheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig extends BookingFlexibleBalanceConfig = BookingFlexibleBalanceConfig>(input: CheckoutPaymentTermsInput<TInstalmentPlan, TFlexibleBalanceConfig>): Result<CheckoutPaymentTerms<TInstalmentPlan, TFlexibleBalanceConfig>, CheckoutPaymentTermsError>;
+/**
+ * Resolves the one payment selection the whole checkout is paid with.
+ *
+ * A plan or contract only applies when the customer asked for it, and every
+ * line has to belong to the booking it collects for. Without a request the
+ * checkout pays whatever is due in full, even when a line's terms offered only
+ * a plan: that auto-selection stays on the line and isn't applied here.
+ */
+export declare function resolveCheckoutPaymentTerms(input: CheckoutPaymentTermsInput): Result<BookingPaymentSelection, CheckoutPaymentTermsError>;
+/** Checks an already resolved selection without choosing the payment option again. */
+export declare function validateCheckoutPaymentSelection(selection: BookingPaymentSelection, items: readonly CheckoutPaymentTermLine[]): Result<BookingPaymentSelection, CheckoutPaymentTermsError>;
 export {};

package/dist/_dts/commerce/src/purchase/checkoutSessionMetadata.d.ts

@@ -17,7 +17,7 @@ export declare const OrderCheckoutSessionMetadataSchema: z.ZodUnion<readonly [z.
     type: z.ZodLiteral<"order">;
     site_id: z.ZodString;
     order_id: z.ZodOptional<z.ZodString>;
-    customer_email: z.ZodString;
+    customer_email: z.ZodOptional<z.ZodString>;
     customer_name: z.ZodOptional<z.ZodString>;
     product_id: z.ZodOptional<z.ZodString>;
     attendee_id: z.ZodOptional<z.ZodString>;
@@ -48,7 +48,7 @@ export declare const OrderCheckoutSessionMetadataSchema: z.ZodUnion<readonly [z.
     type: z.ZodLiteral<"order">;
     site_id: z.ZodString;
     order_id: z.ZodOptional<z.ZodString>;
-    customer_email: z.ZodString;
+    customer_email: z.ZodOptional<z.ZodString>;
     customer_name: z.ZodOptional<z.ZodString>;
     product_id: z.ZodOptional<z.ZodString>;
     attendee_id: z.ZodOptional<z.ZodString>;

package/dist/_dts/commerce/src/purchase/checkoutStripeSessionPlanning.d.ts

@@ -1,11 +1,12 @@
 import { type Result } from '../../../core/src/index';
 import { type LineSettlementBreakdown } from './settlement';
 export type CheckoutStripeSessionPaymentPlan = Readonly<{
-    kind: 'stripe' | 'instalment_plan';
+    kind: 'stripe';
     creditReservationId?: string | null;
 }> | Readonly<{
-    kind: 'flexible_balance';
-    initialPaymentCents: number;
+    kind: 'instalment_plan' | 'flexible_balance';
+    /** Only this first payment is charged now; the rest is collected later. */
+    chargeNowCents: number;
     creditReservationId?: string | null;
 }>;
 export type CheckoutStripeSessionPaymentIntentPaymentPlan = Readonly<{
@@ -78,7 +79,7 @@ export type CheckoutStripeSessionPlanningError = Readonly<{
     amountCents: number;
     message: string;
 }> | Readonly<{
-    _tag: 'invalid_flexible_balance_initial_payment';
+    _tag: 'invalid_charge_now_amount';
     amountCents: number;
     message: string;
 }>;

package/dist/_dts/commerce/src/purchase/event-registration-errors.d.ts

@@ -48,6 +48,10 @@ export declare const eventRegistrationErrors: {
         readonly message: "The payment options for this event have changed. Please check the latest options before continuing.";
         readonly action: "payment-options";
     };
+    readonly verificationFailed: {
+        readonly message: "We couldn’t confirm this request came from a person. Please refresh the page and try again.";
+        readonly action: "none";
+    };
     readonly idempotencyConflict: {
         readonly message: "You’ve already started booking this event. Please finish in the other tab if it’s still open, or check your booking status before starting again.";
         readonly action: "portal";

package/dist/_dts/commerce/src/purchase/index.d.ts

@@ -3,6 +3,7 @@ export * from './allocation';
 export * from './orderTypes';
 export * from './orderPlanningTypes';
 export * from './bookingInstalmentSchedule';
+export * from './bookingPaymentSelection';
 export * from './cancellationPolicy';
 export * from './checkoutCollectionPlan';
 export * from './checkoutCommitPlan';
@@ -11,14 +12,12 @@ export * from './checkoutErrorCodes';
 export * from './checkoutOrderItemProjection';
 export * from './checkoutPaymentFlow';
 export * from './checkoutPaymentPlanPlanning';
-export * from './checkoutPaymentTermPlanning';
 export * from './checkoutPaymentTerms';
 export * from './checkoutQuantity';
 export * from './checkoutSettlement';
 export * from './checkoutStripeFinalizationPlanning';
 export * from './checkoutStripeSessionPlanning';
 export * from './checkoutSessionMetadata';
-export * from './checkoutValidatedItemPlanning';
 export * from './canonicalRefundPlanner';
 export * from './confirmationEmailPayment';
 export * from './discountApplication';
@@ -34,7 +33,6 @@ export * from './orderHistorySource';
 export * from './orderInstalmentAdminSettlement';
 export * from './orderInstalmentClosure';
 export * from './orderInstalmentLifecycle';
-export * from './orderInstalmentPayoff';
 export * from './orderInstalmentPlan';
 export * from './orderItemMetadata';
 export * from './orderItemSupport';

package/dist/_dts/commerce/src/purchase/membershipOrderItemMetadata.d.ts

@@ -0,0 +1,4 @@
+import { type Result } from '../../../core/src/index';
+import type { StripeBookingCommissionOrderItemMetadata } from './stripeCommissionMetadata';
+import type { CheckoutLineMetadata, MembershipOrderItemMetadata } from './orderItemMetadata';
+export declare function parseMembershipOrderItemMetadata(raw: Record<string, unknown>, checkoutLine: CheckoutLineMetadata, commission: StripeBookingCommissionOrderItemMetadata): Result<MembershipOrderItemMetadata, string>;

package/dist/_dts/commerce/src/purchase/oneTimeCheckoutPlanning.d.ts

@@ -1,10 +1,10 @@
-import { type NonEmptyArray, type Result } from '../../../core/src/index';
+import { type BookingInstalmentPlanConfig, type NonEmptyArray, type Result } from '../../../core/src/index';
 import { type CurrencyCode, type Money } from './settlement';
 import type { CartCheckout } from './types';
 import type { OrderPaymentMethod, OrderStatus } from './orderTypes';
 export type CheckoutPlanningError = {
     _tag: 'CheckoutPlanningError';
-    code: 'empty_cart';
+    code: 'empty_cart' | 'instalment_charge_mismatch';
     message: string;
 };
 type CheckoutPlanningSettledCart = Readonly<{
@@ -33,10 +33,13 @@ export type DeferredManualCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readon
 }>;
 export type InstalmentCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readonly<{
     kind: 'instalment_plan';
+    planDefinition: BookingInstalmentPlanConfig;
+    /** Charged now; has to be the plan's first instalment of the settled total. */
+    chargeNowCents: number;
 }>;
 export type FlexibleBalanceCheckoutPaymentPlan = CheckoutPaymentPlanBase & Readonly<{
     kind: 'flexible_balance';
-    initialPaymentCents: number;
+    chargeNowCents: number;
 }>;
 export type OneTimeCheckoutPlanningPaymentPlan = StripeCheckoutPaymentPlan | BypassCheckoutPaymentPlan | DeferredManualCheckoutPaymentPlan | InstalmentCheckoutPaymentPlan | FlexibleBalanceCheckoutPaymentPlan;
 type CheckoutPlanningContext = Readonly<Record<string, unknown>>;
@@ -56,9 +59,11 @@ export type OrderSettlementPlan<TItem, TDiscount, TDiscountApplication> = Readon
     discount: TDiscount;
     discountApplication: TDiscountApplication;
 }>;
+/** The ways a one-time checkout's order can be paid; passes, memberships and waivers never check out here. */
+export type OneTimeCheckoutOrderPaymentMethod = Extract<OrderPaymentMethod, 'free' | 'store_credit' | 'manual' | 'stripe' | 'mixed'>;
 export type OrderDraftPlan = Readonly<{
     status: OrderStatus;
-    paymentMethod: OrderPaymentMethod;
+    paymentMethod: OneTimeCheckoutOrderPaymentMethod;
     paidTotal: Money<CurrencyCode>;
 }>;
 export type OneTimeCheckoutPlan<TContext extends CheckoutPlanningContext, TSettledCart extends CheckoutPlanningSettledCart> = Readonly<{

package/dist/_dts/commerce/src/purchase/orderInstalmentClosure.d.ts

@@ -1,6 +1,6 @@
 import { type NonNegativeCents } from '../../../core/src/index';
 import type { OrderInstalmentPlanStatus, OrderInstalmentStatus } from './orderInstalmentPlan';
-type InstalmentClosureReason = 'cancelled' | 'refunded';
+export type InstalmentClosureReason = 'cancelled' | 'refunded';
 type InstalmentClosurePlanSnapshot = Readonly<{
     status: OrderInstalmentPlanStatus;
     remainingBalanceCents: NonNegativeCents;
@@ -15,12 +15,24 @@ type InstalmentStatusUpdate = Readonly<{
 }>;
 export type OrderInstalmentClosurePlan = Readonly<{
     kind: 'already_applied';
+}> | Readonly<{
+    kind: 'conflict';
 }> | Readonly<{
     kind: 'apply';
     nextPlanStatus: Extract<OrderInstalmentPlanStatus, 'cancelled' | 'refunded'>;
     nextRemainingBalanceCents: NonNegativeCents;
     instalmentUpdates: readonly InstalmentStatusUpdate[];
 }>;
+/**
+ * Whether closing the plan for this reason has nothing to do: it already has
+ * that status, or (for a cancel) it isn't live or has nothing left to
+ * collect. This only describes local accounting; it never proves that provider
+ * collection has stopped.
+ */
+export declare function isOrderInstalmentClosureAlreadyApplied(input: Readonly<{
+    paymentPlan: InstalmentClosurePlanSnapshot;
+    reason: InstalmentClosureReason;
+}>): boolean;
 export declare function planOrderInstalmentClosure(input: Readonly<{
     paymentPlan: InstalmentClosurePlanSnapshot;
     instalments: readonly InstalmentClosureRowSnapshot[];

package/dist/_dts/commerce/src/purchase/orderInstalmentLifecycle.d.ts

@@ -25,6 +25,10 @@ export type ApplyRecurringInstalmentPaymentPlan = Readonly<{
 export type ApplyRecurringInstalmentFailurePlan = Readonly<{
     kind: 'already_applied';
     instalmentId: string;
+}>
+/** The plan is finished or closed: a late failed invoice changes nothing. */
+ | Readonly<{
+    kind: 'plan_closed';
 }> | Readonly<{
     kind: 'apply_failure';
     instalmentId: string;
@@ -38,6 +42,7 @@ export declare function planRecurringInstalmentInvoicePaid(input: Readonly<{
     amountPaidCents: NonNegativeCents;
 }>): ApplyRecurringInstalmentPaymentPlan;
 export declare function planRecurringInstalmentInvoiceFailed(input: Readonly<{
+    planStatus: OrderInstalmentPlanStatus;
     instalments: readonly InstalmentLifecycleRowSnapshot[];
     stripeInvoiceId: string;
 }>): ApplyRecurringInstalmentFailurePlan;

package/dist/_dts/commerce/src/purchase/orderItemMetadata.d.ts

@@ -1,6 +1,6 @@
 import { type StripeBookingCommissionOrderItemMetadata } from './stripeCommissionMetadata';
 export { parseStripeBookingCommissionMetadata, type StripeBookingCommissionOrderItemMetadata } from './stripeCommissionMetadata';
-import { type BrandedIdParseError, type CheckoutLineId, type RetiredCourseId, type CustomerId, type DatedOfferingCapacityHoldAuditRef, type DatedOfferingCapacityHoldId, type EventSeriesId, type EventInstanceId, type OccurrenceId, type PassId, type PricingOptionId, type Result } from '../../../core/src/index';
+import { type BrandedIdParseError, type CheckoutLineId, type RetiredCourseId, type CustomerId, type DatedOfferingCapacityHoldAuditRef, type DatedOfferingCapacityHoldId, type EventSeriesId, type MembershipId, type EventInstanceId, type OccurrenceId, type PassId, type PricingOptionId, type Result } from '../../../core/src/index';
 import type { OrderItemKind } from './orderTypes';
 export type CheckoutLineMetadata = Readonly<{
     checkoutLineId?: CheckoutLineId;
@@ -150,6 +150,8 @@ export type MembershipBundleFulfillmentMetadata = Readonly<{
     membershipName: string;
 }>;
 export type MembershipOrderItemMetadata = CheckoutLineMetadata & StripeBookingCommissionOrderItemMetadata & Readonly<{
+    membershipId?: MembershipId;
+    billingInterval?: 'month' | 'year';
     bundleFulfillment?: MembershipBundleFulfillmentMetadata;
 }>;
 export type OrderItemMetadataByKind = {

package/dist/_dts/commerce/src/purchase/orderTypes.d.ts

@@ -1,6 +1,12 @@
 export declare const ORDER_STATUSES: readonly ["pending", "paid", "partially_refunded", "refunded", "failed", "cancelled"];
 export type OrderStatus = (typeof ORDER_STATUSES)[number];
 export declare function isOrderStatus(value: string): value is OrderStatus;
+/**
+ * Orders that ended without being paid: a failed checkout or a cancellation.
+ * Nothing is collected or chased against them.
+ */
+export declare const CLOSED_ORDER_STATUSES: readonly ["failed", "cancelled"];
+export declare function isClosedOrderStatus(status: string): status is (typeof CLOSED_ORDER_STATUSES)[number];
 export declare const ORDER_PAYMENT_METHODS: readonly ["stripe", "store_credit", "mixed", "pass_redemption", "membership_access", "free", "manual", "waived"];
 export type OrderPaymentMethod = (typeof ORDER_PAYMENT_METHODS)[number];
 export declare function isOrderPaymentMethod(value: string): value is OrderPaymentMethod;
@@ -20,7 +26,7 @@ export declare const RESERVATION_FINALIZATION_STATES: readonly ["not_applicable"
 export type ReservationFinalizationState = (typeof RESERVATION_FINALIZATION_STATES)[number];
 export declare function isReservationFinalizationState(value: string): value is ReservationFinalizationState;
 export type CheckoutPaymentRail = 'bypass' | 'stripe';
-export type CheckoutCommitFailureStep = 'credit_consumption' | 'membership_provision' | 'fulfillment' | 'discount_redemption' | 'payment_record';
+export type CheckoutCommitFailureStep = 'credit_consumption' | 'membership_provision' | 'fulfillment' | 'discount_redemption';
 export type CheckoutCompensationDecision = Readonly<{
     kind: 'release_reservations';
     reason: string;

package/dist/_dts/commerce/src/purchase/refundRailSplit.d.ts

@@ -34,7 +34,7 @@ export declare function computeRailAwareRefundSplit(originalCashCents: NonNegati
  *
  * Pure function — just array reduction.
  */
-export declare function summarizePriorRefundsByRail(refunds: ReadonlyArray<RefundWithAllocations>, orderItemId: string): Result<RefundRailSplit, Readonly<{
+export declare function summarizePriorRefundsByRail(refunds: ReadonlyArray<RefundWithAllocations>, orderItemIds: readonly string[]): Result<RefundRailSplit, Readonly<{
     kind: 'mixed_rail_attribution_missing';
 }>>;
 export {};

package/dist/_dts/commerce/src/purchase/stateTransitions.d.ts

@@ -1,13 +1,13 @@
 import { type Result } from '../../../core/src/index';
 import type { CheckoutCommitFailureStep, CheckoutCompensationDecision, CheckoutPaymentRail, DiscountRedemptionStatus, OrderStatus } from './orderTypes';
+import type { CheckoutCommitProgress } from './checkoutCommitPlan';
 export type OrderStatusEvent = 'checkout_failed' | 'stripe_payment_completed' | 'cancel' | 'partial_refund' | 'full_refund';
 export declare function advanceOrderStatus(from: OrderStatus, event: OrderStatusEvent): Result<OrderStatus, string>;
 export declare function transitionOrderStatusTo(from: OrderStatus, to: OrderStatus): Result<OrderStatus, string>;
 export declare function classifyCheckoutCompensationDecision(input: {
     paymentRail: CheckoutPaymentRail;
     failedStep: CheckoutCommitFailureStep;
-    reservationsConsumed: boolean;
-    fulfillmentCommitted: boolean;
+    progress: CheckoutCommitProgress;
 }): CheckoutCompensationDecision;
 export type DiscountRedemptionEvent = 'redeem' | 'release' | 'expire';
 export declare function advanceDiscountRedemptionStatus(from: DiscountRedemptionStatus, event: DiscountRedemptionEvent): Result<DiscountRedemptionStatus, string>;

package/dist/_dts/commerce/src/purchase/stripeMinimumCharge.d.ts

@@ -8,3 +8,9 @@ export declare function isStripeChargeBelowMinimum(options: Readonly<{
     amountCents: number;
     currency: string;
 }>): boolean;
+/**
+ * The smallest deposit a plan that starts with one may ask for: the card
+ * minimum for the currency, or any positive amount for a currency Stripe has
+ * no minimum on record for.
+ */
+export declare function getInstalmentDepositMinimumCents(currency: string): number;

package/dist/_dts/commerce/src/purchase/types.d.ts

@@ -5,6 +5,7 @@
  * course, membership), it's a Purchase. Payment method is an attribute
  * of the purchase, not a separate concept (Model B: unified).
  */
+import type { BookingPaymentCollectionOptionKind } from '../../../core/src/index';
 import type { OccurrenceId, PricingOptionId, ProductId, ProductVariantId, PassId, MembershipId, CustomerId, OrderId, AttendeeId, CustomerPassId, CustomerMembershipId, EventSeriesRegistrationId, AppointmentId, NonEmptyArray, SiteId, EventSeriesId } from '../../../core/src/index';
 import type { PositiveCheckoutQuantity } from './checkoutQuantity';
 export type CheckoutItem = EventTicketItem | ProductItem | PassItem | EventSeriesRegistrationItem | AppointmentItem;
@@ -67,7 +68,7 @@ export type CartCheckout = {
     items: NonEmptyArray<CheckoutItem>;
     customer: CustomerInfo;
     discountCode?: string;
-    collectionOptionKind?: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
+    collectionOptionKind?: BookingPaymentCollectionOptionKind;
     successUrl: string;
     cancelUrl: string;
 };

package/dist/_dts/content-editor/src/components/ContentFieldsForm.d.ts

@@ -2,9 +2,8 @@ import { type ReactNode } from 'react';
 import type { BlockManifest } from '../../../blocks/src/index';
 import { type FieldWidgetComponent } from '../../../block-form/src/index';
 import type { ManifestFormSource } from '../../../block-form/src/index';
-export type { AutosaveHandle } from '../hooks/useSimpleAutosave';
+export type { AutosaveHandle } from '../ui/stores/types';
 export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
-    siteId: string;
     manifest?: BlockManifest;
     form?: ManifestFormSource;
     /**
@@ -14,12 +13,8 @@ export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
     initialValues?: TValues;
     paletteTokens?: Record<string, string>;
     widgets?: Partial<Record<string, FieldWidgetComponent>>;
-    mediaProvider?: (props: {
-        siteId: string;
-        children: ReactNode;
-    }) => ReactNode;
     errorComponent?: (props: {
         error: string;
     }) => ReactNode;
 };
-export declare function ContentFieldsForm<TValues extends Record<string, unknown>>({ siteId, manifest, form: formSpec, initialValues: _initialValues, paletteTokens, widgets, mediaProvider: MediaProvider, errorComponent: ErrorComponent, }: ContentFieldsFormProps<TValues>): import("react").JSX.Element;
+export declare function ContentFieldsForm<TValues extends Record<string, unknown>>({ manifest, form: formSpec, initialValues: _initialValues, paletteTokens, widgets, errorComponent: ErrorComponent, }: ContentFieldsFormProps<TValues>): import("react").JSX.Element;

package/dist/_dts/content-editor/src/controller/EditLeaseController.d.ts

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+import type { ApiClient } from '../../../api/src/request';
+import type { DocumentLeaseReadInput } from './readDocumentLeaseBaselines';
+import type { EditLeaseScope } from '../../../core/src/index';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { EditLeaseLossSignal } from './editLeaseLossSignal';
+import { useEditLease, type EditLeaseChangeSubscription } from '../hooks/useEditLease';
+export type EditorLeaseConfig = Readonly<{
+    siteId: string;
+    scope: EditLeaseScope;
+    subscribeToLeaseChanges?: EditLeaseChangeSubscription;
+    /** Refresh display props after the authoritative baseline has been applied. */
+    onGranted?: () => void;
+    onAccessChanged?: () => void;
+}>;
+export type EditLeaseActions = ReturnType<typeof useEditLease>;
+/**
+ * Discarding is local and synchronous: it can't fail, and it happens before the tab leaves
+ * edit mode. Newer server values arrive by the take-back refresh on the next grant, or, in
+ * view mode, by live drafts and reload broadcasts.
+ */
+export type EditLeaseControllerActions = EditLeaseActions & Readonly<{
+    discardLocal: () => void;
+}>;
+/**
+ * Mounts the lease session only while `lease` is set. Children keep their position in the
+ * tree either way, so joining or leaving the lease never remounts the editor.
+ */
+export declare function EditLeaseController({ children, lease, ...session }: Readonly<{
+    children: ReactNode;
+    document: Pick<DocumentLeaseReadInput, 'type' | 'schema' | 'blockFieldExtensions'>;
+    lease: EditorLeaseConfig | null;
+    apiClient: ApiClient;
+    uiStore: EditorUiStoreInstance;
+    leaseLossSignal: EditLeaseLossSignal;
+    /** Rendered beside children, only while the lease session is mounted. */
+    sessionChildren?: ReactNode;
+}>): import("react").JSX.Element;
+export declare function useEditLeaseActions(): EditLeaseControllerActions | null;

package/dist/_dts/content-editor/src/controller/EditorWriteGate.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+import { type LeaseNotice, type LeaseNoticeAction } from './editLeaseNotice';
+export type LeaseNoticeHandlers = Readonly<Record<LeaseNoticeAction, () => void>>;
+/** Makes a mount's editing surface inert while the tab is waiting for, or denied, the lease. */
+export declare function EditorWriteSurface({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;
+export declare function LeaseNoticeButtons({ notice, handlers, size }: Readonly<{
+    notice: LeaseNotice;
+    handlers: LeaseNoticeHandlers;
+    size?: 'sm';
+}>): import("react").JSX.Element[];
+/** A blocking modal; it can't be dismissed, because the modal is the only way forward. */
+export declare function EditLeaseModalView({ notice, handlers }: Readonly<{
+    notice: LeaseNotice | null;
+    handlers: LeaseNoticeHandlers;
+}>): import("react").JSX.Element;
+/** The document's lease modal. Pass `onKeepViewing` where the tab can return to view mode. */
+export declare function EditLeaseModal({ thing, onKeepViewing }: Readonly<{
+    thing: string;
+    onKeepViewing?: () => void;
+}>): import("react").JSX.Element | null;
+export declare function LeaseDiscardedNoticeView({ thing, onDismiss }: Readonly<{
+    thing: string;
+    onDismiss: () => void;
+}>): import("react").JSX.Element;
+/** Shown after taking the lease back replaced edits another tab had changed. */
+export declare function EditLeaseDiscardedNotice({ thing }: Readonly<{
+    thing: string;
+}>): import("react").JSX.Element | null;
+/**
+ * One write gate per editor mount: the whole editing surface is inert while the tab can't
+ * write, and the lease modal explains why. The modal portals outside the inert subtree.
+ */
+export declare function EditorWriteGate({ thing, children }: Readonly<{
+    thing: string;
+    children: ReactNode;
+}>): import("react").JSX.Element;