@riverbankcms/sdk 0.138.0 → 0.140.0

package/dist/_dts/blocks/src/system/runtime/nodes/appointment-services.d.ts

@@ -0,0 +1,94 @@
+import React from 'react';
+import { z } from 'zod';
+declare const publicLocationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"online">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"in_person">;
+    venue: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        area: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"either">;
+    venue: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        area: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "mode">;
+type PublicAppointmentLocation = z.infer<typeof publicLocationSchema>;
+declare const publicAppointmentServiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    durationMinutes: z.ZodNumber;
+    pricing: z.ZodOptional<z.ZodObject<{
+        pricingStrategy: z.ZodEnum<{
+            free: "free";
+            single: "single";
+            tiered: "tiered";
+            sliding_scale: "sliding_scale";
+        }>;
+        currency: z.ZodString;
+        singlePriceAmount: z.ZodNullable<z.ZodNumber>;
+        slidingMinAmount: z.ZodNullable<z.ZodNumber>;
+        slidingMaxAmount: z.ZodNullable<z.ZodNumber>;
+        options: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            priceAmount: z.ZodNumber;
+            isActive: z.ZodBoolean;
+            saleStartsAt: z.ZodNullable<z.ZodString>;
+            saleEndsAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    priceAmount: z.ZodNullable<z.ZodNumber>;
+    priceCurrency: z.ZodNullable<z.ZodString>;
+    location: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"online">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"in_person">;
+        venue: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            area: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"either">;
+        venue: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            area: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "mode">;
+}, z.core.$strip>;
+type PublicAppointmentService = z.infer<typeof publicAppointmentServiceSchema>;
+export type AppointmentServiceRow = Readonly<{
+    id: string;
+    title: string;
+    description: string | null;
+    durationLabel: string;
+    locationLabel: string | null;
+    priceLabel: string | null;
+    href: string;
+}>;
+export type AppointmentServicesView = Readonly<{
+    kind: 'items';
+    rows: readonly AppointmentServiceRow[];
+}> | Readonly<{
+    kind: 'empty';
+    message: string;
+}> | Readonly<{
+    kind: 'error';
+    message: string;
+}>;
+export type AppointmentServicesNodeProps = Readonly<{
+    sectionHeading?: unknown;
+    services?: unknown;
+    pathname?: unknown;
+    className?: string | null;
+}>;
+export declare function formatAppointmentDuration(durationMinutes: number): string;
+export declare function formatAppointmentLocation(location: PublicAppointmentLocation): string | null;
+export declare function formatAppointmentPrice(service: PublicAppointmentService): string | null;
+export declare function buildAppointmentServicesView(input: Readonly<{
+    services: unknown;
+    pathname: string | undefined;
+}>): AppointmentServicesView;
+export declare function AppointmentServicesNode({ sectionHeading, services, pathname, className, }: AppointmentServicesNodeProps): React.ReactElement;
+export default AppointmentServicesNode;

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

@@ -1,4 +1,3 @@
-import React from 'react';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 export type EventPortalAuthCopy = Readonly<{
     title: string;
@@ -21,4 +20,4 @@ export declare function EventRegistrationSurface(props: Readonly<{
     buttonClass: string;
     supportEmail?: string;
     successMessage: string;
-}>): React.JSX.Element;
+}>): import("react").JSX.Element;

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

