@riverbankcms/sdk 0.130.0 → 0.130.2

package/dist/client/{propsDecoder-CAZdhwjs.mjs → propsDecoder-CBPGXEYX.mjs}

@@ -1,5 +1,7 @@
-import { a as parseColorTokenParts, b as ok$1, l as parseEventOfferingId, r as rgbColorValue, s as parseAspectRatioValue, u as parseEventSeriesId, y as err$1 } from "./colorStyles-BWpj_h4C.mjs";
+import { E as ok$1, T as err$1, a as paletteColorEntries, c as themeColorTokenSchema, g as parseEventSeriesId, h as parseEventOfferingId, l as parseColorTokenParts, o as paletteColorsFromEntries, p as parseAspectRatioValue, r as rgbColorValue, s as parseThemeColorToken } from "./colorStyles-CrxJrPjJ.mjs";
+import "react";
 import { z } from "zod";
+import "react/jsx-runtime";
 //#region ../core/src/assert-never.ts
 function assertNever$2(value, message = "Unexpected variant") {
 	throw new Error(`${message}: ${String(value)}`);
@@ -142,18 +144,32 @@ function formatEventPricing(pricing, options = {}) {
 }
 //#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$1({
-				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$1(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -1480,105 +1496,6 @@ const eventCalendarListLayoutValues = [
 	"compact"
 ];
 //#endregion
-//#region ../theme-core/src/tokens/blockColorTokens.ts
-const blockColorTokenNames = [
-	"text",
-	"heading",
-	"mutedText",
-	"surface",
-	"background",
-	"foreground",
-	"border",
-	"primary",
-	"secondary",
-	"accent",
-	"success",
-	"warning",
-	"info",
-	"error",
-	"destructive",
-	"scrim",
-	"shadow",
-	"onPrimary",
-	"onSecondary",
-	"onAccent",
-	"onSuccess",
-	"onWarning",
-	"onInfo",
-	"onError",
-	"onDestructive",
-	"onSurface"
-];
-new Set(blockColorTokenNames);
-//#endregion
-//#region ../theme-core/src/tokens/themeColorTokens.ts
-/**
-* Known palette role token names. This is the low-level source of truth for
-* palette roles used by palette variants, Theme V2 schemas, and runtime color
-* reference parsing.
-*/
-const PALETTE_TOKEN_NAMES = [
-	"primary",
-	"primaryForeground",
-	"secondary",
-	"accent",
-	"success",
-	"warning",
-	"destructive",
-	"background",
-	"surface",
-	"surfaceAlt",
-	"muted",
-	"text",
-	"border"
-];
-const paletteTokenNameSchema = z.enum(PALETTE_TOKEN_NAMES);
-const themeColorBaseTokenNames = [
-	...PALETTE_TOKEN_NAMES,
-	...blockColorTokenNames,
-	"white",
-	"neutral",
-	"primaryText",
-	"secondaryForeground",
-	"accentForeground"
-];
-const themeColorBaseTokenSet = new Set(themeColorBaseTokenNames);
-const shadeStepSet = /* @__PURE__ */ new Set([
-	"50",
-	"100",
-	"200",
-	"300",
-	"400",
-	"500",
-	"600",
-	"700",
-	"800",
-	"900",
-	"950"
-]);
-function isKnownBaseToken(value) {
-	return themeColorBaseTokenSet.has(value);
-}
-function isKnownShadeToken(value) {
-	const match = value.match(/^([a-zA-Z][a-zA-Z0-9]*)(?:-([0-9]{2,3}))$/);
-	if (!match) return false;
-	const [, base, shade] = match;
-	return Boolean(base && shade && isKnownBaseToken(base) && shadeStepSet.has(shade));
-}
-function isThemeColorTokenBase(value) {
-	return isKnownBaseToken(value) || isKnownShadeToken(value);
-}
-function isThemeColorToken(value) {
-	if (typeof value !== "string") return false;
-	const parts = parseColorTokenParts(value);
-	return parts.kind === "token" && isThemeColorTokenBase(parts.token);
-}
-function parseThemeColorToken(value) {
-	if (!isThemeColorToken(value)) return null;
-	return value.trim();
-}
-const themeColorTokenSchema = z.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
-//#endregion
 //#region ../theme-core/src/buttons/types.ts
 /**
 * Standard semantic variant roles a theme exposes.
@@ -2062,144 +1979,6 @@ z.discriminatedUnion("type", [
 	persistableMediaBaseSchema.extend({ type: z.literal("archive") })
 ]);
 //#endregion
-//#region ../theme-core/src/palette/colors.ts
-const HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-const NORMALIZABLE_HEX_REGEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
-const THEME_PALETTE_COLOR_ORDER = [
-	"primary",
-	"secondary",
-	"accent",
-	"success",
-	"warning",
-	"destructive",
-	"background",
-	"surface",
-	"surfaceAlt",
-	"muted",
-	"text",
-	"primaryForeground",
-	"border"
-];
-const hexColorSchema = z.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
-const paletteModeSchema = z.enum(["light", "dark"]);
-const PALETTE_VALUE_KEY_PREFIX = "palette-value:v1|";
-z.string().regex(/^[0-9a-f]{64}$/, "Palette hash must be a lowercase SHA-256 value").transform((value) => value);
-const paletteColorsSchema = z.object({
-	primary: hexColorSchema,
-	primaryForeground: hexColorSchema,
-	secondary: hexColorSchema,
-	accent: hexColorSchema,
-	success: hexColorSchema,
-	warning: hexColorSchema,
-	destructive: hexColorSchema,
-	background: hexColorSchema,
-	surface: hexColorSchema,
-	surfaceAlt: hexColorSchema,
-	muted: hexColorSchema,
-	text: hexColorSchema,
-	border: hexColorSchema
-}).strict().transform((value) => value);
-function normalizePaletteHex(value) {
-	if (!NORMALIZABLE_HEX_REGEX.test(value)) return null;
-	const normalized = value.toLowerCase();
-	if (normalized.length === 7) return normalized;
-	const triplet = normalized.slice(1);
-	const red = triplet.charAt(0);
-	const green = triplet.charAt(1);
-	const blue = triplet.charAt(2);
-	return `#${red}${red}${green}${green}${blue}${blue}`;
-}
-function paletteColorsFromEntries(entries) {
-	const values = {};
-	for (const entry of entries) {
-		const parsedRole = paletteTokenNameSchema.safeParse(entry.name);
-		if (!parsedRole.success) return {
-			ok: false,
-			error: {
-				kind: "unknown-role",
-				role: entry.name
-			}
-		};
-		const role = parsedRole.data;
-		if (values[role] !== void 0) return {
-			ok: false,
-			error: {
-				kind: "duplicate-role",
-				role
-			}
-		};
-		const hex = normalizePaletteHex(entry.hex);
-		if (!hex) return {
-			ok: false,
-			error: {
-				kind: "invalid-color",
-				role,
-				value: entry.hex
-			}
-		};
-		values[role] = hex;
-	}
-	const missing = PALETTE_TOKEN_NAMES.filter((role) => values[role] === void 0);
-	if (missing.length > 0) return {
-		ok: false,
-		error: {
-			kind: "missing-roles",
-			roles: missing
-		}
-	};
-	return {
-		ok: true,
-		colors: paletteColorsSchema.parse(values)
-	};
-}
-function paletteColorEntries(colors) {
-	return THEME_PALETTE_COLOR_ORDER.map((name) => ({
-		name,
-		hex: colors[name]
-	}));
-}
-function paletteColorFingerprint(colors) {
-	return PALETTE_TOKEN_NAMES.map((name) => `${name}:${colors[name]}`).join("|");
-}
-function canonicalPaletteHashInput(colors, mode) {
-	return `${mode}|${paletteColorFingerprint(colors)}`;
-}
-/**
-* Stable curated-catalogue identity. Do not reorder roles: the order comes
-* from PALETTE_TOKEN_NAMES through canonicalPaletteHashInput.
-*/
-function paletteValueKey(colors, mode) {
-	return `${PALETTE_VALUE_KEY_PREFIX}${canonicalPaletteHashInput(colors, mode)}`;
-}
-/** Parses only the exact v1 canonical form emitted by paletteValueKey. */
-function parsePaletteValueKey(value) {
-	if (typeof value !== "string" || !value.startsWith(PALETTE_VALUE_KEY_PREFIX)) return null;
-	const [rawMode, ...rawRoles] = value.slice(17).split("|");
-	const mode = paletteModeSchema.safeParse(rawMode);
-	if (!mode.success || rawRoles.length !== PALETTE_TOKEN_NAMES.length) return null;
-	const colors = paletteColorsFromEntries(rawRoles.map((roleValue) => {
-		const separator = roleValue.indexOf(":");
-		return separator === -1 ? {
-			name: "",
-			hex: ""
-		} : {
-			name: roleValue.slice(0, separator),
-			hex: roleValue.slice(separator + 1)
-		};
-	}));
-	if (!colors.ok || paletteValueKey(colors.colors, mode.data) !== value) return null;
-	return value;
-}
-z.string().transform((value, ctx) => {
-	const parsed = parsePaletteValueKey(value);
-	if (parsed) return parsed;
-	ctx.addIssue({
-		code: "custom",
-		message: "Invalid canonical palette value key"
-	});
-	return z.NEVER;
-});
-//#endregion
 //#region ../theme-core/src/palette/schema.ts
 const colourHexString = z.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
 const paletteColorSchema = z.object({
@@ -2231,9 +2010,30 @@ 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 legacyCardVariantRoleAliases = {
 	variant1: "alternative",
-	variant2: "alternative"
+	variant2: "alternative",
+	statement: "alternative"
 };
 const cardSpacingSchema = z.enum([
 	"none",
@@ -2243,6 +2043,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",
@@ -2254,7 +2065,13 @@ const gradientDirectionSchema = z.enum([
 	"to-bl"
 ]);
 const cardVariantRoleSchema = 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;
 function isCardVariantRole(value) {
 	return typeof value === "string" && cardVariantRoleValues.includes(value);
 }
@@ -2263,6 +2080,19 @@ function normalizeCardVariantRole(value) {
 	if (typeof value !== "string") return null;
 	return legacyCardVariantRoleAliases[value] ?? null;
 }
+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"),
@@ -2288,17 +2118,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",
@@ -2307,13 +2139,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(),
@@ -2322,8 +2184,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([
@@ -2347,9 +2211,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
 /**
@@ -3267,6 +3213,58 @@ function resolveOnColorForThemeToken(token) {
 	if (!shade) return rgbColorValue(`on${normalizedRole.charAt(0).toUpperCase() + normalizedRole.slice(1)}`);
 	return shade <= 400 ? "#000000" : "#FFFFFF";
 }
+//#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;
@@ -3583,14 +3581,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({
@@ -3696,30 +3687,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([
@@ -3734,12 +3701,6 @@ const inputStyle = z.object({
 	]),
 	label: z.enum(["inside", "above"])
 });
-const headerVariant = z.enum([
-	"classic",
-	"centered",
-	"transparent",
-	"floating"
-]);
 const headerPositioning = z.enum([
 	"static",
 	"sticky",
@@ -3883,7 +3844,7 @@ const headerBackgroundSchema = z.object({
 	textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
 const headerSchema = z.object({
-	variant: headerVariant,
+	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
 	shrinkOnScroll: z.boolean(),
 	maxWidth: headerMaxWidth,
@@ -4179,29 +4140,6 @@ z.object({
 	themes: z.array(themeSchema).length(3)
 });
 //#endregion
-//#region ../theme-core/src/palette/utils/colorConversion.ts
-function hexToRgb(hex) {
-	const h = hex.replace(/^#/, "");
-	const m = h.length === 3 ? h.split("").map((c) => c + c).join("") : h;
-	if (m.length !== 6) throw new Error("Bad hex");
-	const int = parseInt(m, 16);
-	return {
-		r: int >> 16 & 255,
-		g: int >> 8 & 255,
-		b: int & 255
-	};
-}
-function srgbToLinear(u) {
-	const x = u / 255;
-	return x <= .04045 ? x / 12.92 : Math.pow((x + .055) / 1.055, 2.4);
-}
-//#endregion
-//#region ../theme-core/src/palette/utils/contrast.ts
-function relativeLuminance(r, g, b) {
-	const R = srgbToLinear(r), G = srgbToLinear(g), B = srgbToLinear(b);
-	return .2126 * R + .7152 * G + .0722 * B;
-}
-//#endregion
 //#region ../theme-core/src/buttons/classNames.ts
 function themeButtonVariantClassNames(variant) {
 	if (variant === "default") return [variant];
@@ -5939,6 +5877,7 @@ const unsupportedEventRegistrationPageSurfaceSubjectSchema = z.object({
 	reason: z.enum([
 		"unsupportedSubject",
 		"invalidEventSeriesId",
+		"invalidEventSeriesBookingScope",
 		"invalidEventOfferingId"
 	])
 });
@@ -6162,6 +6101,7 @@ const eventPresetSchema = z.enum([
 	"event",
 	"class",
 	"course",
+	"term",
 	"workshop",
 	"retreat",
 	"performance"
@@ -6220,57 +6160,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()
@@ -6281,36 +6213,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({
@@ -6424,6 +6332,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
 */
@@ -6448,6 +6372,7 @@ const publicEventSchema = z.object({
 	path: z.string().nullable(),
 	destination: publicEventDestinationSchema,
 	requiresRegistration: z.boolean(),
+	bookingAvailability: publicEventBookingAvailabilitySchema,
 	deliveryMode: z.enum([
 		"in_person",
 		"online",
@@ -6466,6 +6391,8 @@ const publicEventSchema = z.object({
 	status: z.enum([
 		"active",
 		"draft",
+		"cancelled",
+		"completed",
 		"archived"
 	]).optional(),
 	timeZone: z.string(),
@@ -6504,6 +6431,7 @@ function normalizeIdList(parts) {
 //#region ../blocks/src/system/blocks/events/shared/filtering.ts
 const eventSurfacePresetValues = [
 	"course",
+	"term",
 	"class",
 	"workshop",
 	"retreat",
@@ -6648,6 +6576,43 @@ function groupItemsByDate(items, accessors) {
 	}
 	return grouped;
 }
+/**
+* Canonical responsive ladder for a user-configured column count: 1 column at
+* base, 2 from `sm`, 3 from `lg` (when the count allows), and the full count
+* from `xl`. This matches the events blocks' COLUMN_CLASSES ladder — the two
+* are derived from this single function.
+*/
+function gridUserColumnLadder(count) {
+	const capped = Number.isFinite(count) ? Math.max(1, Math.min(4, Math.floor(count))) : 3;
+	const ladder = { base: 1 };
+	if (capped >= 2) ladder.sm = 2;
+	if (capped >= 3) ladder.lg = 3;
+	if (capped >= 4) ladder.xl = capped;
+	return ladder;
+}
+/** The ladder as a space-separated `rb-*` utility class string. */
+function gridUserColumnClasses(count) {
+	const ladder = gridUserColumnLadder(count);
+	return GRID_BREAKPOINTS.flatMap((bp) => {
+		const value = ladder[bp];
+		return typeof value === "number" ? [COL_COUNT_CLASS[bp](value)] : [];
+	}).join(" ");
+}
+/** Utility class for a numeric column COUNT at a given breakpoint. */
+const COL_COUNT_CLASS = {
+	base: (n) => `rb-grid-cols-${n}`,
+	sm: (n) => `rb-sm-grid-cols-${n}`,
+	md: (n) => `rb-md-grid-cols-${n}`,
+	lg: (n) => `rb-lg-grid-cols-${n}`,
+	xl: (n) => `rb-xl-grid-cols-${n}`
+};
+const GRID_BREAKPOINTS = [
+	"base",
+	"sm",
+	"md",
+	"lg",
+	"xl"
+];
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/shared/eventCapacity.ts
 /**
@@ -6898,11 +6863,14 @@ function readAmount(value) {
 /**
 * Shared utility functions for event blocks
 */
-/** Column class mappings for grid layouts */
+/**
+* Column class mappings for grid layouts, derived from the canonical
+* responsive column ladder (see gridUserColumnLadder).
+*/
 const COLUMN_CLASSES = {
-	"2": "rb-sm-grid-cols-2",
-	"3": "rb-sm-grid-cols-2 rb-lg-grid-cols-3",
-	"4": "rb-sm-grid-cols-2 rb-lg-grid-cols-3 rb-xl-grid-cols-4"
+	"2": gridUserColumnClasses(2),
+	"3": gridUserColumnClasses(3),
+	"4": gridUserColumnClasses(4)
 };
 /**
 * Build container class based on layout mode
@@ -6914,7 +6882,7 @@ function getContainerClass(layout, columns) {
 	if (layout === "compact") return "event-listing-compact-container rb-flex rb-flex-col";
 	if (layout === "stack") return "rb-flex rb-flex-col rb-gap-6";
 	const fallbackColumnClass = COLUMN_CLASSES["3"] ?? "";
-	return `rb-grid rb-items-stretch rb-grid-cols-1 rb-gap-6 ${COLUMN_CLASSES[columns] ?? fallbackColumnClass}`;
+	return `rb-grid rb-items-stretch rb-gap-6 ${COLUMN_CLASSES[columns] ?? fallbackColumnClass}`;
 }
 /**
 * Get card orientation based on layout mode
@@ -7047,6 +7015,22 @@ function formatEventPrice(event) {
 function formatEventPriceDisplay(pricing) {
 	return formatEventPricing(pricing, { decimals: "auto" });
 }
+function closedEventBookingLabel(reason) {
+	switch (reason) {
+		case "occurrence_cancelled":
+		case "series_cancelled": return "Cancelled";
+		case "occurrence_completed":
+		case "series_completed": return "Completed";
+		case "series_draft":
+		case "series_archived":
+		case "parent_archived":
+		case "parent_inconsistent":
+		case "not_public":
+		case "already_started":
+		case "enrollment_closed": return "Registration closed";
+		default: return assertNever$2(reason);
+	}
+}
 function resolveEventHref(event) {
 	const destination = resolveRuntimeEventDestination(event);
 	return destination.kind === "external" ? destination.url : destination.path;
@@ -7071,6 +7055,15 @@ function resolveEventCta(event, buttonText) {
 	const defaultButtonText = isExternal ? destination.label : event.bookingScope === "whole_series" ? "Book course" : "Book";
 	const effectiveButtonText = buttonText ?? defaultButtonText;
 	const href = resolveEventHref(event);
+	if (event.bookingAvailability.kind === "closed") {
+		const linksToClosedWholeSeriesDetails = event.bookingAvailability.reason === "enrollment_closed" && !isExternal;
+		return {
+			label: closedEventBookingLabel(event.bookingAvailability.reason),
+			href,
+			external: isExternal,
+			hidden: !linksToClosedWholeSeriesDetails
+		};
+	}
 	if (!isExternal && isSoldOut) return {
 		label: "Sold out",
 		href,
@@ -7078,7 +7071,7 @@ function resolveEventCta(event, buttonText) {
 		hidden: true
 	};
 	return {
-		label: !(event.bookingScope === "whole_series" ? event.wholeSeries?.enrollmentOpen !== false : true) ? "Registration closed" : effectiveButtonText,
+		label: effectiveButtonText,
 		href,
 		external: isExternal,
 		hidden: false
@@ -11849,4 +11842,4 @@ function defineIslandPropsDecoder(kind) {
 	};
 }
 //#endregion
-export { hexToRgb as $, normalizeOptionalId as A, formatBookingInstant as At, groupEventsByDate as B, publicEventPricingCurrency as Bt, getWizardStepsForContext as C, ok as Ct, getEventRuntimeFiltersKey as D, addLocalScheduleDays as Dt, buildEventRuntimeFilters as E, reportWorkflowSuccess as Et, formatEventPriceDisplay as F, resolveBookingTimeZoneId as Ft, getEventAvailabilityStatus as G, formatCurrencyAmount as Gt, resolveEventLinkProps as H, publicEventPricingType as Ht, formatEventTeacherLine as I, toBookingTimeZone as It, RichTextDocSchema as J, getLocalDateKey as K, assertNever$2 as Kt, formatTime as L, toScheduledBookingDateTime as Lt, formatEventCompactDateRail as M, formatLocalScheduleDate as Mt, formatEventDateParts as N, getBookingLocalDateKey as Nt, normalizeCsvIds as O, formatBookingDate as Ot, formatEventPrice as P, parseBookingLocalDate as Pt, relativeLuminance as Q, getCardOrientation as R, parseEventPageSurfaceSubject as Rt, getStepNumber as S, err as St, staticHeaderChromeRuntime as T, reportWorkflowError as Tt, resolveRuntimeEventPricing as U, publicEventScalarPrice as Ut, resolveEventCta as V, publicEventPricingMode as Vt, getEventAvailability as W, publicEventTicketTypes as Wt, resolveEventRegistrationScopedEvents as X, isRecord$3 as Y, themeButtonClassName as Z, findPreSelectedEvent as _, resolveDefaultBookingServiceId as _t, buildProductDetailDisplay as a, deriveBookingFormViewState as at, resolveRegistrationTarget as b, assertNever$1 as bt, EMPTY_COMMERCE_CART_STATE as c, getBookingRedirectStateFromLocation as ct, deriveCommerceCheckoutState as d, isBookingServiceSlidingAmountInRange as dt, isCssColorLiteral as et, parseStoredCommerceCartState as f, parseBookingCurrencyInputToCents as ft, findEventByOccurrenceId as g, resolveBookingSiteId as gt, toRegistrationEvents as h, resolveBookingPaymentStep as ht, buildProductCardDisplay as i, logger as it, formatDate as j, formatBookingTime as jt, normalizeCsvString as k, formatBookingDateTime as kt, buildPassCartItem as l, getBookingServiceSlidingScale as lt, reduceCommerceCart as m, resolveAppointmentCheckoutVerificationState as mt, getShopDisplayForItems as n, resolveTokenOrCssColorValue as nt, formatCommercePrice as o, formatBookingCentsAsCurrencyInput as ot, productItemKey as p, prepareBookingSubmission as pt, getLocalMinuteOfDay as q, buildCartDisplay as r, normalizeCardVariantRole as rt, formatInterval as s, formatBookingSubmissionPreparationError as st, defineIslandPropsDecoder as t, resolveOnColorForThemeToken as tt, buildProductCartItem as u, getBookingSuccessMessage as ut, resolveDiscountContext as v, toSelectedCollectionOptionKind as vt, buildEventCalendarListingRender as w, okWith as wt, WIZARD_STEPS as x, clearWorkflowFeedback as xt, resolveEventRequiresPayment as y, BOOKING_FORM_DATA_RESERVED_KEYS as yt, getContainerClass as z, formatBookingPriceDisplay as zt };
+export { resolveOnColorForThemeToken as $, normalizeOptionalId as A, formatLocalScheduleDate as At, groupEventsByDate as B, publicEventPricingType as Bt, getWizardStepsForContext as C, reportWorkflowError as Ct, getEventRuntimeFiltersKey as D, formatBookingDateTime as Dt, buildEventRuntimeFilters as E, formatBookingDate as Et, formatEventPriceDisplay as F, toScheduledBookingDateTime as Ft, getEventAvailabilityStatus as G, resolveEventLinkProps as H, publicEventTicketTypes as Ht, formatEventTeacherLine as I, parseEventPageSurfaceSubject as It, RichTextDocSchema as J, getLocalDateKey as K, formatTime as L, formatBookingPriceDisplay as Lt, formatEventCompactDateRail as M, parseBookingLocalDate as Mt, formatEventDateParts as N, resolveBookingTimeZoneId as Nt, normalizeCsvIds as O, formatBookingInstant as Ot, formatEventPrice as P, toBookingTimeZone as Pt, isCssColorLiteral as Q, getCardOrientation as R, publicEventPricingCurrency as Rt, getStepNumber as S, okWith as St, staticHeaderChromeRuntime as T, addLocalScheduleDays as Tt, resolveRuntimeEventPricing as U, formatCurrencyAmount as Ut, resolveEventCta as V, publicEventScalarPrice as Vt, getEventAvailability as W, assertNever$2 as Wt, resolveEventRegistrationScopedEvents as X, isRecord$3 as Y, themeButtonClassName as Z, findPreSelectedEvent as _, BOOKING_FORM_DATA_RESERVED_KEYS as _t, buildProductDetailDisplay as a, formatBookingSubmissionPreparationError as at, resolveRegistrationTarget as b, err as bt, EMPTY_COMMERCE_CART_STATE as c, getBookingSuccessMessage as ct, deriveCommerceCheckoutState as d, prepareBookingSubmission as dt, resolveTokenOrCssColorValue as et, parseStoredCommerceCartState as f, resolveAppointmentCheckoutVerificationState as ft, findEventByOccurrenceId as g, toSelectedCollectionOptionKind as gt, toRegistrationEvents as h, resolveDefaultBookingServiceId as ht, buildProductCardDisplay as i, formatBookingCentsAsCurrencyInput as it, formatDate as j, getBookingLocalDateKey as jt, normalizeCsvString as k, formatBookingTime as kt, buildPassCartItem as l, isBookingServiceSlidingAmountInRange as lt, reduceCommerceCart as m, resolveBookingSiteId as mt, getShopDisplayForItems as n, logger as nt, formatCommercePrice as o, getBookingRedirectStateFromLocation as ot, productItemKey as p, resolveBookingPaymentStep as pt, getLocalMinuteOfDay as q, buildCartDisplay as r, deriveBookingFormViewState as rt, formatInterval as s, getBookingServiceSlidingScale as st, defineIslandPropsDecoder as t, normalizeCardVariantRole as tt, buildProductCartItem as u, parseBookingCurrencyInputToCents as ut, resolveDiscountContext as v, assertNever$1 as vt, buildEventCalendarListingRender as w, reportWorkflowSuccess as wt, WIZARD_STEPS as x, ok as xt, resolveEventRequiresPayment as y, clearWorkflowFeedback as yt, getContainerClass as z, publicEventPricingMode as zt };