@riverbankcms/sdk 0.135.1 → 0.137.0

package/dist/_dts/blocks/src/system/manifest/fieldValidation/index.d.ts

@@ -143,21 +143,6 @@ type BaseIssue<K extends string, Extra extends object = Record<never, never>> =
     fieldId: string;
     label: string;
 }> & Readonly<Extra>;
-export type ManifestContentRequiredScope = "topLevel" | "nested";
-export type ManifestContentValidationIssue = Readonly<{
-    kind: FieldValidationIssue["kind"];
-    field: string;
-    message: string;
-    requiredScope: ManifestContentRequiredScope | null;
-}>;
-export type ManifestContentValidationResult = Readonly<{
-    kind: 'valid';
-    issues: readonly [];
-    data: Readonly<Record<string, unknown>>;
-}> | Readonly<{
-    kind: "invalid";
-    issues: readonly ManifestContentValidationIssue[];
-}>;
 type PlanBase<K extends string, ValueKind extends string, Constraints extends FieldConstraint> = Readonly<{
     kind: K;
     valueKind: ValueKind;
@@ -265,11 +250,10 @@ export declare function validateFieldValue(plan: FieldValidationPlan, value: unk
 export declare function fieldPlanToZod(plan: FieldValidationPlan, options?: FieldValidationOptions): z.ZodTypeAny;
 export declare function fieldPresenceForPlan(plan: Pick<FieldValidationPlan, "required">): FieldPresence;
 export declare function fieldPlanToObjectPropertyZod(plan: FieldValidationPlan, options?: FieldValidationOptions): z.ZodTypeAny;
+/** Validate stored field values without applying editor/write normalization. */
+export declare function fieldPlanToStoredObjectPropertyZod(plan: FieldValidationPlan): z.ZodTypeAny;
 export declare function resolveFieldValidationDescriptor(plans: readonly FieldValidationPlan[], path: FieldPath): FieldValidationDescriptor | null;
 export declare function validateManifestValues(fields: readonly FieldDefinition[], values: Record<string, unknown>, options?: FieldValidationOptions): FieldValidationIssue[];
-export declare function validateManifestContentForPush(fields: readonly FieldDefinition[], values: Record<string, unknown>, options?: FieldValidationOptions): ManifestContentValidationResult;
-export declare function isTopLevelRequiredManifestContentIssue(issue: ManifestContentValidationIssue): boolean;
-export declare function formatManifestContentValidationIssue(issue: ManifestContentValidationIssue): string;
 export declare function isCanonicalEmailValue(value: string): boolean;
 export declare function isCanonicalPhoneValue(value: string): boolean;
 export declare function isCanonicalUrlValue(value: string, options?: Readonly<{

package/dist/_dts/blocks/src/system/manifest/validation.d.ts

@@ -1,6 +1,69 @@
-import { z } from "zod";
-import type { BlockManifest, FieldDefinition } from "./schema";
+import { z } from 'zod';
+import type { BlockManifest, FieldDefinition } from './schema';
+import { type FieldValidationDescriptor, type FieldValidationPlan } from './fieldValidation';
 type FieldShape = Record<string, z.ZodTypeAny>;
+declare const manifestContentStage: unique symbol;
+declare const compiledManifestContentContract: unique symbol;
+type CompiledManifestContentContractState = Readonly<{
+    plans: readonly FieldValidationPlan[];
+    strictStoredSchema: z.ZodType<Record<string, unknown>>;
+    writeSchema: z.ZodType<Record<string, unknown>>;
+    draftSchema: z.ZodType<Record<string, unknown>>;
+    renderSchema: z.ZodType<Record<string, unknown>>;
+    findNonPortableMediaPaths: (content: unknown) => readonly string[];
+}>;
+export type CompiledManifestContentContract = Readonly<{
+    [compiledManifestContentContract]: CompiledManifestContentContractState;
+}>;
+export type StoredManifestContent = Readonly<Record<string, unknown>> & Readonly<{
+    [manifestContentStage]: 'stored';
+}>;
+export type RenderableManifestContent = Readonly<Record<string, unknown>> & Readonly<{
+    [manifestContentStage]: 'renderable';
+}>;
+export type ManifestContentAdmissionIssue = Readonly<{
+    code: z.core.$ZodIssue['code'];
+    path: readonly (string | number)[];
+    message: string;
+}>;
+export type ManifestContentAdmissionError = Readonly<{
+    kind: 'invalid_shape';
+    issues: readonly ManifestContentAdmissionIssue[];
+}> | Readonly<{
+    kind: 'non_portable_media';
+    paths: readonly string[];
+}>;
+export type ManifestContentAdmissionResult<T> = Readonly<{
+    ok: true;
+    value: T;
+}> | Readonly<{
+    ok: false;
+    error: ManifestContentAdmissionError;
+}>;
+export type ManifestDraftValidationResult = Readonly<{
+    kind: 'previewable';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'invalid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [
+        ManifestContentAdmissionIssue,
+        ...ManifestContentAdmissionIssue[]
+    ];
+}>;
+export type ManifestWriteCandidateValidationResult = Readonly<{
+    kind: 'valid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'invalid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [
+        ManifestContentAdmissionIssue,
+        ...ManifestContentAdmissionIssue[]
+    ];
+}>;
 type ValidatorOptions = {
     allowNull?: boolean;
     /**
@@ -8,22 +71,46 @@ type ValidatorOptions = {
      * Use for autosave scenarios where content may be incomplete.
      */
     allowIncomplete?: boolean;
-    /**
-     * Validation mode:
-     * - 'strict' (default): Enforce all required field constraints
-     * - 'draft': Preprocess empty values to undefined, use allowIncomplete for lenient validation
-     *
-     * Use 'draft' mode in preview/editing contexts where users need to temporarily
-     * have empty fields without validation errors causing blocks to disappear.
-     */
-    mode?: "strict" | "draft";
 };
 export declare function deriveContentZodFromManifest(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodObject<FieldShape>;
-export declare function createManifestValidator(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodType<Record<string, unknown>>;
 /**
- * Validates content at a persistence boundary and returns identifier-only media
- * values. Render-time validation intentionally uses createManifestValidator so
- * hydrated projection fields remain available to renderers.
+ * Compiles editor-facing manifest structure into the presentation-independent
+ * validation contract used by every manifest-content trust transition.
+ */
+export declare function compileManifestContentContract(manifestOrFields: BlockManifest | FieldDefinition[]): CompiledManifestContentContract;
+export declare function resolveManifestContentFieldDescriptor(contract: CompiledManifestContentContract, path: readonly (string | number)[]): FieldValidationDescriptor | null;
+/**
+ * Reports declared media fields carrying environment-specific keys.
+ *
+ * Split out of stored admission for callers that must prove portability of
+ * content whose *shape* is legitimately incomplete — a template block's stored
+ * defaults, for instance, where required values only arrive through entry
+ * bindings. Returns the offending paths, empty when the content is portable.
+ */
+export declare function findNonPortableManifestMediaPaths(contract: CompiledManifestContentContract, content: unknown): readonly string[];
+/** Strictly admits already-persisted content without repairing it. */
+export declare function admitStoredManifestContent(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<StoredManifestContent>;
+/**
+ * Admits an effectfully resolved write candidate and canonicalizes declared
+ * media to its portable identifier-only representation.
+ */
+export declare function admitManifestContentForWrite(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<StoredManifestContent>;
+/** Validates raw editor state without granting a stored-content proof. */
+export declare function validateManifestDraft(contract: CompiledManifestContentContract, data: Readonly<Record<string, unknown>>): ManifestDraftValidationResult;
+/**
+ * Checks whether a raw editor candidate is schema-ready for the effectful
+ * media-resolution/write boundary without granting a stored proof.
+ */
+export declare function validateManifestWriteCandidate(contract: CompiledManifestContentContract, data: Readonly<Record<string, unknown>>): ManifestWriteCandidateValidationResult;
+/**
+ * Applies a pure runtime projection to admitted stored content and validates
+ * the resulting render shape before granting the renderable proof.
+ */
+export declare function deriveRenderableManifestContent(contract: CompiledManifestContentContract, stored: StoredManifestContent, project: (content: StoredManifestContent) => Readonly<Record<string, unknown>>): ManifestContentAdmissionResult<RenderableManifestContent>;
+/**
+ * Re-admits renderable content after a transport boundary has erased its
+ * compile-time proof. Unlike write admission, this never canonicalizes or
+ * grants a stored proof, so hydrated media cannot flow back to persistence.
  */
-export declare function createManifestWriteValidator(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodType<Record<string, unknown>>;
+export declare function admitTransportedRenderableManifestContent(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<RenderableManifestContent>;
 export {};

package/dist/_dts/blocks/src/system/node/validation-constants.d.ts

@@ -20,7 +20,7 @@ export type AllowedNodeType = (typeof ALLOWED_NODE_TYPES)[number];
  * $bind.transforms within custom block layouts. Transform IDs
  * not in this list will be rejected during validation.
  */
-export declare const ALLOWED_TRANSFORM_IDS: readonly ["string.uppercase", "value.fallback", "date.formatShort", "array.length", "value.jsonArray", "value.csv", "array.marqueeLoop", "value.mapToken", "layout.maxWidthClass", "layout.headerRootClass", "layout.footerRootClass", "layout.headerRootStyle", "layout.headerSectionBackground", "layout.classicNavMode", "layout.footerRootStyle", "ui.headerNavLinkClass", "ui.headingClassFromAlignment", "ui.bodyClassFromAlignment", "ui.stackAlignFromAlignment", "ui.sectionStateTone", "ui.heroContentWrapperClass", "ui.heroCtaJustify", "ui.heroStackJustifyFromVerticalAlignment", "ui.heroGridClassFromVerticalAlignment", "ui.conditionalClass", "ui.twoColumnContainerClass", "ui.twoColumnFlexBasis", "ui.imageGalleryFilterClass", "ui.imageGalleryTileClass", "ui.imageGalleryTileStyle", "ui.imageGalleryMarqueeTileStyle", "ui.imageGalleryMarqueeDuration", "ui.imageGalleryMarqueeDirection", "ui.imageFragmentClass", "ui.imageFragmentSize", "media.fromUrl", "background.resolveStyle", "background.resolveColorsStyle", "background.resolveFrameClassName", "background.resolveImageStyle", "background.resolveImageClassName", "background.resolveOverlayStyle", "links.resolve", "links.label", "content.interpolateRichTextTokens", "boxStyles.spacing", "boxStyles.resolveRootClass", "boxStyles.resolveRootStyle", "boxStyles.semanticGap", "boxStyles.semanticGapValue", "containerStyles.resolveBoxClassName"];
+export declare const ALLOWED_TRANSFORM_IDS: readonly ["string.uppercase", "value.fallback", "date.formatShort", "array.length", "value.jsonArray", "value.csv", "array.marqueeLoop", "value.mapToken", "layout.maxWidthClass", "layout.headerRootClass", "layout.footerRootClass", "layout.headerRootStyle", "layout.headerSectionBackground", "layout.footerRootStyle", "ui.headerNavLinkClass", "ui.headingClassFromAlignment", "ui.bodyClassFromAlignment", "ui.stackAlignFromAlignment", "ui.sectionStateTone", "ui.heroContentWrapperClass", "ui.heroCtaJustify", "ui.heroStackJustifyFromVerticalAlignment", "ui.heroGridClassFromVerticalAlignment", "ui.conditionalClass", "ui.twoColumnContainerClass", "ui.twoColumnFlexBasis", "ui.imageGalleryFilterClass", "ui.imageGalleryTileClass", "ui.imageGalleryTileStyle", "ui.imageGalleryMarqueeTileStyle", "ui.imageGalleryMarqueeDuration", "ui.imageGalleryMarqueeDirection", "ui.imageFragmentClass", "ui.imageFragmentSize", "media.fromUrl", "background.resolveStyle", "background.resolveColorsStyle", "background.resolveFrameClassName", "background.resolveImageStyle", "background.resolveImageClassName", "background.resolveOverlayStyle", "links.resolve", "links.label", "content.interpolateRichTextTokens", "boxStyles.spacing", "boxStyles.resolveRootClass", "boxStyles.resolveRootStyle", "boxStyles.semanticGap", "boxStyles.semanticGapValue", "containerStyles.resolveBoxClassName"];
 export type AllowedTransformId = (typeof ALLOWED_TRANSFORM_IDS)[number];
 /**
  * Set for O(1) lookup of allowed node types.

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

@@ -3,7 +3,7 @@
  *
  * Factory function for creating a typed API client for block client-side API calls.
  */
-import type { BlockApiConfig, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, BookingSubmitRequest, BookingPackageSubmitRequest, BookingSubmitResponse, EligibleAppointmentPackagesResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, WeeklySlotAvailabilityRequest, WeeklySlotAvailabilityResponse, AvailableDatesRequest, AvailableDatesResponse, BookingServicesResponse, BookingServiceResponse, BookingResourcesResponse, PublicEventsRequest, PublicEvent, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, RegistrationOptionsRequest, RegistrationOptionsResponse, EventRegistrationStatusRequest, EventRegistrationStatusResponse, ResolveWaitlistClaimRequest, ResolveWaitlistClaimResponse, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyRequest, DiscountApplyResponse, PublicProductsResponse, ShopCheckoutRequest, ShopCheckoutResponse, UnifiedCheckoutRequest, UnifiedCheckoutResponse, PublicGiftingOffersResponse, CreateGiftingCheckoutRequest, CreateGiftingCheckoutResponse, ClaimGiftCardRequest, ClaimGiftCardResponse, PortalMeResponse, CustomerProfile, CustomerOrder, PortalMeUpdateRequest, CustomerPass, CustomerMembership, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, BookingQuestionsTaskDetail, CustomerEventSeriesRegistration, PortalCredit, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalDigitalProductsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateEventBookingQuestionsRequest, PortalCancelEventRegistrationRequest, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, EventGuest, UpdateEventGuestsRequest, NewsletterSubscribeRequest, NewsletterSubscribeResponse } from './types';
+import type { BlockApiConfig, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, BookingSubmitRequest, BookingPackageSubmitRequest, BookingSubmitResponse, EligibleAppointmentPackagesResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, WeeklySlotAvailabilityRequest, WeeklySlotAvailabilityResponse, AvailableDatesRequest, AvailableDatesResponse, BookingServicesResponse, BookingServiceResponse, BookingResourcesResponse, PublicEventsRequest, PublicEvent, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, RegistrationOptionsRequest, RegistrationOptionsResponse, EventRegistrationStatusRequest, EventRegistrationStatusResponse, EventCheckoutReturnRequest, EventCheckoutReturnResponse, ResolveWaitlistClaimRequest, ResolveWaitlistClaimResponse, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyRequest, DiscountApplyResponse, PublicProductsResponse, ShopCheckoutRequest, ShopCheckoutResponse, UnifiedCheckoutRequest, UnifiedCheckoutResponse, PublicGiftingOffersResponse, CreateGiftingCheckoutRequest, CreateGiftingCheckoutResponse, ClaimGiftCardRequest, ClaimGiftCardResponse, PortalMeResponse, CustomerProfile, CustomerOrder, PortalMeUpdateRequest, CustomerPass, CustomerMembership, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, BookingQuestionsTaskDetail, CustomerEventSeriesRegistration, PortalCredit, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalDigitalProductsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateEventBookingQuestionsRequest, PortalCancelEventRegistrationRequest, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, EventGuest, UpdateEventGuestsRequest, NewsletterSubscribeRequest, NewsletterSubscribeResponse } from './types';
 type WithoutSiteId<T> = T extends unknown ? Omit<T, 'siteId'> : never;
 type PublicProductCategorySelector = Readonly<{
     kind: 'category';
@@ -18,7 +18,8 @@ type PublicProductCategorySelector = Readonly<{
 export declare class BlockApiError extends Error {
     readonly status: number;
     readonly code?: string | undefined;
-    constructor(message: string, status: number, code?: string | undefined);
+    readonly tag?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined, tag?: string | undefined);
 }
 /**
  * Block API Client interface
@@ -49,6 +50,7 @@ export interface BlockApiClient {
     createEventCheckout(data: WithoutSiteId<EventCheckoutRequest>): Promise<EventCheckoutResponse>;
     getRegistrationOptions(data: Omit<RegistrationOptionsRequest, 'siteId'>): Promise<RegistrationOptionsResponse>;
     getEventRegistrationStatus(params: WithoutSiteId<EventRegistrationStatusRequest>): Promise<EventRegistrationStatusResponse>;
+    resolveEventCheckoutReturn(data: EventCheckoutReturnRequest): Promise<EventCheckoutReturnResponse>;
     resolveWaitlistClaim(data: Omit<ResolveWaitlistClaimRequest, 'siteId'>): Promise<ResolveWaitlistClaimResponse>;
     getDiscountsAvailable(data: Omit<DiscountsAvailableRequest, 'siteId'>): Promise<DiscountsAvailableResponse>;
     applyDiscountCode(data: Omit<DiscountApplyRequest, 'siteId'>): Promise<DiscountApplyResponse>;

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

@@ -101,6 +101,10 @@ export declare const EVENTS: {
         path: string;
         method: "GET";
     };
+    checkoutReturn: {
+        path: string;
+        method: "POST";
+    };
 };
 export declare const WHOLE_SERIES: {
     list: {
@@ -428,6 +432,10 @@ export declare const ENDPOINTS: {
             path: string;
             method: "GET";
         };
+        checkoutReturn: {
+            path: string;
+            method: "POST";
+        };
     };
     readonly wholeSeries: {
         list: {

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

@@ -43,7 +43,7 @@ export { createBlockApi, BlockApiError } from './client';
 export type { BlockApiClient } from './client';
 export { BlockApiProvider, useBlockApi, useBlockApiOptional } from './context';
 export type { BlockApiProviderProps } from './context';
-export type { BlockApiConfig, BlockApiAuth, ApiKeyAuth, BearerAuth, NoAuth, ApiResponse, ApiSuccessResponse, ApiErrorResponse, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, FormField, BookingSubmitRequest, BookingSubmitResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, TimeSlot, AvailableDatesRequest, AvailableDatesResponse, BookingService, BookingServicesRequest, BookingServicesResponse, BookingServiceResponse, BookingResource, BookingResourcesRequest, BookingResourcesResponse, PublicEvent, PublicEventsRequest, PublicEventsResponse, EventVenue, PricingType, AccessRestriction, EventFilterCategory, EventFilterStaffMember, EventFilterVenue, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, PaymentMethod, EligiblePass, EligibleMembership, AvailablePass, AvailableMembership, DiscountContext, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyLine, DiscountApplyRequest, DiscountApplyRejectedReason, DiscountApplyResponse, ShopCheckoutRequest, ShopCheckoutResponse, ShopDuplicateMembershipWarning, CustomerProfile, CustomerOrder, CustomerOrderFilter, CustomerOrderItem, CustomerOrderInstalmentPlan, CustomerOrderInstalmentPlanStatus, CustomerOrderInstalmentRow, CustomerOrderInstalmentStatus, CustomerOrderPaymentState, CustomerOrderRefund, EnabledModules, PortalMeResponse, PortalMeUpdateRequest, CustomerPass, CustomerPassCreditHistoryEntry, CustomerMembership, EventTicketBreakdownLine, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, AppointmentBookingQuestionsTaskDetail, BookingQuestionsTaskDetail, BookingQuestionsAnswerValue, BookingQuestionsField, BookingQuestionsFieldOption, BookingQuestionsSection, BeforeYouComeTaskSummary, CustomerEventSeriesRegistration, EventGuest, PortalCredit, PortalCreditSummary, PortalCreditTransaction, PortalCreditResponse, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProduct, PortalDigitalProductFile, PortalDigitalProductsResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalAppointmentBookingQuestionsResponse, PortalCreateAppointmentBookingQuestionsUploadUrlRequest, PortalCreateAppointmentBookingQuestionsUploadUrlResponse, PortalFinalizeAppointmentBookingQuestionsUploadRequest, PortalFinalizeAppointmentBookingQuestionsUploadResponse, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateAppointmentBookingQuestionsResponse, PortalEventBookingQuestionsResponse, PortalCreateEventBookingQuestionsUploadUrlRequest, PortalCreateEventBookingQuestionsUploadUrlResponse, PortalFinalizeEventBookingQuestionsUploadRequest, PortalFinalizeEventBookingQuestionsUploadResponse, PortalUpdateEventBookingQuestionsRequest, PortalUpdateEventBookingQuestionsResponse, PortalWholeSeriesBookingQuestionsResponse, PortalCreateWholeSeriesBookingQuestionsUploadUrlRequest, PortalCreateWholeSeriesBookingQuestionsUploadUrlResponse, PortalFinalizeWholeSeriesBookingQuestionsUploadRequest, PortalFinalizeWholeSeriesBookingQuestionsUploadResponse, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsResponse, UpdateEventGuestsRequest, EventGuestsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalCancelEventRegistrationRequest, PortalRefundInfo, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, } from './types';
+export type { BlockApiConfig, BlockApiAuth, ApiKeyAuth, BearerAuth, NoAuth, ApiResponse, ApiSuccessResponse, ApiErrorResponse, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, FormField, BookingSubmitRequest, BookingSubmitResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, TimeSlot, AvailableDatesRequest, AvailableDatesResponse, BookingService, BookingServicesRequest, BookingServicesResponse, BookingServiceResponse, BookingResource, BookingResourcesRequest, BookingResourcesResponse, PublicEvent, PublicEventsRequest, PublicEventsResponse, EventVenue, PricingType, AccessRestriction, EventFilterCategory, EventFilterStaffMember, EventFilterVenue, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, EventCheckoutReturnRequest, EventCheckoutReturnResponse, PaymentMethod, EligiblePass, EligibleMembership, AvailablePass, AvailableMembership, DiscountContext, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyLine, DiscountApplyRequest, DiscountApplyRejectedReason, DiscountApplyResponse, ShopCheckoutRequest, ShopCheckoutResponse, ShopDuplicateMembershipWarning, CustomerProfile, CustomerOrder, CustomerOrderFilter, CustomerOrderItem, CustomerOrderInstalmentPlan, CustomerOrderInstalmentPlanStatus, CustomerOrderInstalmentRow, CustomerOrderInstalmentStatus, CustomerOrderPaymentState, CustomerOrderRefund, EnabledModules, PortalMeResponse, PortalMeUpdateRequest, CustomerPass, CustomerPassCreditHistoryEntry, CustomerMembership, EventTicketBreakdownLine, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, AppointmentBookingQuestionsTaskDetail, BookingQuestionsTaskDetail, BookingQuestionsAnswerValue, BookingQuestionsField, BookingQuestionsFieldOption, BookingQuestionsSection, BeforeYouComeTaskSummary, CustomerEventSeriesRegistration, EventGuest, PortalCredit, PortalCreditSummary, PortalCreditTransaction, PortalCreditResponse, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProduct, PortalDigitalProductFile, PortalDigitalProductsResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalAppointmentBookingQuestionsResponse, PortalCreateAppointmentBookingQuestionsUploadUrlRequest, PortalCreateAppointmentBookingQuestionsUploadUrlResponse, PortalFinalizeAppointmentBookingQuestionsUploadRequest, PortalFinalizeAppointmentBookingQuestionsUploadResponse, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateAppointmentBookingQuestionsResponse, PortalEventBookingQuestionsResponse, PortalCreateEventBookingQuestionsUploadUrlRequest, PortalCreateEventBookingQuestionsUploadUrlResponse, PortalFinalizeEventBookingQuestionsUploadRequest, PortalFinalizeEventBookingQuestionsUploadResponse, PortalUpdateEventBookingQuestionsRequest, PortalUpdateEventBookingQuestionsResponse, PortalWholeSeriesBookingQuestionsResponse, PortalCreateWholeSeriesBookingQuestionsUploadUrlRequest, PortalCreateWholeSeriesBookingQuestionsUploadUrlResponse, PortalFinalizeWholeSeriesBookingQuestionsUploadRequest, PortalFinalizeWholeSeriesBookingQuestionsUploadResponse, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsResponse, UpdateEventGuestsRequest, EventGuestsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalCancelEventRegistrationRequest, PortalRefundInfo, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, } from './types';
 export { discountAvailabilityAllowsManualEntry, discountAvailabilityHasDiscounts, getAutoAppliedDiscountPreview, } from './types';
 export type { BookingQuestionsDocumentAnswerValue } from '../../../portal/types';
 export { deriveCreditProductLabels, getCreditProductCreditUnit, getCreditProductTypeLabel, getPortalCreditProductCreditNoun, } from './creditProducts';

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

@@ -207,6 +207,7 @@ export type EventCheckoutRequest = EventCheckoutRequestCommon & ({
     altchaSolution?: string | null;
     guests?: EventRegisterGuest[];
     claimToken?: string;
+    checkoutAttemptId: string;
 });
 export type EventCheckoutResponse = {
     scope: 'occurrence';
@@ -278,4 +279,22 @@ export interface EventRegistrationStatusResponse {
     attendeeStatus: AttendeeStatus;
     waitlistPosition: number | null;
 }
+export type EventCheckoutReturnRequest = {
+    kind: 'resolveSuccess';
+    checkoutAttemptId: string;
+    sessionId: string;
+} | {
+    kind: 'abandon';
+    checkoutAttemptId: string;
+};
+export type EventCheckoutReturnResponse = {
+    kind: 'resolved';
+    reference: EventRegistrationStatusReference;
+} | {
+    kind: 'abandoned';
+} | {
+    kind: 'notFound';
+} | {
+    kind: 'reconciliationRequired';
+};
 export {};

package/dist/_dts/blocks/src/system/runtime/components/registry.client.d.ts

@@ -638,6 +638,14 @@ export declare const runtimeBackedBlockClientEntries: {
                     eventSurface: import("../..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("../..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>;
             contracts: Readonly<{
@@ -655,6 +663,14 @@ export declare const runtimeBackedBlockClientEntries: {
                             eventSurface: import("../..").EventSurfaceScope;
                             filterEventPresets: string | null;
                             scheduleScope: import("../..").EventScheduleScope;
+                            calendarContext: Readonly<{
+                                timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                initialToday: Readonly<{
+                                    year: number;
+                                    month: number;
+                                    day: number;
+                                }>;
+                            }>;
                         }>;
                     }>) => unknown;
                     decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
@@ -666,6 +682,14 @@ export declare const runtimeBackedBlockClientEntries: {
                             eventSurface: import("../..").EventSurfaceScope;
                             filterEventPresets: string | null;
                             scheduleScope: import("../..").EventScheduleScope;
+                            calendarContext: Readonly<{
+                                timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                initialToday: Readonly<{
+                                    year: number;
+                                    month: number;
+                                    day: number;
+                                }>;
+                            }>;
                         }>;
                     }>>;
                 }>;
@@ -685,6 +709,14 @@ export declare const runtimeBackedBlockClientEntries: {
                         eventSurface: import("../..").EventSurfaceScope;
                         filterEventPresets: string | null;
                         scheduleScope: import("../..").EventScheduleScope;
+                        calendarContext: Readonly<{
+                            timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                            initialToday: Readonly<{
+                                year: number;
+                                month: number;
+                                day: number;
+                            }>;
+                        }>;
                     }>;
                 }>;
                 contracts: Readonly<{
@@ -702,6 +734,14 @@ export declare const runtimeBackedBlockClientEntries: {
                                 eventSurface: import("../..").EventSurfaceScope;
                                 filterEventPresets: string | null;
                                 scheduleScope: import("../..").EventScheduleScope;
+                                calendarContext: Readonly<{
+                                    timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                    initialToday: Readonly<{
+                                        year: number;
+                                        month: number;
+                                        day: number;
+                                    }>;
+                                }>;
                             }>;
                         }>) => unknown;
                         decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
@@ -713,6 +753,14 @@ export declare const runtimeBackedBlockClientEntries: {
                                 eventSurface: import("../..").EventSurfaceScope;
                                 filterEventPresets: string | null;
                                 scheduleScope: import("../..").EventScheduleScope;
+                                calendarContext: Readonly<{
+                                    timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                    initialToday: Readonly<{
+                                        year: number;
+                                        month: number;
+                                        day: number;
+                                    }>;
+                                }>;
                             }>;
                         }>>;
                     }>;
@@ -2237,6 +2285,10 @@ export declare const clientComponentRegistryEntries: {
                     eventSurface: import("../..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("../..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                        initialToday: import("../../../../../calendar/src/index").CalendarDate;
+                    }>;
                 }>;
             }>>;
         }>>;

package/dist/_dts/blocks/src/system/runtime/components/runtime-backed-blocks.d.ts

@@ -327,6 +327,14 @@ export declare const runtimeBackedBlockServerEntries: {
                     eventSurface: import("../..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("../..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>;
             contracts: Readonly<{
@@ -344,6 +352,14 @@ export declare const runtimeBackedBlockServerEntries: {
                             eventSurface: import("../..").EventSurfaceScope;
                             filterEventPresets: string | null;
                             scheduleScope: import("../..").EventScheduleScope;
+                            calendarContext: Readonly<{
+                                timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                initialToday: Readonly<{
+                                    year: number;
+                                    month: number;
+                                    day: number;
+                                }>;
+                            }>;
                         }>;
                     }>) => unknown;
                     decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
@@ -355,6 +371,14 @@ export declare const runtimeBackedBlockServerEntries: {
                             eventSurface: import("../..").EventSurfaceScope;
                             filterEventPresets: string | null;
                             scheduleScope: import("../..").EventScheduleScope;
+                            calendarContext: Readonly<{
+                                timeZone: import("../../../../../core/src/index").BookingTimeZone;
+                                initialToday: Readonly<{
+                                    year: number;
+                                    month: number;
+                                    day: number;
+                                }>;
+                            }>;
                         }>;
                     }>>;
                 }>;

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

@@ -1,6 +1,13 @@
 import type { PublicEvent } from '../../blocks/events/shared/types';
-import { type CalendarViewport, type CalendarViewportKind, type WeekStart } from '../nodes/events/shared/utils';
+import { type BookingTimeZone } from '../../../../../core/src/index';
+import type { CalendarDate } from '../../../../../calendar/src/index';
+import { type CalendarViewport, type CalendarViewportKind, type WeekStart } from '../nodes/events/domain';
 import { type EventRuntimeFilters } from '../nodes/events/shared/listOptions';
+import { type CalendarViewLoadState } from './useCalendarEvents.state';
+export type { CalendarViewLoadState } from './useCalendarEvents.state';
+type CalendarViewportFor<Kind extends CalendarViewportKind> = Extract<CalendarViewport, Readonly<{
+    kind: Kind;
+}>>;
 type UseCalendarEventsOptions = {
     /** @deprecated Site ID is now provided by BlockApiProvider context */
     siteId?: string;
@@ -16,59 +23,72 @@ type UseCalendarEventsOptions = {
     filters?: EventRuntimeFilters;
     /** Fetch stage (preview vs published) */
     stage?: 'preview' | 'published';
+    calendarContext: Readonly<{
+        timeZone: BookingTimeZone;
+        initialToday: CalendarDate;
+    }>;
 };
-type CalendarEventsState = {
+export type CalendarEventsState<Kind extends CalendarViewportKind> = {
     /** Events visible in the current view */
     events: PublicEvent[];
     /** Current view date (anchor of the calendar viewport) */
-    viewDate: Date;
+    viewDate: CalendarDate;
     /** Derived calendar viewport for the current view date */
-    viewport: CalendarViewport;
+    viewport: CalendarViewportFor<Kind>;
     /** Whether events are being loaded */
-    loading: boolean;
-    /** Error from last fetch */
-    error: Error | null;
+    loadState: CalendarViewLoadState;
     /** Set the view date */
-    setViewDate: (date: Date) => void;
+    setViewDate: (date: CalendarDate) => void;
     /** Navigate to previous viewport period */
     goToPrevious: () => void;
     /** Navigate to next viewport period */
     goToNext: () => void;
     /** Navigate to today */
     goToToday: () => void;
+    /** Retry loading the currently selected viewport without changing its date */
+    retryCurrentView: () => void;
 };
 type UseCalendarViewportOptions = Readonly<{
     view?: CalendarViewportKind;
     startOfWeek?: WeekStart;
-    initialDate?: Date;
+    initialDate: CalendarDate;
 }>;
 /**
  * Owns calendar viewport state only: selected anchor date, derived visible
  * period, and navigation by the natural unit for the active view.
  */
-export declare function useCalendarViewport({ view, startOfWeek, initialDate, }?: UseCalendarViewportOptions): Readonly<{
-    viewDate: Date;
-    viewport: CalendarViewport;
-    goToDate: (date: Date) => void;
+type CalendarViewportState<Kind extends CalendarViewportKind> = Readonly<{
+    viewDate: CalendarDate;
+    viewport: CalendarViewportFor<Kind>;
+    goToDate: (date: CalendarDate) => void;
     goToPrevious: () => void;
     goToNext: () => void;
     goToToday: () => void;
 }>;
+type ExplicitCalendarViewportOptions<Kind extends CalendarViewportKind> = Omit<UseCalendarViewportOptions, 'view'> & Readonly<{
+    view: Kind;
+}>;
+type DefaultCalendarViewportOptions = Omit<UseCalendarViewportOptions, 'view'> & Readonly<{
+    view?: undefined;
+}>;
+export declare function useCalendarViewport(options: DefaultCalendarViewportOptions): CalendarViewportState<'month'>;
+export declare function useCalendarViewport<Kind extends CalendarViewportKind>(options: ExplicitCalendarViewportOptions<Kind>): CalendarViewportState<Kind>;
 type UseCalendarEventCacheOptions = Readonly<{
-    viewDate: Date;
+    viewDate: CalendarDate;
     initialEvents?: PublicEvent[];
     preloadMonths?: number;
     filters?: EventRuntimeFilters;
     stage?: 'preview' | 'published';
+    timeZone: BookingTimeZone;
 }>;
 /**
- * Owns event loading and month-window caching for a supplied viewport anchor.
- * It does not decide navigation semantics or visible calendar days.
+ * The reducer owns month data and request ownership. The hook only performs I/O.
+ * Requests for other months remain useful until the query context changes.
  */
-export declare function useCalendarEventCache({ viewDate, initialEvents, preloadMonths, filters, stage, }: UseCalendarEventCacheOptions): Readonly<{
+export declare function useCalendarEventCache({ viewDate, initialEvents, preloadMonths, filters, stage, timeZone, }: UseCalendarEventCacheOptions): Readonly<{
     events: PublicEvent[];
-    loading: boolean;
-    error: Error | null;
+    loadState: CalendarViewLoadState;
+    retryCurrentView: () => void;
 }>;
 /**
  * Hook for calendar event management with month-based caching.
@@ -84,6 +104,12 @@ export declare function useCalendarEventCache({ viewDate, initialEvents, preload
  * });
  * ```
  */
-export declare function useCalendarEvents({ siteId: _siteId, // Deprecated: siteId now comes from BlockApiProvider context
-initialEvents, view, startOfWeek, preloadMonths, filters, stage, }: UseCalendarEventsOptions): CalendarEventsState;
+type ExplicitCalendarEventsOptions<Kind extends CalendarViewportKind> = Omit<UseCalendarEventsOptions, 'view'> & Readonly<{
+    view: Kind;
+}>;
+type DefaultCalendarEventsOptions = Omit<UseCalendarEventsOptions, 'view'> & Readonly<{
+    view?: undefined;
+}>;
+export declare function useCalendarEvents(options: DefaultCalendarEventsOptions): CalendarEventsState<'month'>;
+export declare function useCalendarEvents<Kind extends CalendarViewportKind>(options: ExplicitCalendarEventsOptions<Kind>): CalendarEventsState<Kind>;
 export default useCalendarEvents;

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

@@ -1,4 +1,24 @@
-export type CalendarEventCacheLoadState = Readonly<{
+import { type BookingTimeZone } from '../../../../../core/src/index';
+import type { CalendarDate } from '../../../../../calendar/src/index';
+import type { PublicEvent } from '../../blocks/events/shared/types';
+type MonthState = Readonly<{
+    events: readonly PublicEvent[];
+}> & (Readonly<{
+    kind: 'seeded';
+}> | Readonly<{
+    kind: 'loading';
+    request: CalendarRequest;
+}> | Readonly<{
+    kind: 'ready';
+}> | Readonly<{
+    kind: 'failed';
+    error: Error;
+}>);
+export type CalendarRequest = Readonly<{
+    months: readonly string[];
+}>;
+export type CalendarCacheState = ReadonlyMap<string, MonthState>;
+export type CalendarViewLoadState = Readonly<{
     kind: 'idle';
 }> | Readonly<{
     kind: 'loading';
@@ -6,15 +26,24 @@ export type CalendarEventCacheLoadState = Readonly<{
     kind: 'error';
     error: Error;
 }>;
-export type CalendarEventCacheLoadAction = Readonly<{
-    type: 'started';
+export type CalendarCacheAction = Readonly<{
+    kind: 'started';
+    request: CalendarRequest;
 }> | Readonly<{
-    type: 'succeeded';
+    kind: 'succeeded';
+    request: CalendarRequest;
+    events: readonly PublicEvent[];
+    timeZone: BookingTimeZone;
 }> | Readonly<{
-    type: 'failed';
+    kind: 'failed';
+    request: CalendarRequest;
     error: Error;
 }>;
-export declare function calendarEventCacheLoadReducer(_state: CalendarEventCacheLoadState, action: CalendarEventCacheLoadAction): CalendarEventCacheLoadState;
-export declare function toCalendarEventCacheLoadError(error: unknown): Error;
-export declare function isCalendarEventCacheLoading(state: CalendarEventCacheLoadState): boolean;
-export declare function getCalendarEventCacheError(state: CalendarEventCacheLoadState): Error | null;
+export declare function calendarMonthKey(date: CalendarDate): string;
+export declare function calendarWindowMonths(date: CalendarDate, radius: number): readonly string[];
+export declare function seedCalendarCache(events: readonly PublicEvent[], timeZone: BookingTimeZone): CalendarCacheState;
+export declare function planCalendarRequest(state: CalendarCacheState, months: readonly string[], retry: boolean): CalendarRequest | null;
+export declare function calendarCacheReducer(state: CalendarCacheState, action: CalendarCacheAction): CalendarCacheState;
+export declare function selectCalendarEvents(state: CalendarCacheState, months: readonly string[]): PublicEvent[];
+export declare function projectCalendarLoadState(state: CalendarCacheState, months: readonly string[]): CalendarViewLoadState;
+export {};

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

@@ -1,12 +1,10 @@
 import React from 'react';
+import type { EventRegistrationErrorAction } from '../../../../../../commerce/src/purchase/index';
 type ErrorStepProps = {
     message: string;
     onRetry: () => void;
+    action?: EventRegistrationErrorAction;
+    canJoinWaitlist?: boolean;
 };
-/**
- * Error Step
- *
- * Displays an error message with a retry button when registration fails.
- */
 export declare const ErrorStep: React.FC<ErrorStepProps>;
 export {};