@@ -10,6 +10,8 @@ type TicketSelectionStepProps = {
     occurrenceContext?: OccurrenceContext | null;
     selectedAttendanceMode?: RegistrationAttendanceMode | null;
     onAttendanceModeChange?: (attendanceMode: RegistrationAttendanceMode) => void;
+    checkoutRecovery?: boolean;
+    onCheckoutRecovery?: () => void;
     ticketsCount: number;
     maxTickets: number;
     visibleTicketTypes?: ReturnType<typeof getVisibleTicketTypes>;

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

@@ -0,0 +1,14 @@
+import type { PublicEventPricingOptionAvailability } from '../../../../../../core/src/index';
+import type { EligibilityData, RegistrationEvent } from './types';
+/** Recovery may select held places; checkout still owns admission and payment validation. */
+export declare function checkoutRecoveryOptionAvailability(availability: PublicEventPricingOptionAvailability): PublicEventPricingOptionAvailability;
+/**
+ * A form-only projection for the explicit existing-checkout path. It permits
+ * collecting the original selection without claiming a new place is available.
+ * The public checkout service identifies the customer and remains the admission
+ * authority; no reservation/customer data is exposed through this projection.
+ */
+export declare function getCheckoutRecoveryFormEligibility(eligibility: EligibilityData | null): EligibilityData | null;
+export declare function isSoldOutEventSelectable(event: RegistrationEvent, waitlistAvailable: boolean): boolean;
+export declare function canJoinWaitlistOutsideRecovery(event: RegistrationEvent | null, attendanceMode: 'in_person' | 'online' | null, checkoutRecovery: boolean): boolean;
+export declare function canRecoverEventCheckout(event: RegistrationEvent | null): boolean;

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

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import type { PublicEvent } from '../../../blocks/events/shared/types';
+import type { PublicEventsRequest } from '../../api/types/events';
+export declare const eventRecoveryRequestSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    eventSurface: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        all: "all";
+        regularClassSchedule: "regularClassSchedule";
+        specialDatedEvents: "specialDatedEvents";
+    }>>;
+    scheduleScope: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        recurring: "recurring";
+        oneOff: "oneOff";
+    }>>;
+    detailLevel: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        listing: "listing";
+    }>>;
+    stage: z.ZodOptional<z.ZodEnum<{
+        published: "published";
+        preview: "preview";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    afterStartsAt: z.ZodOptional<z.ZodString>;
+    afterId: z.ZodOptional<z.ZodString>;
+    categoryIds: z.ZodOptional<z.ZodString>;
+    venueId: z.ZodOptional<z.ZodString>;
+    staffMemberId: z.ZodOptional<z.ZodString>;
+    eventPresets: z.ZodOptional<z.ZodString>;
+    seriesId: z.ZodOptional<z.ZodString>;
+    seriesIds: z.ZodOptional<z.ZodString>;
+    runSeriesId: z.ZodOptional<z.ZodString>;
+    seriesSlug: z.ZodOptional<z.ZodString>;
+    includeOccurrenceId: z.ZodOptional<z.ZodString>;
+    readIntent: z.ZodOptional<z.ZodString>;
+    readProfile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EventRecoveryRequest = Omit<PublicEventsRequest, 'siteId'>;
+export type EventRegistrationEventSource = Readonly<{
+    kind: 'loaded';
+    events: PublicEvent[];
+}> | Readonly<{
+    kind: 'unresolved';
+    request: EventRecoveryRequest | null;
+}>;
+type EventSourceInput = Readonly<{
+    events?: PublicEvent[] | null;
+    wholeSeriesRunEvents?: PublicEvent[] | null;
+    failures?: Readonly<Record<string, unknown>> | null;
+}>;
+export declare function resolveEventRegistrationEventSource(input: EventSourceInput): EventRegistrationEventSource;
+export declare function parseEventLoaderRecoveryRequest(value: unknown): EventRecoveryRequest | null;
+export {};

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

@@ -1,15 +1,13 @@
 import type { PublicEventPricing } from '../../../../../../core/src/index';
-import type { EventRegistrationPricingOption } from '../../../blocks/event-registration';
-import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAvailability } from '../../../blocks/events/shared/types';
+import type { EventRegistrationAvailablePaymentOption, EventRegistrationOptionsResponse, EventRegistrationPricingOption } from '../../../blocks/event-registration';
 import type { OccurrenceContext } from '../../../blocks/event-registration.shared';
