@riverbankcms/sdk 0.149.0 → 0.150.0

package/dist/_dts/blocks/src/system/runtime/api/types/events.d.ts

@@ -1,3 +1,4 @@
+import type { CheckoutSessionHandle, EmbeddedCheckoutBrowserContext } from '../../../../../../commerce/src/purchase/index';
 import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
 /**
  * Public event, registration, checkout and eligibility types
@@ -103,8 +104,7 @@ export interface EventRegisterRequest {
      */
     registrationCommandId: string;
     checkout?: {
-        successUrl: string;
-        cancelUrl: string;
+        returnUrl: string;
         discountCode?: string;
         collectionOptionKind?: DirectCheckoutCollectionOptionKind;
     };
@@ -152,6 +152,10 @@ export type EventRegistrationSummary = {
     passCreditsUsed?: number;
     passCreditsRemaining?: number;
 };
+export type EventEmbeddedCheckout = CheckoutSessionHandle<'embedded'> & Readonly<{
+    browser: EmbeddedCheckoutBrowserContext;
+    expiresAt: string;
+}>;
 export type EventRegisterResponse = {
     kind: 'bookingComplete';
     reference: EventRegistrationStatusReference;
@@ -171,7 +175,7 @@ export type EventRegisterResponse = {
 } | {
     kind: 'checkoutRequired';
     reference: EventRegistrationStatusReference;
-    checkoutUrl: string;
+    checkout: EventEmbeddedCheckout;
     submissionId: string;
     mailingListSignupNote?: BookingSignupNote;
     demoBookingPass?: string;
@@ -203,8 +207,7 @@ type EventCheckoutRequestCommon = {
     siteId: string;
     discountCode?: string;
     collectionOptionKind?: DirectCheckoutCollectionOptionKind;
-    successUrl: string;
-    cancelUrl: string;
+    returnUrl: string;
 };
 export type EventCheckoutRequest = EventCheckoutRequestCommon & ({
     subject: {
@@ -233,30 +236,35 @@ export type EventCheckoutRequest = EventCheckoutRequestCommon & ({
     claimToken?: string;
     waitlistEntryId?: string;
     checkoutAttemptId: string;
+    collectionOptionKind: DirectCheckoutCollectionOptionKind;
 });
-type OccurrenceCheckoutResponse = Readonly<{
+type CheckoutOutcome = Readonly<{
+    kind: 'checkoutRequired';
+    checkout: EventEmbeddedCheckout;
+}> | Readonly<{
+    kind: 'completed';
+    deferredBalance?: {
+        amountCents: number;
+        currency: string;
+    };
+}>;
+type OccurrenceCheckoutResponse = CheckoutOutcome & Readonly<{
     scope: 'occurrence';
     attendeeId: string;
-    checkoutUrl: string | null;
-    sessionId: string | null;
-    bypassed: boolean;
     mailingListSignupNote?: BookingSignupNote;
 }>;
-type WholeSeriesCheckoutResponse = Readonly<{
+type WholeSeriesCheckoutResponse = CheckoutOutcome & Readonly<{
     scope: 'wholeSeries';
     registrationId: string;
     checkoutAttemptId: string;
     recoverableUntil?: string;
-    checkoutUrl: string | null;
-    sessionId: string | null;
-    bypassed: boolean;
     mailingListSignupNote?: BookingSignupNote;
 }>;
 type WholeSeriesPaymentStatusRequired = Readonly<{
     scope: 'wholeSeries';
     status: 'paymentStatusRequired';
     checkoutAttemptId: string;
-    recoverableUntil: string;
+    recoverableUntil?: string;
     mailingListSignupNote?: BookingSignupNote;
 }>;
 type WholeSeriesWaitlistResponse = Readonly<{
@@ -333,17 +341,17 @@ export interface EventRegistrationStatusResponse {
     waitlistPosition: number | null;
 }
 export type EventCheckoutReturnRequest = {
-    kind: 'resolveSuccess';
+    kind: 'resolveSession';
     checkoutAttemptId: string;
     sessionId: string;
 } | {
     kind: 'abandon';
-    checkoutAttemptId: string;
+    subject: EventRegistrationPaymentSubject;
 } | {
     kind: 'checkStatus';
     subject: EventRegistrationPaymentSubject;
 };
-export type EventCheckoutReturnResponse = {
+export type EventCheckoutStatusOutcome = {
     kind: 'resolved';
     reference: EventRegistrationStatusReference;
     deferredBalance?: {
@@ -361,7 +369,7 @@ export type EventCheckoutReturnResponse = {
     recoverableUntil?: string;
 } | {
     kind: 'paymentAvailable';
-    checkoutUrl: string;
+    checkout: EventEmbeddedCheckout;
     recoverableUntil?: string;
 } | {
     kind: 'paymentRetryAvailable';
@@ -371,4 +379,16 @@ export type EventCheckoutReturnResponse = {
 } | {
     kind: 'paymentAssistanceRequired';
 };
+/** A subject is returned only after the server verifies the exact checkout binding. */
+export type EventCheckoutReturnResponse = {
+    kind: 'checkout';
+    subject: EventRegistrationPaymentSubject;
+    outcome: Exclude<EventCheckoutStatusOutcome, {
+        kind: 'notFound';
+    }>;
+} | {
+    kind: 'notFound';
+} | {
+    kind: 'reconciliationRequired';
+};
 export {};

package/dist/_dts/blocks/src/system/runtime/hooks/useHeadlessEventRegistrationFlow.d.ts

@@ -8,7 +8,7 @@ import { createEventRegistrationBlockApiConfig } from '../nodes/event-registrati
 export type { BlockApiConfig };
 export { createEventRegistrationBlockApiConfig };
 export type { EventRegistrationAttendeeModel, EventRegistrationDiscountModel, EventRegistrationEventsModel, EventRegistrationFlowActionResult, EventRegistrationFlowActions, EventRegistrationFlowStatus, EventRegistrationFlowStep, EventRegistrationFlowStepId, EventRegistrationFlowView, EventRegistrationGuestsModel, EventRegistrationLoadState, EventRegistrationOverrideData, EventRegistrationOverrideInput, EventRegistrationOverrideInputResult, EventRegistrationOverridePropsLike, EventRegistrationPaymentModel, EventRegistrationPaymentSelection, EventRegistrationPortalAuthModel, EventRegistrationSpamProtectionModel, EventRegistrationTerminalModel, EventRegistrationTicketsModel, HeadlessEventRegistrationFlow, } from '../nodes/event-registration/event-registration.headless.state';
-export type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult, } from '../nodes/event-registration/useEventRegistrationSubmit';
+export type { EventRegistrationSubmitResult, } from '../nodes/event-registration/useEventRegistrationSubmit';
 export type HeadlessEventRegistrationFlowOptions = Readonly<{
     anchorId?: string;
     occurrenceContext?: EventRegistrationClientProps['occurrenceContext'];

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.server.d.ts

@@ -16,6 +16,12 @@ type BookingFormProps = BookingFormSourceProps & Readonly<{
  * card drawn exactly once after hydration, because the client wizard renders its
  * own `.rb-reg-surface`, and leaves no stale loading state on the mounted form.
  * `event-registration.server.tsx` follows the same shape.
+ *
+ * The root also carries `data-block="appointment-booking"`, because the
+ * appointment-booking and registration-surface styles and the block's Tier 3
+ * vars are all scoped under that attribute. On a page the block wrapper
+ * already provides it, but the system service destination and /book render
+ * this form on its own, so without it those routes lose every booking style.
  */
 export declare function BookingFormSSR({ blockId, children, ...sourceProps }: BookingFormProps): React.JSX.Element;
 export default BookingFormSSR;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/EventEmbeddedCheckoutStep.d.ts

@@ -0,0 +1,13 @@
+import type { EventEmbeddedCheckout } from '../../api/types';
+import { loadBrowserStripe } from '../../shared/stripe/browserStripe';
+type Props = Readonly<{
+    checkout: EventEmbeddedCheckout;
+    onComplete: () => void;
+    onRetry: () => void;
+    onBack: () => void;
+}>;
+export default function EventEmbeddedCheckoutStep(props: Props): import("react").JSX.Element;
+export declare function EventEmbeddedCheckoutStepWithDeps(props: Props & Readonly<{
+    load: typeof loadBrowserStripe;
+}>): import("react").JSX.Element;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/EventRegistrationPayment.d.ts

@@ -0,0 +1,15 @@
+import type { HeadlessEventRegistrationFlow } from './event-registration.headless.contract';
+import type { EventPaymentState } from './types';
+type PaymentMountProps = Readonly<{
+    state: EventPaymentState;
+    onComplete: () => void;
+    onRetry: () => void;
+    onBack: () => Promise<void>;
+}>;
+/** The one Stripe mount, shared by the standard wizard and headless arrangements. */
+export declare function EventPaymentMount({ state, onComplete, onRetry, onBack }: PaymentMountProps): import("react").JSX.Element | null;
+/** Mount the active checkout from the same headless registration controller. */
+export declare function EventRegistrationPayment({ flow }: Readonly<{
+    flow: HeadlessEventRegistrationFlow;
+}>): import("react").JSX.Element;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/EventRegistrationWizardActions.d.ts

@@ -10,7 +10,6 @@ import type { ThemeButtonVariantId } from '../../../../../../theme-core/src/butt
  */
 export declare function resolveDetailsButtonText(input: Readonly<{
     wizard: UseEventRegistrationWizardResult;
-    hasWaitlistClaim: boolean;
     fallbackText: string;
 }>): string;
 type WizardActionsProps = Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/FullyBookedStep.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
+export declare function FullyBookedStep(props: Readonly<{
+    wizard: UseEventRegistrationWizardResult;
+    showSpamProtection: boolean;
+}>): React.JSX.Element;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/PaymentBlockingPanel.d.ts

@@ -1,13 +1,16 @@
 import React from 'react';
 import type { EligibilityData, PaymentStepState } from './types';
+import { type RegistrationAdmission } from './registrationCompletion';
 export declare function resolvePaymentStepStatus(input: Readonly<{
     loading: boolean;
     error: string | null;
     eligibility: EligibilityData | null;
+    admission: RegistrationAdmission;
 }>): PaymentStepState['status'];
 export declare function shouldPromptForLogin(status: PaymentStepState['status'], isAuthenticated: boolean, eligibility: EligibilityData | null): boolean;
 export declare function PaymentBlockingPanel(props: Readonly<{
     eligibility: EligibilityData | null;
+    admission: RegistrationAdmission;
     eligibilityLoading: boolean;
     eligibilityError: string | null;
     occurrenceId: string;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/PaymentSelectionStep.d.ts

@@ -1,3 +1,4 @@
+import type { RegistrationAdmission } from './registrationCompletion';
 /**
  * Payment Selection Step Component
  *
@@ -27,6 +28,7 @@ type PaymentSelectionStepProps = {
     /** Called whenever the user updates payment selection in this step */
     onSelectionChange: (selection: PaymentSelection) => void;
     eligibility: EligibilityData | null;
+    admission: RegistrationAdmission;
     eligibilityLoading: boolean;
     eligibilityError?: string | null;
     /** Called when the user wants to request a login link (optional) */

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/event-registration.headless.contract.d.ts

@@ -2,13 +2,13 @@ import type { DirectCheckoutCollectionOptionKind, PaymentMethod } from '../../ap
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 import type { EventRegistrationDirectPaymentOption, EventRegistrationDirectPaymentSelectionState } from './eventPaymentOptions';
 import type { EventRegistrationPageSurfaceSubject } from './eventScope';
-import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, PaymentSelection, PaymentStatusRecoveryState, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
+import type { EligibilityData, EventTicketSelectionLine, FormData, Guest, GuestErrors, OccurrenceContext, EventPaymentState, PaymentSelection, PaymentStatusRecoveryState, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult } from './types';
 import type { SelectableEventTicketType } from './utils';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
 import type { PortalAuthState, PortalProfile } from './hooks';
 import type { UseWaitlistClaimResult } from '../../shared/useWaitlistClaim';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
-import type { EventRegistrationSubmitOptions, EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
+import type { EventRegistrationSubmitResult } from './useEventRegistrationSubmit';
 export declare const DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
 export type EventRegistrationLoadState<T> = Readonly<{
     tag: 'idle';
@@ -39,7 +39,7 @@ export type EventRegistrationFlowStatus = Readonly<{
 }> | Readonly<{
     tag: 'submitting';
 }> | Readonly<{
-    tag: 'redirecting';
+    tag: 'payment';
 }> | Readonly<{
     tag: 'verifying-payment';
 }> | Readonly<{
@@ -66,6 +66,10 @@ export type EventRegistrationFlowView = Readonly<{
     message: string;
 }> | Readonly<{
     kind: 'form';
+}> | Readonly<{
+    kind: 'fully-booked';
+    recovery: 'byEmail' | 'none';
+    recoveryMessage: string | null;
 }> | Readonly<{
     kind: 'verifying';
     message: string;
@@ -79,7 +83,7 @@ export type EventRegistrationFlowView = Readonly<{
     kind: 'error';
     message: string;
 }>;
-export type EventRegistrationFlowStepId = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment';
+export type EventRegistrationFlowStepId = 'select-event' | 'select-tickets' | 'enter-details' | 'select-payment' | 'payment';
 export type EventRegistrationFlowStepState = 'complete' | 'active' | 'available' | 'blocked';
 export type EventRegistrationFlowStep = Readonly<{
     id: EventRegistrationFlowStepId;
@@ -161,12 +165,14 @@ export type EventRegistrationPaymentModel = Readonly<{
     selection: EventRegistrationPaymentSelection;
     directPaymentOptions: readonly EventRegistrationDirectPaymentOption[];
     directPaymentSelectionState: EventRegistrationDirectPaymentSelectionState;
+    checkout: EventPaymentState;
     stepState: PaymentStepState;
 }> | Readonly<{
     kind: 'loading' | 'error' | 'not-eligible' | 'ready';
     selection: EventRegistrationPaymentSelection;
     directPaymentOptions: readonly EventRegistrationDirectPaymentOption[];
     directPaymentSelectionState: EventRegistrationDirectPaymentSelectionState;
+    checkout: EventPaymentState;
     stepState: PaymentStepState;
     eligibility: EligibilityData | null;
     eligibilityError: string | null | undefined;
@@ -218,8 +224,12 @@ export type EventRegistrationFlowActions = Readonly<{
     logout: () => void;
     next: () => Promise<EventRegistrationFlowActionResult>;
     back: () => void;
-    submit: (options?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+    submit: () => Promise<EventRegistrationSubmitResult>;
     retry: () => void;
+    checkPayment: () => void;
+    completePayment: () => void;
+    retryPaymentLoad: () => void;
+    backToBooking: () => Promise<void>;
     checkPaymentStatus: () => void;
     continueExistingPayment: () => void;
     returnToPayment: () => void;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/event-registration.headless.planning.d.ts

@@ -11,12 +11,14 @@ export declare function resolveEventRegistrationSubmitPlan(input: Readonly<{
     canJoinWaitlist?: boolean | null;
 }>): EventRegistrationSubmitPlan;
 export declare function resolveHeadlessEventRegistrationStatus(wizard: Pick<UseEventRegistrationWizardResult, 'step' | 'registrationResult' | 'errorMessage'> & Partial<Pick<UseEventRegistrationWizardResult, 'errorAction' | 'paymentStatusRecovery'>>): EventRegistrationFlowStatus;
-export declare function resolveHeadlessEventRegistrationView(wizard: Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage'> & Partial<Pick<UseEventRegistrationWizardResult, 'paymentStatusRecovery'>> & {
+type RegistrationViewInput = Readonly<Pick<UseEventRegistrationWizardResult, 'step' | 'scopedEvents' | 'occurrenceContext' | 'registrationResult' | 'errorMessage' | 'paymentStatusRecovery' | 'admission' | 'recoveryMessage'> & {
     api: Pick<UseEventRegistrationWizardResult['api'], 'config'>;
-}>): EventRegistrationFlowView;
+}>;
+export declare function resolveHeadlessEventRegistrationView(wizard: RegistrationViewInput): EventRegistrationFlowView;
 export declare function deriveEventRegistrationSteps(input: Readonly<{
     step: RegistrationStep;
     hasPreSelectedContext: boolean;
     eventRequiresPayment: boolean;
     paymentSelection: PaymentSelection;
 }>): readonly EventRegistrationFlowStep[];
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/paymentLocation.d.ts

@@ -0,0 +1,3 @@
+export declare function eventPaymentReturnUrl(submissionId: string): string;
+export declare function rememberEventPayment(submissionId: string, sessionId: string): void;
+export declare function clearEventPayment(siteId: string | undefined): void;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/paymentResponse.d.ts

@@ -0,0 +1,72 @@
+import type { EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
+import type { PaymentStatusRecoveryState } from './types';
+type PaymentResponseIntent = 'resume' | 'check' | 'abandon';
+export type PaymentResponseTransition = {
+    kind: 'confirmed';
+} | {
+    kind: 'restartBooking';
+} | {
+    kind: 'unresolved';
+} | {
+    kind: 'payment';
+    checkout: EventEmbeddedCheckout;
+    subject: EventRegistrationPaymentSubject;
+} | {
+    kind: 'recovery';
+    state: PaymentStatusRecoveryState;
+};
+/**
+ * Verified response identity owns every follow-up action, including storage-free returns.
+ * `requested` is the subject the client sent, if any: a subject-bound `notFound`
+ * means the server lost that booking, which no amount of re-checking will fix.
+ */
+export declare function planPaymentResponse(response: EventCheckoutReturnResponse, intent: PaymentResponseIntent, requested: EventRegistrationPaymentSubject | null): PaymentResponseTransition;
+type CheckoutEnvelope = Extract<EventCheckoutReturnResponse, {
+    kind: 'checkout';
+}>;
+/** A mounted-form check that never reached the server. */
+export type PaymentCheckUnreachable = Readonly<{
+    kind: 'unreachable';
+}>;
+export type PaymentCheckResult = EventCheckoutReturnResponse | PaymentCheckUnreachable;
+/**
+ * What a check result proves, before deciding what the customer sees.
+ * `inconclusive` means the server could not look; `bindingLost` means it looked
+ * and the booking association is gone. Confusing the two either strands a
+ * customer mid-authentication or lets them pay for a booking we can't find.
+ */
+export type PaymentCheckEvidence = Readonly<{
+    kind: 'inconclusive';
+}> | Readonly<{
+    kind: 'bindingLost';
+}> | Readonly<{
+    kind: 'paymentUnderway';
+}> | Readonly<{
+    kind: 'payable';
+    checkout: EventEmbeddedCheckout;
+    response: CheckoutEnvelope;
+}> | Readonly<{
+    kind: 'terminal';
+    response: CheckoutEnvelope;
+}>;
+export declare function paymentCheckEvidence(result: PaymentCheckResult): PaymentCheckEvidence;
+/**
+ * What a background check may do to a customer looking at a live Stripe form.
+ * Only conclusive evidence moves them; inconclusive evidence keeps the form,
+ * since unmounting it can interrupt an authentication already in progress.
+ */
+export type MountedPaymentRefresh = Readonly<{
+    kind: 'stay';
+}> | Readonly<{
+    kind: 'poll';
+}> | Readonly<{
+    kind: 'leave';
+    transition: PaymentResponseTransition;
+}>;
+export type MountedPayment = Readonly<{
+    sessionId: string;
+    subject: EventRegistrationPaymentSubject;
+}>;
+export declare function planMountedPaymentRefresh(result: PaymentCheckResult, mounted: MountedPayment): MountedPaymentRefresh;
+export declare function paymentResponseNeedsPolling(response: EventCheckoutReturnResponse): boolean;
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/registrationCompletion.d.ts

@@ -1,12 +1,73 @@
-import type { EligibilityData } from './types';
-export declare function isSelectionSoldOut(availability: EligibilityData['availability'] | undefined): boolean;
-export declare function resolveRegistrationAvailabilityBlocker(input: Readonly<{
+import type { EventRegistrationNextStepRequest } from '../../api/types';
+import type { EligibilityData, RegistrationStep } from './types';
+export type RegistrationAdmission = Readonly<{
+    kind: 'checking';
+}> | Readonly<{
+    kind: 'open' | 'resume';
+}> | Readonly<{
+    kind: 'waitlist';
+    recovery: 'byEmail' | 'none';
+}> | Readonly<{
+    kind: 'fullyBooked';
+    recovery: 'byEmail' | 'none';
+}> | Readonly<{
+    kind: 'closed';
+    reason: 'unavailable' | 'optionsUnavailable' | 'alreadyWaitlisted';
+    message: string;
+}>;
+/** One admission decision for navigation, labels and completion. Email recovery
+ * permits navigation only; submission remains the owner of payment recovery. */
+export declare function resolveRegistrationAdmission(input: Readonly<{
     hasWaitlistClaim: boolean;
-    eligibility: EligibilityData | null;
+    eligibility: Pick<EligibilityData, 'registration' | 'availability'> | null;
     eligibilityError: string | null;
-}>): string | null;
+    eligibilityLoading: boolean;
+    isAuthenticated: boolean;
+}>): RegistrationAdmission;
+export declare function stepAfterTickets(admission: RegistrationAdmission): RegistrationStep;
+export type RegistrationAvailabilityBlocker = Readonly<{
+    kind: 'pending';
+    message: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    message: string;
+}>;
+export declare function resolveRegistrationAvailabilityBlocker(admission: RegistrationAdmission): RegistrationAvailabilityBlocker | null;
 export declare function resolvePricingSelectionBlocker(input: Readonly<{
     selectionRequired: boolean;
     hasValidSelection: boolean;
     slidingScaleSelectionMessage: string | null;
 }>): string | null;
+export type GuestNextStepCheck = Readonly<{
+    kind: 'skip';
+    outcome: Readonly<{
+        kind: 'continue' | 'waitlist';
+    }>;
+}> | Readonly<{
+    kind: 'blocked';
+    message: string;
+}> | Readonly<{
+    kind: 'check';
+    request: EventRegistrationNextStepRequest;
+}>;
+/** Submit owns fresh admission. Open quotes do not depend on an email lookup. */
+export declare function resolveGuestNextStepCheck(admission: RegistrationAdmission, request: EventRegistrationNextStepRequest | null): GuestNextStepCheck;
+export type RegistrationTicketContinuation = Readonly<{
+    kind: 'advance';
+    admission: Exclude<RegistrationAdmission, {
+        kind: 'closed' | 'checking';
+    }>;
+    label: string;
+    pending: false;
+}> | Readonly<{
+    kind: 'blocked';
+    message: string;
+    label: string;
+    pending: boolean;
+}>;
+export declare function resolveRegistrationTicketContinuation(input: Readonly<{
+    admission: RegistrationAdmission;
+    ticketSelectionRequired: boolean;
+    hasValidTicketSelection: boolean;
+    isCheckingExistingRegistration: boolean;
+}>): RegistrationTicketContinuation;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/registrationErrorRecovery.d.ts

@@ -1,9 +1,7 @@
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
-import type { EligibilityData, EventTicketSelectionLine, RegistrationEvent, RegistrationStep } from './types';
+import type { EventTicketSelectionLine, RegistrationEvent, RegistrationStep } from './types';
 import type { RegistrationFlowAction } from './registrationStateMachine';
-import type { EventRegistrationStatusReference } from '../../api/types';
 export declare function resolveRegistrationRecoveryAction(step: RegistrationStep, action: EventRegistrationErrorAction): EventRegistrationErrorAction;
-export declare function canRecoverToWaitlist(eligibility: EligibilityData | null): boolean;
 export declare function shouldRefreshAfterRegistrationError(step: RegistrationStep, action: EventRegistrationErrorAction, enabled: boolean): boolean;
 export declare function resetRegistrationAfterExpiry(input: Readonly<{
     hasPreSelectedContext: boolean;
@@ -13,7 +11,6 @@ export declare function resetRegistrationAfterExpiry(input: Readonly<{
     setSelectedSlidingAmountInput: (value: string) => void;
     setSelectedAttendanceMode: (mode: 'online' | 'in_person' | null) => void;
     setErrorMessage: (message: string) => void;
-    setPendingRegistrationReference: (reference: EventRegistrationStatusReference | null) => void;
 }>): void;
 /** Retry the retained submission in place; explicit payment uncertainty stays status-only. */
 export declare function recoverRegistrationError(action: EventRegistrationErrorAction, handlers: Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/registrationStateMachine.d.ts

@@ -1,4 +1,6 @@
 import type { EligibilityData, PaymentSelection, RegistrationStep } from './types';
+import { type RegistrationAdmission } from './registrationCompletion';
+import type { EventRegistrationNextStepResponse } from '../../api/types';
 export type SelectionSource = 'auto' | 'manual';
 export type RegistrationFlowState = {
     step: RegistrationStep;
@@ -12,6 +14,17 @@ export type RegistrationFlowState = {
 export type RegistrationFlowAction = {
     type: 'set-step';
     step: RegistrationStep;
+} | {
+    type: 'admission-updated';
+    admission: RegistrationAdmission;
+} | {
+    type: 'tickets-completed';
+    admission: Exclude<RegistrationAdmission, {
+        kind: 'closed' | 'checking';
+    }>;
+} | {
+    type: 'recovery-checked';
+    outcome: EventRegistrationNextStepResponse;
 } | {
     type: 'set-tickets-count';
     ticketsCount: number;
@@ -33,11 +46,6 @@ export type RegistrationFlowAction = {
     type: 'reset';
     hasPreSelectedContext: boolean;
 };
-export declare function hasBlockingExistingRegistration(input: Readonly<{
-    isAuthenticated: boolean;
-    registration: EligibilityData['registration'];
-    hasWaitlistClaim: boolean;
-}>): boolean;
 export declare function createInitialRegistrationFlowState(hasPreSelectedContext: boolean): RegistrationFlowState;
 export declare function registrationFlowReducer(state: RegistrationFlowState, action: RegistrationFlowAction): RegistrationFlowState;
 export declare function isEntitlementSelection(selection: PaymentSelection): boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/sessionStorage.d.ts

@@ -1,64 +1,23 @@
-import type { BookingMailingListNote as BookingSignupNote } from '../../../../../../core/src/index';
-/**
- * SessionStorage utilities for preserving form state across Stripe redirects.
- *
- * Saves form data before redirecting to Stripe, restores on return.
- * Handles graceful degradation when sessionStorage is unavailable.
- */
-import type { FormData } from './types';
-import type { EventTicketSelectionLine, PaymentSelection } from './types';
+import type { BookingMailingListNote } from '../../../../../../core/src/index';
 import type { EventRegistrationStatusReference } from '../../api/types';
-/**
- * Schema for pending registration data stored in sessionStorage.
- * Version field allows future migrations if schema changes.
- */
-type PendingRegistrationV5 = {
-    version: 5;
+import type { FormData, Guest, EventTicketSelectionLine, PaymentSelection } from './types';
+export type PendingRegistration = {
+    version: 6;
     reference: EventRegistrationStatusReference;
     formData: FormData;
     ticketSelections: EventTicketSelectionLine[];
     selectedEventId: string | null;
-    eventSeriesId?: string | null;
     selectedAttendanceMode?: 'in_person' | 'online' | null;
     paymentSelection: PaymentSelection & {
         method: Exclude<PaymentSelection['method'], null>;
     };
-    mailingListSignupNote?: BookingSignupNote;
+    guests: Guest[];
+    selectedSlidingAmount: number | null;
+    discountCode: string;
+    mailingListSignupNote?: BookingMailingListNote;
     timestamp: number;
 };
-export type PendingRegistration = PendingRegistrationV5;
-/**
- * Save pending registration data before Stripe redirect.
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Correlation ID included in the checkout return URL
- * @param data - Registration data to save (excluding version and timestamp)
- */
-export declare function savePendingRegistration(siteId: string, checkoutAttemptId: string, data: Omit<PendingRegistration, 'version' | 'timestamp'>): void;
-/**
- * Get pending registration data after returning from Stripe.
- *
- * Returns null if:
- * - No entry exists for this checkout attempt
- * - Entry is stale (> 24 hours old)
- * - Entry is corrupt or wrong version
- * - Storage is unavailable
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Correlation ID returned from checkout.
- * @returns Pending registration data or null
- */
-export declare function getPendingRegistration(siteId: string, checkoutAttemptId: string): PendingRegistration | null;
-/**
- * Clear pending registration data after successful verification.
- *
- * @param siteId - Site ID
- * @param checkoutAttemptId - Checkout return correlation ID
- */
-export declare function clearPendingRegistration(siteId: string, checkoutAttemptId: string): void;
-/**
- * Clean up all stale registration entries from sessionStorage.
- * Should be called on component mount to prevent accumulation.
- */
+export declare function savePendingRegistration(siteId: string, submissionId: string, data: Omit<PendingRegistration, 'version' | 'timestamp'>): void;
+export declare function getPendingRegistration(siteId: string, submissionId: string): PendingRegistration | null;
+export declare function clearPendingRegistration(siteId: string, submissionId: string): void;
 export declare function cleanupStaleRegistrations(): void;
-export {};