@riverbankcms/sdk 0.130.0 → 0.130.2

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

@@ -2,6 +2,7 @@ import type { AppointmentResourceId, AppointmentServiceId, Brand, CustomerPassId
 import type { BlockApiConfig, EligibleAppointmentPackage } from "../api/types";
 import type { TimeSlot } from "../api/types";
 import type { BookingFormConfig, BookingFormData, BookingFormField, BookingPaymentStepResolution, BookingFormServicesSource, BookingFormService, BookingSelectedCollectionOptionKind, BookingSubmissionData } from "./booking-form.state";
+import type { BookingValidationErrors } from "./booking-form.validationErrors";
 export type LoadState<T> = Readonly<{
     tag: "idle";
 }> | Readonly<{
@@ -25,10 +26,6 @@ export type BookingFlowStep = Readonly<{
     canEnter: boolean;
     canLeave: boolean;
 }>;
-export type BookingValidationErrors = Readonly<{
-    formError: string | null;
-    fieldErrors: Readonly<Record<string, string>>;
-}>;
 export type BookingFieldId = Brand<string, "BookingFieldId">;
 export declare const unsafeAsBookingFieldId: (id: string) => BookingFieldId;
 export type BookingFieldValue = string | number | boolean | readonly string[] | null;
@@ -173,6 +170,13 @@ export type BookingFlowReducerState = Readonly<{
     selectedSlot: BookingSlotView | null;
     fieldValues: Readonly<Record<string, BookingFieldValue>>;
     touchedFields: Readonly<Record<string, boolean>>;
+    /**
+     * Steps the user has tried to advance past. Step validation is derived
+     * continuously (it gates `canLeave`), but a step's errors are only ever
+     * *shown* once the step has been attempted — so a freshly mounted form is
+     * never scolded for input it has not had the chance to give yet.
+     */
+    attemptedStepIds: BookingAttemptedStepIds;
     discountCode: string;
     selectedSlidingAmountInput: string;
     selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
@@ -200,6 +204,9 @@ export type BookingFlowEvent = Readonly<{
 }> | Readonly<{
     type: "field-touched";
     fieldId: BookingFieldId;
+}> | Readonly<{
+    type: "step-advance-attempted";
+    stepId: BookingFlowStepId;
 }> | Readonly<{
     type: "payment-option-selected";
     kind: BookingSelectedCollectionOptionKind | null;
@@ -256,6 +263,13 @@ export type BookingStepPlanItem = Readonly<{
     label: string;
     visible: boolean;
 }>;
+/**
+ * Steps the user has actually tried to advance past. Step validation is derived
+ * continuously (it gates whether a step can be left), but a step's errors are
+ * only ever *shown* once the step has been attempted — so a freshly mounted
+ * form is never scolded for input it has not had the chance to give yet.
+ */
+export type BookingAttemptedStepIds = Readonly<Partial<Record<BookingFlowStepId, boolean>>>;
 export type BookingStepValidationResult = Readonly<{
     ok: true;
 }> | Readonly<{
@@ -272,6 +286,12 @@ export type DeriveBookingFlowStepsInput = Readonly<{
     requiresServiceSelection?: boolean;
     requiresResourceSelection?: boolean;
     enableAppointmentPackages?: boolean;
+    /**
+     * Steps whose validation messaging has been earned by an advance attempt.
+     * Omitted means "none attempted yet", so callers that only need gating can
+     * keep ignoring it.
+     */
+    attemptedStepIds?: BookingAttemptedStepIds;
 }>;
 export type DerivedBookingFlowSteps = Readonly<{
     steps: readonly BookingFlowStep[];
@@ -416,10 +436,6 @@ export type AppointmentBookingOverrideInputResult = Readonly<{
     reason: "missing-site-id" | "missing-api-base-url" | "missing-form" | "missing-form-id" | "missing-services";
     message: string;
 }>;
-export declare function createEmptyBookingValidationErrors(): BookingValidationErrors;
-export declare function createFormBookingValidationError(formError: string): BookingValidationErrors;
-export declare function createFieldBookingValidationErrors(fieldErrors: Readonly<Record<string, string>>): BookingValidationErrors;
-export declare function hasBookingValidationErrors(errors: BookingValidationErrors): boolean;
 export declare function createInitialBookingFlowReducerState(input: Readonly<{
     defaultServiceId?: string;
     defaultResourceId?: string;

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

@@ -8,6 +8,14 @@ type BookingFormProps = BookingFormSourceProps & Readonly<{
  * Server-safe placeholder for booking form.
  * Renders a stable shell plus the typed island envelope so hydration can attach
  * without pulling client hooks into the server graph.
+ *
+ * The island root carries mount identity only. The loading affordances — the
+ * `.rb-reg-surface` card, its `aria-busy` / `role="status"` announcement and the
+ * skeleton — live on a *child*, which the island mounter replaces wholesale when
+ * React takes over (it swaps the root's children, not the root). That keeps the
+ * 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.
  */
 export declare function BookingFormSSR({ blockId, siteId, apiBaseUrl, portalToken, formId, serviceId, resourceId, initialData, noticeMessage, requiresServiceSelection, requiresResourceSelection, shouldAutoSelectSingleResource, rebookContext, submitLabel, successMessage, form, services, spamProtectionEnabled, className, children, }: BookingFormProps): React.JSX.Element;
 export default BookingFormSSR;

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

@@ -0,0 +1,17 @@
+/**
+ * The booking flow's validation vocabulary: what a step can complain about, and
+ * when the user has earned the right to be told.
+ *
+ * Split out of `booking-form.headless.state.ts` so the reducer file carries
+ * behaviour rather than this small closed value type and its constructors.
+ */
+export type BookingValidationErrors = Readonly<{
+    formError: string | null;
+    fieldErrors: Readonly<Record<string, string>>;
+}>;
+export declare function createEmptyBookingValidationErrors(): BookingValidationErrors;
+export declare function createFormBookingValidationError(formError: string): BookingValidationErrors;
+export declare function createFieldBookingValidationErrors(fieldErrors: Readonly<Record<string, string>>): BookingValidationErrors;
+export declare function hasBookingValidationErrors(errors: BookingValidationErrors): boolean;
+export declare function clearBookingFormError(errors: BookingValidationErrors): BookingValidationErrors;
+export declare function clearBookingFieldError(errors: BookingValidationErrors, fieldId: string): BookingValidationErrors;

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

@@ -1,7 +1,7 @@
 import type { PaymentSelection, PublicEvent, RegistrationStep } from './types';
 import type { UseEventRegistrationWizardResult } from './useEventRegistrationWizard';
 import { type EventRegistrationFlowStatus, type EventRegistrationFlowStep, type EventRegistrationFlowView, type EventRegistrationPaymentSelection, type EventRegistrationSubmitPlan } from './event-registration.headless.contract';
-export declare function getRegistrableStatuses(isPreview: boolean | undefined): readonly PublicEvent['status'][];
+export declare function isEventRegistrationAvailable(event: Pick<PublicEvent, 'bookingAvailability'>): boolean;
 export declare function normalizeEventRegistrationMaxTickets(value: string | number | undefined): number;
 export declare function toHeadlessPaymentSelection(selection: PaymentSelection): EventRegistrationPaymentSelection;
 export declare function toInternalPaymentSelection(selection: EventRegistrationPaymentSelection): PaymentSelection;

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

@@ -1,6 +1,6 @@
 import { type EventPageSurfaceSubject, type EventPageSurfaceSubjectParseError, type EventOfferingId, type EventSeriesId, type Result } from '../../../../../../core/src/index';
 import { z } from 'zod';
-export declare const unsupportedEventRegistrationPageSurfaceSubjectReasons: readonly ["unsupportedSubject", "invalidEventSeriesId", "invalidEventOfferingId"];
+export declare const unsupportedEventRegistrationPageSurfaceSubjectReasons: readonly ["unsupportedSubject", "invalidEventSeriesId", "invalidEventSeriesBookingScope", "invalidEventOfferingId"];
 export type UnsupportedEventRegistrationPageSurfaceSubjectReason = (typeof unsupportedEventRegistrationPageSurfaceSubjectReasons)[number];
 export type EventRegistrationPageSurfaceSubject = EventPageSurfaceSubject | Readonly<{
     kind: 'unsupported';

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

@@ -9,5 +9,5 @@ type EventRegistrationProps = Omit<EventRegistrationSourceProps, 'subject'> & Re
  * Server-safe placeholder for event registration.
  * Provides a static container for island hydration without importing client hooks.
  */
-export declare function EventRegistrationSSR({ blockId, siteId, apiBaseUrl, portalToken, previewToken, occurrenceContext, subject, events, className, buttonText, maxTickets, showVenue, showCapacity, successMessage, waitlistMessage, buttonVariant, overlayEnabled, spamProtectionEnabled, stage, supportEmail, sitePasses, siteMemberships, children, }: EventRegistrationProps): React.JSX.Element;
+export declare function EventRegistrationSSR({ blockId, subject, children, ...sourceProps }: EventRegistrationProps): React.JSX.Element;
 export default EventRegistrationSSR;

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

@@ -138,6 +138,7 @@ export declare const eventCollectionSourceSchemaShape: {
         eventPreset: z.ZodOptional<z.ZodEnum<{
             course: "course";
             event: "event";
+            term: "term";
             performance: "performance";
             class: "class";
             workshop: "workshop";
@@ -452,6 +453,24 @@ export declare const eventCollectionSourceSchemaShape: {
             label: z.ZodString;
         }, z.core.$strip>], "kind">;
         requiresRegistration: z.ZodBoolean;
+        bookingAvailability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"closed">;
+            reason: z.ZodEnum<{
+                occurrence_cancelled: "occurrence_cancelled";
+                occurrence_completed: "occurrence_completed";
+                series_draft: "series_draft";
+                series_cancelled: "series_cancelled";
+                series_completed: "series_completed";
+                series_archived: "series_archived";
+                parent_archived: "parent_archived";
+                parent_inconsistent: "parent_inconsistent";
+                not_public: "not_public";
+                already_started: "already_started";
+                enrollment_closed: "enrollment_closed";
+            }>;
+        }, z.core.$strip>], "kind">;
         deliveryMode: z.ZodEnum<{
             in_person: "in_person";
             hybrid: "hybrid";
@@ -498,6 +517,8 @@ export declare const eventCollectionSourceSchemaShape: {
             active: "active";
             draft: "draft";
             archived: "archived";
+            completed: "completed";
+            cancelled: "cancelled";
         }>>;
         timeZone: z.ZodString;
         pricing: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -845,6 +866,7 @@ export declare const eventCollectionDisplaySchemaShape: {
         eventPreset: z.ZodOptional<z.ZodEnum<{
             course: "course";
             event: "event";
+            term: "term";
             performance: "performance";
             class: "class";
             workshop: "workshop";
@@ -1159,6 +1181,24 @@ export declare const eventCollectionDisplaySchemaShape: {
             label: z.ZodString;
         }, z.core.$strip>], "kind">;
         requiresRegistration: z.ZodBoolean;
+        bookingAvailability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"closed">;
+            reason: z.ZodEnum<{
+                occurrence_cancelled: "occurrence_cancelled";
+                occurrence_completed: "occurrence_completed";
+                series_draft: "series_draft";
+                series_cancelled: "series_cancelled";
+                series_completed: "series_completed";
+                series_archived: "series_archived";
+                parent_archived: "parent_archived";
+                parent_inconsistent: "parent_inconsistent";
+                not_public: "not_public";
+                already_started: "already_started";
+                enrollment_closed: "enrollment_closed";
+            }>;
+        }, z.core.$strip>], "kind">;
         deliveryMode: z.ZodEnum<{
             in_person: "in_person";
             hybrid: "hybrid";
@@ -1205,6 +1245,8 @@ export declare const eventCollectionDisplaySchemaShape: {
             active: "active";
             draft: "draft";
             archived: "archived";
+            completed: "completed";
+            cancelled: "cancelled";
         }>>;
         timeZone: z.ZodString;
         pricing: z.ZodDiscriminatedUnion<[z.ZodObject<{

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

@@ -6,7 +6,10 @@ import type { CardOrientation, EventLayout, PublicEvent } from '../../../../bloc
 /** Day names starting from Sunday — kept for back-compat re-export. */
 export { DAY_NAMES, MONTH_NAMES } from '../../../../../../../calendar/src/index';
 export type { WeekStart } from '../../../../../../../calendar/src/index';
-/** Column class mappings for grid layouts */
+/**
+ * Column class mappings for grid layouts, derived from the canonical
+ * responsive column ladder (see gridUserColumnLadder).
+ */
 export declare const COLUMN_CLASSES: Record<string, string>;
 /**
  * Build container class based on layout mode

package/dist/_dts/blocks/src/system/runtime/shared/components/FeedbackMessage.d.ts

@@ -1,8 +1,24 @@
 import type { ReactNode } from 'react';
 export type FeedbackTone = 'info' | 'success' | 'warning' | 'error';
 export type FeedbackLiveMode = 'off' | 'polite' | 'assertive';
+/**
+ * How loudly a feedback message presents itself. Orthogonal to tone: tone says
+ * what kind of message it is, treatment says how much room it takes up.
+ *
+ * - `panel` — the alert box. The default, and what every existing call site
+ *   gets. Suits a genuine failure: a declined payment, a lost submission.
+ * - `field-note` — a quiet margin note attached to the control or group it
+ *   describes. Suits inline validation, where the user has simply not finished
+ *   something yet.
+ *
+ * Site styles own each treatment's appearance; the CSS is generated in
+ * theme-core (`status/generateStatusCss.ts`) from theme tokens, so a block
+ * only ever names the treatment.
+ */
+export type FeedbackTreatment = 'panel' | 'field-note';
 export type FeedbackMessageProps = Readonly<{
     tone: FeedbackTone;
+    treatment?: FeedbackTreatment;
     children: ReactNode;
     className?: string;
     id?: string;
@@ -12,4 +28,4 @@ export type FeedbackMessageProps = Readonly<{
     role?: 'alert' | 'status';
     live?: FeedbackLiveMode;
 }>;
-export declare function FeedbackMessage({ tone, children, className, id, title, titleClassName, bodyClassName, role, live, }: FeedbackMessageProps): import("react").JSX.Element;
+export declare function FeedbackMessage({ tone, treatment, children, className, id, title, titleClassName, bodyClassName, role, live, }: FeedbackMessageProps): import("react").JSX.Element;

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

@@ -15,7 +15,7 @@ export type { BookingOptionGroupViewModel, BookingOptionListProps, } from './Boo
 export { FieldValidationMessage, getFieldValidationControlProps, } from './FieldValidationMessage';
 export type { FieldValidationControlInput, FieldValidationControlProps, FieldValidationMessageProps, } from './FieldValidationMessage';
 export { FeedbackMessage } from './FeedbackMessage';
-export type { FeedbackLiveMode, FeedbackMessageProps, FeedbackTone } from './FeedbackMessage';
+export type { FeedbackLiveMode, FeedbackMessageProps, FeedbackTone, FeedbackTreatment, } from './FeedbackMessage';
 export { LoggedInAsUser } from './LoggedInAsUser';
 export { StateIcon } from './StateIcon';
 export type { LoggedInAsUserProps } from './LoggedInAsUser';

package/dist/_dts/blocks/src/system/spacing.d.ts

@@ -21,7 +21,7 @@
  * 2. TypeScript will error until you update both spacing maps
  * 3. No way to get out of sync
  */
-declare const SEMANTIC_SPACING_VALUES: readonly ["none", "compact", "cozy", "medium", "comfortable", "spacious"];
+export declare const SEMANTIC_SPACING_VALUES: readonly ["none", "compact", "cozy", "medium", "comfortable", "spacious"];
 /**
  * Semantic spacing values used across the block system.
  * These abstract away the specific CSS classes and provide a consistent vocabulary.

package/dist/_dts/blocks/src/system/transforms/registry/_utils/boxStyleClassNames.d.ts

@@ -0,0 +1,90 @@
+import { type CardRole } from '../../../../../../theme-core/src/cards/index';
+/**
+ * @file The one place box-style content becomes CSS classes.
+ *
+ * `boxStyles.all` runs this for the binding pipeline, and the React nodes that
+ * render a card outside that pipeline (offerings-preview) call it directly, so
+ * there is a single card-class emission path rather than copies that drift.
+ */
+/** The elevation class an elevated box gets when the theme defines a shadow. */
+export declare const RAISED_SHADOW_CLASS = "rb-shadow-md";
+/** Radius values to their `rb-*` classes (defined in `rb-utilities.css`). */
+export declare const ROUNDED_CLASSES: Readonly<Record<string, string>>;
+export declare const fixedFrameScopeClass = "rb-bg-motion-fixed-frame-scope";
+export declare function hasFixedFrameBackgroundMotion(value: unknown): boolean;
+/**
+ * The role a card renders with, and the one place a set of card styles becomes
+ * a role.
+ *
+ * Precedence: a per-item override, then the `role` a Look compiled onto the
+ * block's card styles, then the legacy `cardVariant` field. `cardVariant` only
+ * ever held role names, so it reads *as* a role rather than as a second
+ * vocabulary — an explicit `role` wins when a record carries both.
+ *
+ * Compiled and freshly authored card styles carry only `role`. `cardVariant`
+ * survives on content persisted before the role contract, and normalizes here
+ * rather than in `cardStylesOverrideSchema` because that content reaches the
+ * renderer as a raw record without ever passing through the schema.
+ */
+export declare function resolveCardRoleForBoxStyles(input: Record<string, unknown>, override: CardRole | null | undefined): CardRole | null;
+/**
+ * Parse a block's own per-item surface vocabulary into a card role. The alias
+ * map is declared by the block (its persisted values are its own history), and
+ * `normalizeCardRole` remains the one untrusted-input boundary after that.
+ */
+export declare function resolveItemCardRole(value: unknown, aliases: Readonly<Record<string, string>> | undefined): CardRole | null;
+/** The border widths `CardStylesContent['border']` can carry. */
+export type BoxBorderWidth = 'none' | '1' | '2' | '3';
+/**
+ * A box border after the one legacy shape has been normalized away, parsed
+ * into the vocabulary the field actually declares. The record arrives here as
+ * raw persisted JSON, so parsing is this function's job and no reader
+ * downstream repeats it.
+ */
+export type NormalizedBoxBorder = Readonly<{
+    /** `null` means the box expresses no opinion and inherits its border. */
+    enabled: boolean | null;
+    width: BoxBorderWidth | undefined;
+    colorToken: string | undefined;
+}>;
+/**
+ * A box's border record with `{ width: 'none' }`-without-`enabled` resolved.
+ *
+ * That shape used to mean two different things to two different readers: the
+ * old private offerings emitter read it as border-off, while the shared
+ * emitter read it as "no opinion" and left the caller's base `rb-border` in
+ * place. Same persisted bytes, opposite answers. A width of `none` says there
+ * is no border, so it is read as `enabled: false` here — once, at the one
+ * place box-style content is interpreted — and every reader downstream now
+ * agrees.
+ *
+ * Nothing persisted carries the shape (the #1297 usage audit found zero rows;
+ * the authoring UI cannot produce it, since the width control is gated on
+ * `enabled === true`), so this is boundary hygiene rather than a migration.
+ */
+export declare function normalizeBoxStylesBorder(value: unknown): NormalizedBoxBorder | null;
+/**
+ * The class list for a set of box styles: the caller's base class, the border /
+ * spacing / elevation / radius overrides the box carries, and its card surface.
+ *
+ * Pure, so the React nodes that render a card outside the binding pipeline
+ * (offerings-preview) share this one emission path with `boxStyles.all` instead
+ * of keeping a copy that drifts.
+ */
+export declare function boxStyleClassNames(value: unknown, options: Readonly<{
+    axis?: "y" | "all";
+    baseClass?: string;
+    includeSpacing?: boolean;
+    /**
+     * A card role that wins over the one compiled into the box styles — the
+     * per-item override in blocks that let individual cards pick their surface.
+     */
+    cardRoleOverride?: CardRole | null;
+    /**
+     * The elevation class an elevated box gets. Defaults to the standard raised
+     * shadow; pass `null` to opt out explicitly (the binding pipeline does that
+     * for a theme whose medium shadow is `none`). Omitting it must never
+     * silently flatten a raised card, hence the default.
+     */
+    raisedClass?: string | null;
+}>): string;

package/dist/_dts/blocks/src/system/transforms/registry/_utils/surfaceForegroundStyles.d.ts

@@ -1,4 +1,8 @@
+import { resolveSurfaceForeground, type ResolvedSurfaceForeground } from '../../../../../../theme-core/src/surfaces/index';
+import type { ThemeHeader } from '../../../../../../theme-core/src/schema';
 import type { TransformContext } from '../core';
+export declare function resolveHeaderLeafTextColor(header: Partial<ThemeHeader> | undefined): NonNullable<ThemeHeader['textColor']>;
+export declare function resolveHeaderRootForeground(header: Partial<ThemeHeader> | undefined, palette: Parameters<typeof resolveSurfaceForeground>[1], isTransparent: boolean): ResolvedSurfaceForeground;
 export declare function resolveSurfaceForegroundStyles(value: unknown, context: TransformContext, options?: Readonly<{
     fallbackToken?: string;
 }>): Record<string, string>;

package/dist/_dts/blocks/src/system/transforms/registry/boxStyles.d.ts

@@ -1,5 +1,6 @@
 import { type TransformDefinition } from "./core";
 import type { SemanticSpacing } from "../../spacing";
+import { type CardRole } from '../../../../../theme-core/src/cards/index';
 /**
  * Maps semantic spacing values to CSS-only `rb-*` spacing classes.
  *
@@ -59,7 +60,32 @@ export declare const boxStylesCompositeTransform: TransformDefinition<{
     axis?: "y" | "all";
     baseClass?: string;
     includeSpacing?: boolean;
+    cardRoleOverride?: CardRole | null;
 }>;
+type CardRoleClassOptions = {
+    baseClass?: string;
+    axis?: "y" | "all";
+    /** Where the block's compiled card styles live on the view model. */
+    stylesPath?: string;
+    /** The block's own per-item surface vocabulary, mapped onto card roles. */
+    itemRoleAliases?: Readonly<Record<string, string>>;
+    /**
+     * `surface` renders the card container (box styles plus the role class);
+     * `media` / `content` render the shared child hooks generated card CSS
+     * targets, and only while a role is actually in play.
+     */
+    emit?: "surface" | "media" | "content";
+};
+/**
+ * Card classes for a block whose items may each pick their own surface.
+ *
+ * Bound from the per-item role so it can see the repeated item, and reads the
+ * block's compiled card styles off the view model — the two live in different
+ * binding scopes. Precedence: the Look's block-level role is the base, an
+ * explicit per-item role overrides it, and the user's own card fields (border,
+ * background, radius) ride along on top as they always have.
+ */
+export declare const cardRoleClassTransform: TransformDefinition<CardRoleClassOptions>;
 export declare const cardVariantClassTransform: TransformDefinition<{
     baseClass?: string;
 }>;

package/dist/_dts/blocks/src/system/transforms/registry/layout.d.ts

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-import type { ThemeHeader } from '../../../../../theme-core/src/schema';
-import type { ThemeTokens } from '../../theme';
+import { type ThemeHeader } from '../../../../../theme-core/src/schema';
 import { type TransformDefinition } from './core';
 declare const headerLogoClassSchema: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;
@@ -13,7 +12,7 @@ export declare const headerLogoTextVisibleTransform: TransformDefinition;
  *
  * - `'inline'`  → classic variant with the historical logo-left / nav-right row
  * - `'centered'`→ classic variant with a centred (flex-1) nav and a right CTA
- * - `'other'`   → not a classic variant (centered/floating/transparent handle it)
+ * - `'other'`   → not a classic variant (centered/floating handle it)
  *
  * Consumed by the site-header block's `$when` gates so the two classic rows are
  * mutually exclusive without introducing a new top-level header variant.
@@ -32,47 +31,15 @@ declare const headerRootClassSchema: z.ZodObject<{
     invert: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type HeaderRootOptions = z.infer<typeof headerRootClassSchema>;
-export type HeaderVisualStyles = ReturnType<typeof resolveHeaderVisualStyles>;
-export declare function resolveBackgroundVisualStyles(backgroundColor: string | undefined, tokens: ThemeTokens, defaultToken?: string): {
+export declare function resolveBackgroundVisualStyles(backgroundColor: string | undefined, defaultToken?: string): {
     backgroundToken: string;
-    paletteHex: string | null;
-    backgroundHex: string | null;
-    isBackgroundDark: boolean;
-    textColorToken: "text";
-    textColorOverride: string | null;
-    isTransparent: boolean;
-} | {
-    backgroundToken: string;
-    paletteHex: string | undefined;
-    backgroundHex: string;
-    isBackgroundDark: boolean;
-    textColorToken: "text" | undefined;
-    textColorOverride: string | null;
     isTransparent: boolean;
 };
-export declare function resolveHeaderVisualStyles(header: Partial<ThemeHeader> | undefined, tokens: ThemeTokens): {
-    backgroundToken: string;
-    paletteHex: string | null;
-    backgroundHex: string | null;
-    isBackgroundDark: boolean;
-    textColorToken: "text";
-    textColorOverride: string | null;
-    isTransparent: boolean;
-} | {
+export declare function resolveHeaderVisualStyles(header: Partial<ThemeHeader> | undefined): {
     backgroundToken: string;
-    paletteHex: string | undefined;
-    backgroundHex: string;
-    isBackgroundDark: boolean;
-    textColorToken: "text" | undefined;
-    textColorOverride: string | null;
     isTransparent: boolean;
 } | {
     readonly backgroundToken: "transparent";
-    readonly paletteHex: null;
-    readonly backgroundHex: null;
-    readonly isBackgroundDark: false;
-    readonly textColorToken: "text";
-    readonly textColorOverride: null;
     readonly isTransparent: true;
 };
 export declare const headerRootClassTransform: TransformDefinition<HeaderRootOptions>;

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

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { BlockManifest } from '../../../blocks/src/index';
-import { type FieldWidgetComponent } from '../../../block-form/src/client/index';
-import type { ManifestFormSource } from '../../../block-form/src/client/index';
+import { type FieldWidgetComponent } from '../../../block-form/src/index';
+import type { ManifestFormSource } from '../../../block-form/src/index';
 export type { AutosaveHandle } from '../hooks/useSimpleAutosave';
 export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
     siteId: string;

package/dist/_dts/content-model/src/content-types/builtin-schemas.d.ts

@@ -57,19 +57,19 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
     readonly fields: [{
         readonly id: "summary";
         readonly type: "textarea";
-        readonly label: "Summary";
-        readonly description: "Short teaser shown in listings.";
+        readonly label: "Short introduction";
+        readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
         readonly rows: 3;
     }, {
         readonly id: "image";
         readonly type: "media";
-        readonly label: "Listing image";
-        readonly description: "Optional image used for event cards and previews.";
+        readonly label: "Event image";
+        readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
     }, {
         readonly id: "body";
         readonly type: "richText";
-        readonly label: "Details";
-        readonly description: "Full event details and agenda.";
+        readonly label: "About this event";
+        readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
     }];
     readonly routing: {
         readonly enabled: true;

package/dist/_dts/content-model/src/content-types/builtins.d.ts

@@ -162,19 +162,19 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
         readonly fields: [{
             readonly id: "summary";
             readonly type: "textarea";
-            readonly label: "Summary";
-            readonly description: "Short teaser shown in listings.";
+            readonly label: "Short introduction";
+            readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
             readonly rows: 3;
         }, {
             readonly id: "image";
             readonly type: "media";
-            readonly label: "Listing image";
-            readonly description: "Optional image used for event cards and previews.";
+            readonly label: "Event image";
+            readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
         }, {
             readonly id: "body";
             readonly type: "richText";
-            readonly label: "Details";
-            readonly description: "Full event details and agenda.";
+            readonly label: "About this event";
+            readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
         }];
         readonly routing: {
             readonly enabled: true;

package/dist/_dts/core/src/branded.d.ts

@@ -24,6 +24,8 @@ export type BrandedIdParseError = {
 export declare function expectParsedBrandedId<TBrand>(result: Result<TBrand, BrandedIdParseError>): TBrand;
 export type EventInstanceId = Brand<string, 'EventInstanceId'>;
 export type SiteId = Brand<string, 'SiteId'>;
+/** An API key identifier, independent of the credential family it represents. */
+export type ApiKeyId = Brand<string, 'ApiKeyId'>;
 export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
 export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
@@ -159,6 +161,7 @@ export declare const unsafeAsEntryId: (id: string) => EntryId;
 export declare const unsafeAsPreviewEntryId: (id: string) => PreviewEntryId;
 export declare const unsafeAsEventInstanceId: (id: string) => EventInstanceId;
 export declare const unsafeAsSiteId: (id: string) => SiteId;
+export declare const unsafeAsApiKeyId: (id: string) => ApiKeyId;
 export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
 export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
@@ -268,6 +271,7 @@ export declare const unsafeAsEncounterRecordId: (id: string) => EncounterRecordI
 export declare const unsafeAsRecordEntryId: (id: string) => RecordEntryId;
 export declare const unsafeAsProtectedPayloadKeyVersion: (id: string) => ProtectedPayloadKeyVersion;
 export declare const parseSiteId: (value: unknown) => Result<SiteId, BrandedIdParseError>;
+export declare const parseApiKeyId: (value: unknown) => Result<ApiKeyId, BrandedIdParseError>;
 export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, BrandedIdParseError>;
 export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
 export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;

package/dist/_dts/core/src/event-page-surface-subject.d.ts

@@ -14,16 +14,33 @@ export type EventPageSurfaceSubjectRefWire = Readonly<{
     kind: 'eventOffering';
     eventOfferingId: string;
 }>;
-export type EventPageSurfaceSubject = Extract<EventPageSurfaceSubjectRef, {
+export type EventPageSurfaceBookingScope = 'single_occurrence' | 'whole_series';
+export type EventSeriesPageSurfaceSubject = Readonly<{
     kind: 'eventSeries';
+    eventSeriesId: EventSeriesId;
+    bookingScope: 'single_occurrence';
+}> | Readonly<{
+    kind: 'eventSeries';
+    eventSeriesId: EventSeriesId;
+    bookingScope: 'whole_series';
+    isWholeSeriesBooking: true;
+}>;
+export type EventSeriesPageSurfaceSubjectWire = Readonly<{
+    kind: 'eventSeries';
+    eventSeriesId: string;
+    bookingScope: 'single_occurrence';
 }> | Readonly<{
+    kind: 'eventSeries';
+    eventSeriesId: string;
+    bookingScope: 'whole_series';
+    isWholeSeriesBooking: true;
+}>;
+export type EventPageSurfaceSubject = EventSeriesPageSurfaceSubject | Readonly<{
     kind: 'eventOffering';
     eventOfferingId: EventOfferingId;
     availableEventSeriesIds: readonly EventSeriesId[];
 }>;
-export type EventPageSurfaceSubjectWire = Extract<EventPageSurfaceSubjectRefWire, {
-    kind: 'eventSeries';
-}> | Readonly<{
+export type EventPageSurfaceSubjectWire = EventSeriesPageSurfaceSubjectWire | Readonly<{
     kind: 'eventOffering';
     eventOfferingId: string;
     availableEventSeriesIds: readonly string[];
@@ -36,9 +53,13 @@ export type EventPageSurfaceSubjectParseError = Readonly<{
 }> | Readonly<{
     kind: 'invalidEventSeriesId';
     error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalidEventSeriesBookingScope';
+    bookingScope: unknown;
 }> | Readonly<{
     kind: 'invalidEventOfferingId';
     error: BrandedIdParseError;
 }>;
+export declare function createEventSeriesPageSurfaceSubject(eventSeriesId: EventSeriesId, bookingScope: EventPageSurfaceBookingScope): EventSeriesPageSurfaceSubject;
 export declare function parseEventPageSurfaceSubject(value: unknown): Result<EventPageSurfaceSubject, EventPageSurfaceSubjectParseError>;
 export declare function toEventPageSurfaceSubjectWire(subject: EventPageSurfaceSubject): EventPageSurfaceSubjectWire;