-import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
-import type { PublicRunSession } from '../../../blocks/events/shared/types';
-import type { AvailablePass, AvailableMembership, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
+import type { PublicEvent, PublicEventPricingOption, PublicEventPricingOptionAvailability, PublicRunSession } from '../../../blocks/events/shared/types';
 import type { BlockBookingPaymentTerms } from '../../../blocks/shared/bookingPaymentTerms';
-import type { EventRegistrationPageSurfaceSubject } from './eventScope';
+import type { PublicMembershipProductCollection, PublicPassProductCollection } from '../../../blocks/shop.shared';
 import type { BlockButtonRole } from '../../../constants/buttonRoles';
-import type { EventRegistrationAvailablePaymentOption, EventRegistrationOptionsResponse } from '../../../blocks/event-registration';
-export type { PublicEvent, OccurrenceContext };
+import type { AvailableMembership, AvailablePass, DirectCheckoutCollectionOptionKind, EventTicketLineSummary } from '../../api/types';
+import type { EventRegistrationPageSurfaceSubject } from './eventScope';
+export type { OccurrenceContext, PublicEvent };
 export type { FormData } from '../../shared';
 /**
  * Guest details for additional attendees (when "collect all attendee details" is enabled)

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

@@ -0,0 +1,8 @@
+import type { EligibilityData, RegistrationEvent, RegistrationStep } from './types';
+/** Recovery belongs to the selected booking subject; changing events resets its scope. */
+export declare function useCheckoutRecovery(event: RegistrationEvent | null, setStep: (step: RegistrationStep) => void): {
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
+};
+/** Authenticated pending bookings enter the same form-only recovery path as guests. */
+export declare function useCheckoutRecoveryEligibility(eligibility: EligibilityData | null, step: RegistrationStep, checkoutRecovery: boolean, startCheckoutRecovery: () => void): EligibilityData | null;

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

@@ -1,10 +1,9 @@
-import type { BlockApiClient } from '../../api';
 import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
-import { savePendingRegistration } from './sessionStorage';
-import type { EventTicketSelectionLine, FormData, Guest, RegistrationResult, RegistrationStep, PaymentSelection } from './types';
-import type { PaymentMethod } from '../../api/types';
-import type { EventRegistrationStatusReference } from '../../api/types';
+import type { BlockApiClient } from '../../api';
+import type { EventRegistrationStatusReference, PaymentMethod } from '../../api/types';
 import type { RegistrationTarget } from './registrationDerivations';
+import { savePendingRegistration } from './sessionStorage';
+import type { EventTicketSelectionLine, FormData, Guest, PaymentSelection, RegistrationResult, RegistrationStep } from './types';
 export type EventRegistrationSubmitOptions = Readonly<{
     redirect?: 'auto' | 'manual';
 }>;
@@ -24,6 +23,7 @@ export type EventRegistrationSubmitResult = Readonly<{
     reason: 'blocked' | 'missing-target' | 'submission-failed';
     message: string;
 }>;
+export type EventRegistrationSubmit = (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
 export type UseEventRegistrationSubmitInput = {
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
@@ -36,6 +36,7 @@ export type UseEventRegistrationSubmitInput = {
     guests: Guest[];
     discountCode: string;
     claimToken: string | null;
+    waitlistEntryId?: string | null;
     setPendingRegistrationReference: (reference: EventRegistrationStatusReference) => void;
     setStep: (step: RegistrationStep) => void;
     setErrorAction?: (action: EventRegistrationErrorAction) => void;
@@ -55,6 +56,6 @@ type ClientCommandIdCryptoSource = Readonly<{
     getRandomValues: (bytes: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
 }>;
 export declare function createClientCommandId(cryptoSource?: ClientCommandIdCryptoSource): string;
-export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
-export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): EventRegistrationSubmit;
+export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): EventRegistrationSubmit;
 export {};

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

@@ -52,6 +52,8 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     scopedEvents: RegistrationEvent[];
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
     step: RegistrationStep;
     setStep: (nextStep: RegistrationStep) => void;
     selectedEvent: RegistrationEvent | null;
@@ -117,6 +119,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
     eligibility: EligibilityData | null;
+    registrationOptionsState: import("./hooks.state").EligibilityLookupState;
     eligibilityLoading: boolean;
     eligibilityError: string | null;
     existingRegistration: import("../../api").CustomerEventRegistration | null;
@@ -126,6 +129,8 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
         kind: "none";
     }> | Readonly<{
         kind: "booked";
+    }> | Readonly<{
+        kind: "pending_payment";
     }> | Readonly<{
         kind: "waitlisted";
     }>;
@@ -147,7 +152,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
+    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
     handleEventSelect: (event: RegistrationEvent) => void;
     handleRetry: () => void;
 };
@@ -173,6 +178,8 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     scopedEvents: RegistrationEvent[];
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
+    checkoutRecovery: boolean;
+    startCheckoutRecovery: () => void;
     step: RegistrationStep;
     setStep: (nextStep: RegistrationStep) => void;
     selectedEvent: RegistrationEvent | null;
@@ -238,6 +245,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
     eligibility: EligibilityData | null;
+    registrationOptionsState: import("./hooks.state").EligibilityLookupState;
     eligibilityLoading: boolean;
     eligibilityError: string | null;
     existingRegistration: import("../../api").CustomerEventRegistration | null;
@@ -247,6 +255,8 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
         kind: "none";
     }> | Readonly<{
         kind: "booked";
+    }> | Readonly<{
+        kind: "pending_payment";
     }> | Readonly<{
         kind: "waitlisted";
     }>;
