@riverbankcms/sdk 0.130.0 → 0.130.2

package/dist/client/bookings.mjs

@@ -2465,23 +2465,6 @@ function createDeduplicationCache(options = {}) {
 	};
 }
 //#endregion
-//#region ../blocks/src/system/runtime/api/requestBody.ts
-function omitUndefinedOverrides(overrides) {
-	return Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
-}
-/**
-* Forward a typed request body unchanged, then apply a small set of explicit overrides.
-*
-* Undefined override values are stripped before merging so callers do not accidentally
-* clobber an existing field when they mean "no override".
-*/
-function withRequestOverrides(body, overrides) {
-	return {
-		...body,
-		...omitUndefinedOverrides(overrides)
-	};
-}
-//#endregion
 //#region ../blocks/src/system/runtime/api/endpoints.ts
 /**
 * Build endpoint path with parameter substitution
@@ -2567,7 +2550,8 @@ const EVENTS = {
 	register: {
 		path: "/public/sites/{siteId}/events/register",
 		method: "POST",
-		authScope: "portal"
+		authScope: "portal",
+		skipPreviewStage: true
 	},
 	checkout: {
 		path: "/public/sites/{siteId}/events/checkout",
@@ -2591,7 +2575,8 @@ const WHOLE_SERIES = {
 	enroll: {
 		path: "/public/sites/{siteId}/dated-offerings/whole-series/enroll",
 		method: "POST",
-		authScope: "portal"
+		authScope: "portal",
+		skipPreviewStage: true
 	},
 	checkout: {
 		path: "/public/sites/{siteId}/dated-offerings/whole-series/checkout",
@@ -3169,7 +3154,7 @@ function createBlockApi(config) {
 			const path = buildPath(EVENTS.register.path, { siteId: sid });
 			return request(EVENTS.register, {
 				path,
-				body: withRequestOverrides(data, shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {})
+				body: data
 			});
 		},
 		async createEventCheckout(data) {
@@ -3202,7 +3187,7 @@ function createBlockApi(config) {
 			const path = buildPath(WHOLE_SERIES.enroll.path, { siteId: sid });
 			return request(WHOLE_SERIES.enroll, {
 				path,
-				body: withRequestOverrides(data, shouldUsePreviewStageForNonPortalRequests ? { stage: "preview" } : {})
+				body: data
 			});
 		},
 		async checkWholeSeriesEligibility(data) {
@@ -3833,18 +3818,32 @@ function isFreePublicEventPriceDisplay(display) {
 }
 //#endregion
 //#region ../core/src/event-page-surface-subject.ts
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
+	return bookingScope === "whole_series" ? {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope,
+		isWholeSeriesBooking: true
+	} : {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope
+	};
+}
 function parseEventPageSurfaceSubject(value) {
 	if (!isRecord$6(value)) return err$1({ kind: "notObject" });
 	switch (value.kind) {
 		case "eventSeries": {
 			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
-			return eventSeriesId.ok ? ok({
-				kind: "eventSeries",
-				eventSeriesId: eventSeriesId.value
-			}) : err$1({
+			if (!eventSeriesId.ok) return err$1({
 				kind: "invalidEventSeriesId",
 				error: eventSeriesId.error
 			});
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") return err$1({
+				kind: "invalidEventSeriesBookingScope",
+				bookingScope: value.bookingScope
+			});
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -5711,8 +5710,12 @@ function formatScheduleDate(isoString, locale) {
 	return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(date);
 }
 //#endregion
-//#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
-const unsafeAsBookingFieldId = (id) => id;
+//#region ../blocks/src/system/runtime/nodes/booking-form.validationErrors.ts
+function omitRecordKey(record, key) {
+	if (!(key in record)) return record;
+	const { [key]: _removed, ...rest } = record;
+	return rest;
+}
 function createEmptyBookingValidationErrors() {
 	return {
 		formError: null,
@@ -5747,6 +5750,9 @@ function clearBookingFieldError(errors, fieldId) {
 		fieldErrors: omitRecordKey(errors.fieldErrors, fieldId)
 	};
 }
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
+const unsafeAsBookingFieldId = (id) => id;
 function createInitialBookingFlowReducerState(input) {
 	const initialData = input.initialData ?? {};
 	return {
@@ -5758,6 +5764,7 @@ function createInitialBookingFlowReducerState(input) {
 		selectedSlot: null,
 		fieldValues: collectInitialFieldValues(initialData),
 		touchedFields: {},
+		attemptedStepIds: {},
 		discountCode: toOptionalString(initialData.discountCode) ?? "",
 		selectedSlidingAmountInput: toOptionalString(initialData.selectedSlidingAmountInput) ?? "",
 		selectedCollectionOptionKind: toSelectedCollectionOptionKind(initialData.selectedCollectionOptionKind),
@@ -5799,6 +5806,25 @@ function toOptionalCustomerPassId(value) {
 function isBookingFieldValue(value) {
 	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+/**
+* Send the flow back to the date step when the slot it was holding went away,
+* leaving a scoped feedback message. A completed booking is left alone.
+*/
+function applyAvailabilitySelectionInvalidation(state, invalidation) {
+	if (state.phase !== "editing") return state;
+	return {
+		...state,
+		currentStepId: "datetime-selection",
+		selectedDate: invalidation.kind === "date_unavailable" ? void 0 : state.selectedDate,
+		selectedSlot: null,
+		feedback: {
+			kind: "error",
+			scope: "availability",
+			message: invalidation.message
+		},
+		validationErrors: clearBookingFormError(state.validationErrors)
+	};
+}
 function bookingFlowReducer(state, event) {
 	switch (event.type) {
 		case "service-selected": return {
@@ -5847,6 +5873,13 @@ function bookingFlowReducer(state, event) {
 				[event.fieldId]: true
 			}
 		};
+		case "step-advance-attempted": return state.attemptedStepIds[event.stepId] ? state : {
+			...state,
+			attemptedStepIds: {
+				...state.attemptedStepIds,
+				[event.stepId]: true
+			}
+		};
 		case "payment-option-selected": return {
 			...state,
 			selectedCollectionOptionKind: event.kind ?? void 0,
@@ -5893,20 +5926,7 @@ function bookingFlowReducer(state, event) {
 			phase: event.feedback.kind === "success" ? "completed" : "editing",
 			feedback: event.feedback
 		};
-		case "availability-selection-invalidated":
-			if (state.phase !== "editing") return state;
-			return {
-				...state,
-				currentStepId: "datetime-selection",
-				selectedDate: event.invalidation.kind === "date_unavailable" ? void 0 : state.selectedDate,
-				selectedSlot: null,
-				feedback: {
-					kind: "error",
-					scope: "availability",
-					message: event.invalidation.message
-				},
-				validationErrors: clearBookingFormError(state.validationErrors)
-			};
+		case "availability-selection-invalidated": return applyAvailabilitySelectionInvalidation(state, event.invalidation);
 		case "feedback-cleared": return {
 			...state,
 			phase: "editing",
@@ -6137,6 +6157,7 @@ function deriveBookingFlowSteps(input) {
 		requiresResourceSelection: input.requiresResourceSelection,
 		paymentResolution: stepResolution.paymentResolution
 	}));
+	const attemptedStepIds = input.attemptedStepIds ?? {};
 	const steps = stepPlan.map((step, index) => {
 		const validation = validations.get(step.id) ?? { ok: true };
 		const state = index < currentStepIndex ? "complete" : index === currentStepIndex ? "active" : "available";
@@ -6146,7 +6167,7 @@ function deriveBookingFlowSteps(input) {
 			state,
 			index,
 			visibleIndex: index,
-			errors: validation.ok ? createEmptyBookingValidationErrors() : validation.errors,
+			errors: validation.ok || !attemptedStepIds[step.id] ? createEmptyBookingValidationErrors() : validation.errors,
 			canEnter: index <= currentStepIndex,
 			canLeave: validation.ok
 		};
@@ -6415,11 +6436,6 @@ function isBlankFieldValue(value) {
 	if (Array.isArray(value)) return value.length === 0;
 	return false;
 }
-function omitRecordKey(record, key) {
-	if (!(key in record)) return record;
-	const { [key]: _removed, ...rest } = record;
-	return rest;
-}
 function readAppointmentBookingOverrideData(value) {
 	if (!isRecord$4(value)) return null;
 	const services = normalizeBookingServices(value.services);
@@ -6518,9 +6534,11 @@ function useHeadlessBookingFlow(options) {
 		currentStepId: state.currentStepId,
 		requiresServiceSelection: options.requiresServiceSelection,
 		requiresResourceSelection: options.requiresResourceSelection,
-		enableAppointmentPackages: options.enableAppointmentPackages
+		enableAppointmentPackages: options.enableAppointmentPackages,
+		attemptedStepIds: state.attemptedStepIds
 	}), [
 		data,
+		state.attemptedStepIds,
 		defaultServiceId,
 		defaultResourceId,
 		options.enableAppointmentPackages,
@@ -6872,6 +6890,10 @@ function useHeadlessBookingFlow(options) {
 			if (!latest.currentStep) return { ok: true };
 			const validation = latest.validations.get(latest.currentStep.id) ?? { ok: true };
 			if (!validation.ok) {
+				dispatch({
+					type: "step-advance-attempted",
+					stepId: latest.currentStep.id
+				});
 				dispatch({
 					type: "validation-errors-set",
 					errors: validation.errors
@@ -8125,6 +8147,26 @@ const paletteSchema = z.object({
 //#region ../theme-core/src/cards/types.ts
 const cardVariantRoleValues = ["default", "alternative"];
 const boxlessCardVariantValue = "none";
+const openCardRoleValue = "open";
+/**
+* The roles a site style implements with an actual card variant. `none` is
+* deliberately absent: it is a role value only, never a variant.
+*/
+const surfaceCardRoleValues = [...cardVariantRoleValues, openCardRoleValue];
+/**
+* The closed card-role vocabulary Looks and blocks address cards by — this is
+* `BoxStylesCardVariant` widened with `open`, not a parallel enum.
+*
+* - `none`        — no site-style card surface; the block's own composition and
+*                   the author's own card fields govern the item. This is *not*
+*                   a promise of visible boxlessness: a block whose base class
+*                   draws a border still draws one. It says the Look is not
+*                   asking the site style for a card.
+* - `open`        — boxless but marked (a rule or accent edge, no enclosing box)
+* - `default`     — the site's quiet everyday card
+* - `alternative` — the statement card carrying the site's personality
+*/
+const cardRoleValues = [...surfaceCardRoleValues, boxlessCardVariantValue];
 const cardSpacingSchema = z.enum([
 	"none",
 	"compact",
@@ -8133,6 +8175,17 @@ const cardSpacingSchema = z.enum([
 	"comfortable",
 	"spacious"
 ]);
+/** Per-axis padding, for boxless cards whose inline padding differs from block. */
+const cardSpacingAxesSchema = z.object({
+	block: cardSpacingSchema,
+	inline: cardSpacingSchema
+});
+/**
+* A card's content padding: one value for both axes, or one per axis. Two
+* fields would let a variant say both and leave the reader to guess, so this is
+* a union — the legacy `spacingAxes` key is lifted into it on parse.
+*/
+const cardSpacingValueSchema = z.union([cardSpacingSchema, cardSpacingAxesSchema]);
 const gradientDirectionSchema = z.enum([
 	"to-r",
 	"to-l",
@@ -8144,7 +8197,26 @@ const gradientDirectionSchema = z.enum([
 	"to-bl"
 ]);
 z.enum(cardVariantRoleValues);
-const boxStylesCardVariantSchema = z.enum([...cardVariantRoleValues, boxlessCardVariantValue]);
+const surfaceCardRoleSchema = z.enum(surfaceCardRoleValues);
+const cardRoleSchema = z.enum(cardRoleValues);
+/**
+* Historical name for the role vocabulary as it reaches box styles. Widened to
+* the full `CardRole` set — old values keep parsing, `open` now parses too.
+*/
+const boxStylesCardVariantSchema = cardRoleSchema;
+const PRIORITY_ROLE_INFERENCE = {
+	1: "default",
+	2: "alternative"
+};
+/**
+* Role inference for legacy card systems authored before variants carried a
+* `role`. Priority 1 is the everyday card, priority 2 the statement card —
+* which is how variants are surfaced today. `open` is never inferred: a site
+* style has to opt into it.
+*/
+function inferCardVariantRoleFromPriority(priority) {
+	return PRIORITY_ROLE_INFERENCE[priority] ?? null;
+}
 const cardBackgroundSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("solid"),
@@ -8170,17 +8242,19 @@ const cardCornerValueSchema = z.enum([
 	"pill",
 	"expressive"
 ]);
+const cardEdgeSchema = z.enum([
+	"left",
+	"top",
+	"right",
+	"bottom"
+]);
 /**
-* A single accented card edge (e.g. a left accent bar). When set, it replaces
-* the full `border` so the card reads as edge-accented rather than outlined.
+* Legacy single accented card edge (e.g. a left accent bar). Persisted and
+* curated data may still carry it; it lifts into a one-element `decorations`
+* list at the parse boundary and has no representation after that.
 */
 const cardAccentEdgeSchema = z.object({
-	edge: z.enum([
-		"left",
-		"top",
-		"right",
-		"bottom"
-	]),
+	edge: cardEdgeSchema,
 	colorToken: themeColorTokenSchema,
 	width: z.enum([
 		"thin",
@@ -8189,13 +8263,43 @@ const cardAccentEdgeSchema = z.object({
 		"heavy"
 	])
 });
+/** `hairline` (1px) is the widening the boxless `open` role needs. */
+const cardEdgeRuleWidthSchema = z.enum([
+	"hairline",
+	"thin",
+	"medium",
+	"thick",
+	"heavy"
+]);
+const cardEdgeRuleLengthSchema = z.enum(["full", "short"]);
+const cardEdgeRuleAlignSchema = z.enum([
+	"start",
+	"center",
+	"end"
+]);
+/**
+* Decorations are edge rules today. The alias exists so the list can grow into
+* a discriminated union without every call site changing.
+*/
+const cardDecorationSchema = z.object({
+	edge: cardEdgeSchema,
+	colorToken: themeColorTokenSchema,
+	width: cardEdgeRuleWidthSchema,
+	/** Defaults to `full`. */
+	length: cardEdgeRuleLengthSchema.optional(),
+	/** Where a `short` rule sits along its edge. Defaults to `start`. */
+	align: cardEdgeRuleAlignSchema.optional(),
+	/** Opacity applied to `colorToken`, 0–1. Scoped here, not on the token. */
+	alpha: z.number().min(0).max(1).optional()
+});
+const cardDecorationsSchema = z.array(cardDecorationSchema).max(2);
 const cardCornerRadiiSchema = z.object({
 	topLeft: cardCornerValueSchema.optional(),
 	topRight: cardCornerValueSchema.optional(),
 	bottomLeft: cardCornerValueSchema.optional(),
 	bottomRight: cardCornerValueSchema.optional()
 });
-const cardVariantSchema = z.object({
+const cardVariantInputSchema = z.object({
 	id: z.string(),
 	name: z.string().min(1).max(20),
 	enabled: z.boolean(),
@@ -8204,8 +8308,10 @@ const cardVariantSchema = z.object({
 		z.literal(2),
 		z.literal(3)
 	]),
+	role: surfaceCardRoleSchema.optional(),
 	background: cardBackgroundSchema,
-	spacing: cardSpacingSchema,
+	spacing: cardSpacingValueSchema,
+	spacingAxes: cardSpacingAxesSchema.optional(),
 	foregroundToken: themeColorTokenSchema.optional(),
 	shadow: z.object({
 		elevation: z.enum([
@@ -8229,9 +8335,91 @@ const cardVariantSchema = z.object({
 	]).optional(),
 	cornerRadii: cardCornerRadiiSchema.optional(),
 	border: cardBorderSchema.optional(),
+	decorations: cardDecorationsSchema.optional(),
 	accentEdge: cardAccentEdgeSchema.optional()
 });
-const cardSystemSchema = z.object({ variants: z.array(cardVariantSchema).min(1).max(3) });
+/**
+* Lift a legacy `accentEdge` into the decoration list. The old emitter reset
+* `border: 0` implicitly whenever an accent edge was present; conversion drops
+* the border instead, so the output is unchanged and the data says so.
+*/
+function normalizeLegacyAccentEdge(variant) {
+	const { accentEdge, ...rest } = normalizeLegacySpacingAxes(variant);
+	if (!accentEdge) return rest;
+	const { border: _droppedByAccentEdgeReset, ...withoutBorder } = rest;
+	return {
+		...withoutBorder,
+		decorations: [{
+			...accentEdge,
+			length: "full"
+		}]
+	};
+}
+/**
+* Lift a legacy `spacingAxes` into `spacing`. It always won over the flat value
+* when both were set, so the lift preserves the emitted padding exactly.
+*/
+function normalizeLegacySpacingAxes(variant) {
+	const { spacingAxes, ...rest } = variant;
+	return spacingAxes ? {
+		...rest,
+		spacing: spacingAxes
+	} : variant;
+}
+function validateSingleDecorationSource(variant, ctx) {
+	if (!variant.accentEdge || !variant.decorations) return;
+	ctx.addIssue({
+		code: "custom",
+		path: ["decorations"],
+		message: "A card variant carries either the legacy `accentEdge` or `decorations`, never both."
+	});
+}
+const cardVariantSchema = cardVariantInputSchema.superRefine(validateSingleDecorationSource).transform(normalizeLegacyAccentEdge);
+/**
+* Fill in roles for legacy systems whose variants declare none. Inference is
+* collision-tolerant on purpose: first claimant wins and a later variant that
+* would infer a taken role simply gets no role. Legacy data is not obliged to
+* be well-formed, and a card system that fails to parse takes the whole theme
+* down with it.
+*/
+function withInferredRoles(variants) {
+	const claimed = new Set(variants.flatMap((variant) => variant.role ? [variant.role] : []));
+	return variants.map((variant) => {
+		if (variant.role) return variant;
+		const inferred = inferCardVariantRoleFromPriority(variant.priority);
+		if (!inferred || claimed.has(inferred)) return variant;
+		claimed.add(inferred);
+		return {
+			...variant,
+			role: inferred
+		};
+	});
+}
+/**
+* Only *declared* roles are validated — a site style saying "these two
+* variants are both the default card" is an authoring error worth rejecting.
+*/
+function validateUniqueDeclaredCardVariantRoles(system, ctx) {
+	const declared = /* @__PURE__ */ new Set();
+	system.variants.forEach((variant, index) => {
+		const role = variant.role;
+		if (!role) return;
+		if (declared.has(role)) {
+			ctx.addIssue({
+				code: "custom",
+				path: [
+					"variants",
+					index,
+					"role"
+				],
+				message: `Card role "${role}" is already implemented by another variant.`
+			});
+			return;
+		}
+		declared.add(role);
+	});
+}
+const cardSystemSchema = z.object({ variants: z.array(cardVariantSchema).min(1).max(3) }).superRefine(validateUniqueDeclaredCardVariantRoles).transform((system) => ({ variants: withInferredRoles(system.variants) }));
 //#endregion
 //#region ../theme-core/src/accordions/types.ts
 /**
@@ -9052,6 +9240,58 @@ const siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 * palette context and happens in `parseThemeColorReference`.
 */
 const tokenOrCssColorValueSchema = z.string();
+//#endregion
+//#region ../theme-core/src/header/legacyHeaderVariant.ts
+/**
+* The header variants the system actually renders.
+*
+* Each one has a layout row in the site-header block and a paint target in
+* `paintTargets.ts`. This is the canonical list: the block transform's variant
+* class allowlist and the AI theme generator's enum both derive from it, so
+* they cannot drift.
+*/
+const headerVariantValues = [
+	"classic",
+	"centered",
+	"floating"
+];
+z.enum(headerVariantValues);
+/**
+* Header variant spellings that were once authorable but no longer name a
+* layout of their own, and the variant they read as now.
+*
+* `transparent` was an overlay header with no CSS of its own: everything it
+* did (transparent root background, overlay content flow) is what `floating`
+* already does, and it had zero persisted usage in production or locally when
+* it was retired. It survives here as a one-boundary alias so a theme authored
+* against the old vocabulary still parses.
+*
+* This matters because the theme schema is strict and has no per-field
+* `.catch()`: an out-of-enum variant fails `themeSchema.safeParse` for the
+* *whole* theme, which silently swaps the site's theme for
+* `modernMinimalTheme`. Aliasing here keeps that from happening.
+*/
+const legacyHeaderVariants = { transparent: "floating" };
+const legacyHeaderVariantValues = Object.keys(legacyHeaderVariants);
+/**
+* The header variant boundary for themes that go through `themeSchema`:
+* canonical variants pass through, legacy spellings normalize to the variant
+* they meant, everything else fails the parse.
+*
+* Deliberately an enum plus a transform rather than a `z.preprocess`, so the
+* schema's *input* type stays an accurate union (the legacy spelling is still
+* accepted on the wire) instead of widening to `unknown`. `SdkThemeWire` in
+* `@riverbankcms/api` is `z.input<typeof themeSchema>`, so a widened input here
+* would leak straight into a public type.
+*
+* Not every read of a persisted theme goes through the schema:
+* `resolveRuntimeTheme` in
+* `apps/dashboard/src/server/services/sites/runtimeSiteResponse.ts` returns the
+* raw database JSON asserted as `Theme` with no parse, so a theme still
+* carrying a legacy spelling reaches the theme editor un-aliased. That gap
+* predates this alias and is harmless while persisted usage is zero.
+*/
+const headerVariantWithLegacyAliasSchema = z.enum([...headerVariantValues, ...legacyHeaderVariantValues]).transform((value) => value in legacyHeaderVariants ? legacyHeaderVariants[value] : value);
 const BREAKPOINT_LG = 1024;
 const BREAKPOINT_XL = 1280;
 const BREAKPOINT_LG_DOWN = BREAKPOINT_LG - 1;
@@ -9368,14 +9608,7 @@ const cardStylesOverrideSchema = z.object({
 	spacing: semanticSpacingSchema.nullable().optional(),
 	raised: z.boolean().nullable().optional(),
 	rounded: boxRoundedSchema.nullable().optional(),
-	treatment: z.enum([
-		"accent-quote",
-		"editorial-rule",
-		"soft-panel",
-		"editorial-serif-quote",
-		"editorial-open",
-		"color-blocked"
-	]).nullable().optional(),
+	role: cardRoleSchema.nullable().optional(),
 	cardVariant: boxStylesCardVariantSchema.nullable().optional()
 });
 const blockStyleOverridesSchema = z.object({
@@ -9481,30 +9714,6 @@ const motion = z.object({
 	]).nullable()
 });
 z.object({ shape: corners });
-z.object({
-	elevation: z.enum([
-		"none",
-		"low",
-		"medium",
-		"high"
-	]),
-	border: z.enum([
-		"none",
-		"subtle",
-		"defined"
-	]),
-	shape: corners,
-	headerStyle: z.enum([
-		"plain",
-		"accentBar",
-		"subtleBg"
-	]).nullable(),
-	mediaTreatment: z.enum([
-		"square",
-		"rounded",
-		"bleed"
-	]).nullable()
-});
 const inputStyle = z.object({
 	shape: corners,
 	border: z.enum([
@@ -9519,12 +9728,6 @@ const inputStyle = z.object({
 	]),
 	label: z.enum(["inside", "above"])
 });
-const headerVariant = z.enum([
-	"classic",
-	"centered",
-	"transparent",
-	"floating"
-]);
 const headerPositioning = z.enum([
 	"static",
 	"sticky",
@@ -9668,7 +9871,7 @@ const headerBackgroundSchema = z.object({
 	textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
 const headerSchema = z.object({
-	variant: headerVariant,
+	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
 	maxWidth: headerMaxWidth,
@@ -11656,13 +11859,25 @@ function presetCategory(recipe) {
 function joinClasses(...parts) {
 	return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
 }
-function FeedbackMessage({ tone, children, className, id, title, titleClassName, bodyClassName, role = "status", live }) {
+/**
+* The class each treatment contributes on top of whatever the caller passed.
+*
+* `panel` contributes nothing: its callers already pass `alert alert-*`, so
+* adopting the vocabulary changes no existing rendering. `field-note` needs a
+* single hook — its tone styling keys off `data-feedback-tone` in the
+* theme-generated CSS rather than off a second class.
+*/
+function treatmentClass(treatment) {
+	return treatment === "field-note" ? "feedback-note" : void 0;
+}
+function FeedbackMessage({ tone, treatment = "panel", children, className, id, title, titleClassName, bodyClassName, role = "status", live }) {
 	const resolvedLive = live ?? (role === "alert" ? "assertive" : "polite");
-	const shouldWrapBody = Boolean(title || bodyClassName);
+	const shouldWrapBody = Boolean(title || bodyClassName) || treatment === "field-note";
 	return /* @__PURE__ */ jsxs("div", {
 		id,
-		className,
+		className: joinClasses(className, treatmentClass(treatment)) || void 0,
 		"data-feedback-tone": tone,
+		"data-feedback-treatment": treatment,
 		role,
 		"aria-live": resolvedLive === "off" ? void 0 : resolvedLive,
 		children: [title ? /* @__PURE__ */ jsx("p", {
@@ -12841,16 +13056,10 @@ function DefaultBookingErrorSummary({ errors, id }) {
 	if (!hasBookingValidationErrors(errors)) return null;
 	return /* @__PURE__ */ jsxs(FeedbackMessage, {
 		tone: "error",
-		className: "rb-mt-6 alert alert-error",
+		treatment: "field-note",
 		id,
 		role: "alert",
-		children: [errors.formError ? /* @__PURE__ */ jsx("p", {
-			className: "rb-caption",
-			children: /* @__PURE__ */ jsx("strong", { children: errors.formError })
-		}) : null, Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx("p", {
-			className: "rb-caption",
-			children: message
-		}, key))]
+		children: [errors.formError ? /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("strong", { children: errors.formError }) }) : null, Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx("p", { children: message }, key))]
 	});
 }
 function SelectedCheck() {
@@ -14657,6 +14866,7 @@ const eventPresetSchema = z.enum([
 	"event",
 	"class",
 	"course",
+	"term",
 	"workshop",
 	"retreat",
 	"performance"
@@ -14715,57 +14925,49 @@ z.enum([
 */
 const accessRestrictionSchema = z.enum(["none", "category"]);
 z.enum(["single", "ticket_types"]);
+const freePriceDisplaySchema = z.object({
+	kind: z.literal("free"),
+	currency: z.string()
+});
+const exactPriceDisplaySchema = z.object({
+	kind: z.literal("exact"),
+	amount: z.number(),
+	currency: z.string()
+});
+const fromPriceDisplaySchema = z.object({
+	kind: z.literal("from"),
+	amount: z.number(),
+	currency: z.string()
+});
+const unavailablePriceDisplaySchema = z.object({
+	kind: z.literal("unavailable"),
+	currency: z.string()
+});
+const rangePriceDisplaySchema = z.object({
+	kind: z.literal("range"),
+	minAmount: z.number(),
+	maxAmount: z.number(),
+	currency: z.string()
+});
+const mixedPriceDisplaySchema = z.object({
+	kind: z.literal("mixed"),
+	paidFromAmount: z.number(),
+	paidToAmount: z.number(),
+	currency: z.string()
+});
 const publicCoursePriceDisplaySchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	})
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	unavailablePriceDisplaySchema
 ]);
 z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("range"),
-		minAmount: z.number(),
-		maxAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("mixed"),
-		paidFromAmount: z.number(),
-		paidToAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	}),
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	rangePriceDisplaySchema,
+	mixedPriceDisplaySchema,
+	unavailablePriceDisplaySchema,
 	z.object({
 		kind: z.literal("external"),
 		label: z.string()
@@ -14776,36 +14978,12 @@ z.discriminatedUnion("kind", [
 	})
 ]);
 const publicEventTicketTypePriceDisplaySchema = z.union([
-	z.object({
-		kind: z.literal("free"),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("exact"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("from"),
-		amount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("range"),
-		minAmount: z.number(),
-		maxAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("mixed"),
-		paidFromAmount: z.number(),
-		paidToAmount: z.number(),
-		currency: z.string()
-	}),
-	z.object({
-		kind: z.literal("unavailable"),
-		currency: z.string()
-	})
+	freePriceDisplaySchema,
+	exactPriceDisplaySchema,
+	fromPriceDisplaySchema,
+	rangePriceDisplaySchema,
+	mixedPriceDisplaySchema,
+	unavailablePriceDisplaySchema
 ]);
 const publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
 const publicEventAttendanceModeAvailabilitySchema = z.object({
@@ -14919,6 +15097,22 @@ const publicTeamMemberSummarySchema = z.object({
 	summary: z.string().nullable(),
 	profilePath: z.string().nullable()
 });
+const publicEventBookingAvailabilitySchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("open") }), z.object({
+	kind: z.literal("closed"),
+	reason: z.enum([
+		"occurrence_cancelled",
+		"occurrence_completed",
+		"series_draft",
+		"series_cancelled",
+		"series_completed",
+		"series_archived",
+		"parent_archived",
+		"parent_inconsistent",
+		"not_public",
+		"already_started",
+		"enrollment_closed"
+	])
+})]);
 /**
 * Zod schema for public event data
 */
@@ -14943,6 +15137,7 @@ const publicEventSchema = z.object({
 	path: z.string().nullable(),
 	destination: publicEventDestinationSchema,
 	requiresRegistration: z.boolean(),
+	bookingAvailability: publicEventBookingAvailabilitySchema,
 	deliveryMode: z.enum([
 		"in_person",
 		"online",
@@ -14961,6 +15156,8 @@ const publicEventSchema = z.object({
 	status: z.enum([
 		"active",
 		"draft",
+		"cancelled",
+		"completed",
 		"archived"
 	]).optional(),
 	timeZone: z.string(),
@@ -14984,6 +15181,7 @@ const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
 	reason: z.enum([
 		"unsupportedSubject",
 		"invalidEventSeriesId",
+		"invalidEventSeriesBookingScope",
 		"invalidEventOfferingId"
 	])
 });
@@ -15014,6 +15212,10 @@ function normalizeEventRegistrationPageSurfaceSubject(value) {
 			kind: "unsupported",
 			reason: "invalidEventSeriesId"
 		};
+		case "invalidEventSeriesBookingScope": return {
+			kind: "unsupported",
+			reason: "invalidEventSeriesBookingScope"
+		};
 		case "invalidEventOfferingId": return {
 			kind: "unsupported",
 			reason: "invalidEventOfferingId"
@@ -15126,8 +15328,8 @@ function normalizePublicEventLike(value) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.planning.ts
-function getRegistrableStatuses(isPreview) {
-	return isPreview ? ["active", "draft"] : ["active"];
+function isEventRegistrationAvailable(event) {
+	return event.bookingAvailability.kind === "open";
 }
 function normalizeEventRegistrationMaxTickets(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
@@ -15283,8 +15485,7 @@ function resolveHeadlessEventRegistrationView(wizard) {
 		kind: "empty",
 		message: "No events available for registration."
 	};
-	const allowedStatuses = getRegistrableStatuses(wizard.api.config.isPreview);
-	if (!wizard.scopedEvents.some((event) => !event.status || allowedStatuses.includes(event.status)) && !wizard.occurrenceContext) return {
+	if (!wizard.scopedEvents.some(isEventRegistrationAvailable) && !wizard.occurrenceContext) return {
 		kind: "unavailable",
 		message: "Registration is not currently available for this event."
 	};