@@ -268,7 +278,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
+    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
     handleEventSelect: (event: RegistrationEvent) => void;
     handleRetry: () => void;
 };

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

@@ -0,0 +1,18 @@
+import { useBlockApi } from '../../api';
+import type { PublicEvent } from '../../../blocks/events/shared/types';
+import type { EventRegistrationEventSource } from './eventSourceRecovery';
+export type EventSourceRecovery = Readonly<{
+    kind: 'ready';
+    events: PublicEvent[];
+}> | Readonly<{
+    kind: 'loading';
+}> | Readonly<{
+    kind: 'exhausted';
+    retry: () => void;
+}>;
+type RecoveryDeps = Readonly<{
+    useApi: typeof useBlockApi;
+    wait: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}>;
+export declare function useEventSourceRecovery(source: EventRegistrationEventSource, deps?: RecoveryDeps): EventSourceRecovery;
+export {};

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { EventRegistrationClientProps as InternalEventRegistrationClientProps } from './event-registration/types';
-import type { EventRegistrationInteractiveIslandProps } from './event-registration.interactive';
+import { type EventRegistrationInteractiveIslandProps } from './event-registration.interactive';
 export type { PublicEvent, OccurrenceContext } from './event-registration/types';
 export type EventRegistrationClientProps = InternalEventRegistrationClientProps;
 export type EventRegistrationIslandClientProps = EventRegistrationInteractiveIslandProps;

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

@@ -5,6 +5,7 @@ import type { OccurrenceContext } from '../../blocks/event-registration.shared';
 import type { EventRegistrationClientProps as InternalEventRegistrationClientProps } from './event-registration/types';
 import { type EventRegistrationPageSurfaceSubject } from './event-registration/eventScope';
 import { type InteractiveIslandProps } from '../../../contracts/islands';
+import { type EventRegistrationEventSource } from './event-registration/eventSourceRecovery';
 export declare const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS: readonly ["Date", "Tickets", "Details"];
 declare const EVENT_REGISTRATION_SHELL_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Details", "Payment"];
 export type EventRegistrationGenericShellStepLabels = typeof EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
@@ -19,6 +20,7 @@ export type EventRegistrationSourceProps = Readonly<{
     events?: PublicEvent[] | null;
     /** Runs for a whole-series page, loaded independently of the date page. */
     wholeSeriesRunEvents?: PublicEvent[] | null;
+    eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
     className?: string | null;
     buttonText?: string | null;
     maxTickets?: string | null;
@@ -48,7 +50,9 @@ export type EventRegistrationDisplay = Readonly<{
     titleText: string;
     bodyText: string;
 }>;
-export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'buttonText' | 'className'>>;
+export type EventRegistrationHydration = Readonly<Omit<InternalEventRegistrationClientProps, 'siteId' | 'stage' | 'buttonText' | 'className' | 'events'> & {
+    eventSource: EventRegistrationEventSource;
+}>;
 type EventRegistrationIslandMeta = Readonly<{
     siteId?: string;
     apiBaseUrl?: string;
@@ -56,7 +60,7 @@ type EventRegistrationIslandMeta = Readonly<{
     previewToken?: string | null;
     stage?: 'preview' | 'published';
 }>;
-export declare function buildEventRegistrationDisplay(source: EventRegistrationSourceProps): EventRegistrationDisplay;
+export declare function buildEventRegistrationDisplayFromScopedEvents(source: EventRegistrationSourceProps, scopedSourceEvents: readonly PublicEvent[]): EventRegistrationDisplay;
 export type EventRegistrationInteractiveIslandProps = InteractiveIslandProps<EventRegistrationIslandMeta, 'event-registration', typeof eventRegistrationBlockRuntime>;
 export declare const eventRegistrationBlockRuntime: Readonly<{
     kind: "client-owned";
@@ -70,6 +74,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         events?: PublicEvent[] | null;
         /** Runs for a whole-series page, loaded independently of the date page. */
         wholeSeriesRunEvents?: PublicEvent[] | null;
+        eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
         className?: string | null;
         buttonText?: string | null;
         maxTickets?: string | null;
@@ -89,7 +94,9 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         }> | null;
     }>) => Readonly<{
         display: EventRegistrationDisplay;
-        hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+        hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+            eventSource: EventRegistrationEventSource;
+        }>;
     }>;
     contracts: Readonly<{
         source: Readonly<{
@@ -103,6 +110,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 events?: PublicEvent[] | null;
                 /** Runs for a whole-series page, loaded independently of the date page. */
                 wholeSeriesRunEvents?: PublicEvent[] | null;
+                eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
                 className?: string | null;
                 buttonText?: string | null;
                 maxTickets?: string | null;
@@ -131,6 +139,7 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
                 events?: PublicEvent[] | null;
                 /** Runs for a whole-series page, loaded independently of the date page. */
                 wholeSeriesRunEvents?: PublicEvent[] | null;
+                eventLoaderFailures?: Readonly<Record<string, unknown>> | null;
                 className?: string | null;
                 buttonText?: string | null;
                 maxTickets?: string | null;
@@ -153,11 +162,15 @@ export declare const eventRegistrationBlockRuntime: Readonly<{
         render: Readonly<{
             encode: (value: Readonly<{
                 display: EventRegistrationDisplay;
-                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                    eventSource: EventRegistrationEventSource;
+                }>;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
                 display: EventRegistrationDisplay;
-                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+                hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                    eventSource: EventRegistrationEventSource;
+                }>;
             }>>;
         }>;
     }>;
@@ -175,7 +188,9 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
             mode: "event-registration";
         } & Readonly<{
             display: EventRegistrationDisplay;
-            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                eventSource: EventRegistrationEventSource;
+            }>;
         }>>;
     }>) => unknown;
     decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<Readonly<{
@@ -190,7 +205,9 @@ export declare const eventRegistrationInteractiveIslandPropsCodec: Readonly<{
             mode: "event-registration";
         } & Readonly<{
             display: EventRegistrationDisplay;
-            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "buttonText">>;
+            hydration: Readonly<Omit<InternalEventRegistrationClientProps, "siteId" | "stage" | "className" | "events" | "buttonText"> & {
+                eventSource: EventRegistrationEventSource;
+            }>;
         }>>;
     }>>;
 }>;

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

@@ -1,13 +1,15 @@
 import React from 'react';
 import { type EventRegistrationSourceProps } from './event-registration.interactive';
-type EventRegistrationProps = Omit<EventRegistrationSourceProps, 'subject'> & Readonly<{
+import type { BlockLoaderFailures } from '../../data/types';
+type EventRegistrationProps = Omit<EventRegistrationSourceProps, 'subject' | 'eventLoaderFailures'> & Readonly<{
     blockId?: string | null;
     children?: React.ReactNode;
     subject?: unknown;
+    loaderFailures?: BlockLoaderFailures | null;
 }>;
 /**
  * Server-safe placeholder for event registration.
  * Provides a static container for island hydration without importing client hooks.
  */
-export declare function EventRegistrationSSR({ blockId, subject, children, ...sourceProps }: EventRegistrationProps): React.JSX.Element;
+export declare function EventRegistrationSSR({ blockId, subject, loaderFailures, children, ...sourceProps }: EventRegistrationProps): React.JSX.Element;
 export default EventRegistrationSSR;

package/dist/_dts/blocks/src/system/runtime/nodes/events/EventCombined.client.d.ts

@@ -1,9 +1,12 @@
 import React from "react";
 import type { PublicEvent, ButtonVariant, EventLayout, ColumnOption, WeekStart, CalendarTabViews, FilterAutoShow, CalendarView, EventScheduleScope, EventSurfaceScope } from "../../../blocks/events/shared/types";
 import type { CardRole } from "../../../../../../theme-core/src/cards/index";
+import { type CalendarViewLoadState } from "../../hooks/useCalendarEvents";
 import type { EventCombinedInteractiveIslandProps } from "./EventCombined.interactive";
 import type { EventCollectionHydration } from './shared/eventCollectionContract';
+import { type CalendarDate, type CalendarViewport } from "./shared";
 import { type EventListPaginationAction, type EventPageSize } from "./shared/listOptions";
+import { type CalendarViewToggleOption } from "./shared/calendarViewOptions";
 export type EventCombinedClientProps = Readonly<{
     events?: PublicEvent[] | null;
     siteId: string;
@@ -37,6 +40,31 @@ export type EventCombinedClientProps = Readonly<{
     calendarWindow?: EventCollectionHydration['calendarWindow'];
 }>;
 export type EventCombinedIslandClientProps = EventCombinedInteractiveIslandProps;
+type EventCombinedCalendarTabProps = Readonly<{
+    calendarTabViews: CalendarTabViews;
+    calendarView: CalendarView;
+    calendarViewOptions: readonly CalendarViewToggleOption[];
+    onCalendarViewChange: (view: CalendarView) => void;
+    calendarEvents: PublicEvent[];
+    eventsByDate: Map<string, PublicEvent[]>;
+    viewDate: CalendarDate;
+    viewport: CalendarViewport;
+    calendarLoadState: CalendarViewLoadState;
+    dayNames: readonly string[];
+    calendarContext: EventCollectionHydration["calendarContext"];
+    today: CalendarDate;
+    goToPrevious: () => void;
+    goToNext: () => void;
+    goToToday: () => void;
+    emptyMessage: string;
+    showCapacity: boolean;
+    showVenue: boolean;
+    cardRole: CardRole;
+    buttonVariant: ButtonVariant;
+    buttonText: string;
+    showEmptyState: boolean;
+}>;
+export declare const EventCombinedCalendarTab: React.FC<EventCombinedCalendarTabProps>;
 /**
  * EventCombined Component
  *

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/bookability.d.ts

@@ -0,0 +1,9 @@
+import type { PublicEvent } from '../../../../blocks/events/shared/types';
+/**
+ * Whether a public event has a registration path a visitor can take.
+ *
+ * Lifecycle admission comes from the public booking-availability contract;
+ * capacity comes from the shared event-domain helpers so uncapped, fallback,
+ * and hybrid attendance-mode cases agree with the registration runtime.
+ */
+export declare function isBookableEvent(event: PublicEvent): boolean;

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/dates.d.ts

@@ -11,6 +11,8 @@ type DateTimeFormatOptions = {
     timeZone?: string | null;
     locale?: string;
 };
+/** Use the event timezone when present, otherwise the calendar/site timezone. */
+export declare function resolveEventTimeZone(event: Pick<PublicEvent, 'timeZone'>, calendarTimeZone: string): string;
 /**
  * Format date for display.
  * Returns: "Monday, January 15, 2025"
@@ -36,7 +38,19 @@ export type EventCompactDateRail = Readonly<{
     month: string;
     label: string;
 }>;
+export type EventNextDateFact = Readonly<{
+    dateTime: string;
+    value: string;
+    label: string;
+}>;
 export declare function formatEventCompactDateRail(isoTimestamp: string, options?: DateTimeFormatOptions): EventCompactDateRail;
+/**
+ * Format the next occurrence for the image-free catalogue card treatment.
+ *
+ * The compact rail already owns this short, booking-local date vocabulary;
+ * keep the fact panel on the same date and timezone rules as event rows.
+ */
+export declare function formatEventNextDateFact(event: Pick<PublicEvent, 'startsAt' | 'timeZone'>): EventNextDateFact;
 export { addDays, addMonths, buildCalendarViewport, formatCalendarTitle, formatDateKey, getEndOfMonth, getMonthCalendarDays, getOrderedDayNames, getStartOfMonth, getWeekCalendarDays, getWeekCalendarDayTuple, isToday, MAX_EVENTS_PER_DAY, shiftCalendarAnchorDate, } from '../../../../../../../calendar/src/index';
 export type { CalendarDate, CalendarViewport, CalendarViewportKind, MonthCalendarViewport, WeekCalendarDays, WeekCalendarViewport, } from '../../../../../../../calendar/src/index';
 /**

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/duration.d.ts

@@ -0,0 +1,2 @@
+import type { PublicEvent } from '../../../../blocks/events/shared/types';
+export declare function formatEventDuration(event: Pick<PublicEvent, 'startsAt' | 'endsAt'>): string;

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/index.d.ts

@@ -7,8 +7,12 @@
  * Components in ../shared and the registration wizard import from this barrel.
  */
 export * from './capacity';
+export * from './bookability';
 export * from './cta';
 export * from './dates';
 export * from './destination';
+export * from './duration';
+export * from './location';
 export * from './people';
 export * from './pricing';
+export * from './quickDates';

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/location.d.ts

@@ -0,0 +1,2 @@
+import type { PublicEvent } from '../../../../blocks/events/shared/types';
+export declare function formatEventLocation(event: Pick<PublicEvent, 'deliveryMode' | 'venue'>): string;

package/dist/_dts/blocks/src/system/runtime/nodes/events/domain/quickDates.d.ts

@@ -0,0 +1,16 @@
+import type { PublicEvent } from '../../../../blocks/events/shared/types';
+export declare const QUICK_EVENT_DATE_LIMIT = 4;
+export type EventQuickDateFact = Readonly<{
+    dateTime: string;
+    label: string;
+}>;
+/**
+ * Select the next occurrence-targeted events for a quick-book rail.
+ *
+ * The API normally returns valid timestamps, but malformed values sort after
+ * valid events so one bad record cannot displace an otherwise useful rail.
+ * Sorting before deduplication means a duplicate occurrence keeps its earliest
+ * deterministic representation.
+ */
+export declare function selectQuickDateEvents(events: readonly PublicEvent[]): readonly PublicEvent[];
+export declare function formatEventQuickDate(event: Pick<PublicEvent, 'startsAt' | 'timeZone'>): EventQuickDateFact;

package/dist/_dts/blocks/src/system/runtime/nodes/events/shared/AgendaEventCard.d.ts

@@ -1,9 +1,17 @@
 import React from 'react';
-import type { PublicEvent } from '../../../../blocks/events/shared/types';
+import type { ButtonVariant, PublicEvent } from '../../../../blocks/events/shared/types';
 type AgendaEventCardProps = {
     event: PublicEvent;
     /** Whether to render the capacity indicator. */
     showCapacity: boolean;
+    /** Whether the published agenda row should include its public location. */
+    showVenue?: boolean;
+    /** Theme button role used by the agenda booking action. */
+    buttonVariant?: ButtonVariant;
+    /** Optional override for the canonical booking action label. */
+    buttonText?: string;
+    /** Calendar/site timezone used when legacy events omit their own timezone. */
+    calendarTimeZone: string;
     /** When provided, renders as button and calls onClick instead of navigating */
     onClick?: (event: PublicEvent) => void;
 };