@riverbankcms/sdk 0.108.0 → 0.111.0

package/dist/client/{propsDecoder-BRWBiH7i.mjs → propsDecoder-wWN0tBDF.mjs}

@@ -1,4 +1,4 @@
-import { a as parseEventOfferingId, g as ok$1, h as err$1, o as parseEventSeriesId, r as parseAspectRatioValue, t as parseColorTokenParts } from "./colorTokenParts-CMugwvX_.mjs";
+import { _ as err$1, a as parseAspectRatioValue, c as parseEventSeriesId, s as parseEventOfferingId, t as parseColorTokenParts, v as ok$1 } from "./colorTokenParts-FSS3al6l.mjs";
 import z, { z as z$1 } from "zod";
 //#region ../core/src/assert-never.ts
 function assertNever$2(value, message = "Unexpected variant") {
@@ -201,19 +201,29 @@ const DEFAULT_BOOKING_DATE_TIME_FORMAT = {
 	minute: "2-digit"
 };
 const LOCAL_DATE_PATTERN = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
+const DATE_TIME_FORMATTER_CACHE_LIMIT = 100;
+const dateTimeFormatterCache = /* @__PURE__ */ new Map();
+const timeZoneValidityCache = /* @__PURE__ */ new Map();
 function isValidTimeZone$1(timeZone) {
+	const cached = timeZoneValidityCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	let isValid;
 	try {
 		new Intl.DateTimeFormat(DEFAULT_LOCALE, { timeZone }).format(/* @__PURE__ */ new Date());
-		return true;
+		isValid = true;
 	} catch {
-		return false;
+		isValid = false;
 	}
+	if (timeZoneValidityCache.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) timeZoneValidityCache.clear();
+	timeZoneValidityCache.set(timeZone, isValid);
+	return isValid;
 }
 function getSafeTimeZone(timeZone) {
 	const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
 	return normalized.length > 0 && isValidTimeZone$1(normalized) ? normalized : FALLBACK_TIMEZONE;
 }
 function parseStrictBookingTimeZone(timeZone) {
+	if (typeof timeZone !== "string") return null;
 	const normalized = timeZone.trim();
 	if (normalized.length === 0 || !isValidTimeZone$1(normalized)) return null;
 	return normalized;
@@ -226,10 +236,19 @@ function formatParseError(error) {
 	}
 }
 function formatToPartsLookup(date, locale, timeZone, format) {
-	return new Map(new Intl.DateTimeFormat(locale, {
+	return new Map(getCachedDateTimeFormatter(locale, timeZone, format).formatToParts(date).map((part) => [part.type, part.value]));
+}
+function getCachedDateTimeFormatter(locale, timeZone, format) {
+	const key = `${locale}\u0000${timeZone}\u0000${JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)))}`;
+	const cached = dateTimeFormatterCache.get(key);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat(locale, {
 		...format,
 		timeZone
-	}).formatToParts(date).map((part) => [part.type, part.value]));
+	});
+	if (dateTimeFormatterCache.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) dateTimeFormatterCache.clear();
+	dateTimeFormatterCache.set(key, formatter);
+	return formatter;
 }
 function getZonedDateTimeParts(date, timeZone) {
 	const parts = formatToPartsLookup(date, "en-GB", timeZone, {
@@ -282,23 +301,9 @@ function toUtcIsoDateTimeString(value) {
 	return parsed.value;
 }
 function parseScheduledBookingDateTime(input) {
+	let startsAt;
 	try {
-		const startsAt = toUtcIsoDateTimeString(input.startsAt);
-		const timeZone = parseStrictBookingTimeZone(input.timeZone);
-		if (timeZone === null) return {
-			ok: false,
-			field: "timeZone",
-			reason: "invalid_time_zone",
-			value: input.timeZone
-		};
-		return {
-			ok: true,
-			value: {
-				startsAt,
-				timeZone,
-				locale: input.locale
-			}
-		};
+		startsAt = toUtcIsoDateTimeString(input.startsAt);
 	} catch {
 		return {
 			ok: false,
@@ -307,6 +312,21 @@ function parseScheduledBookingDateTime(input) {
 			value: input.startsAt
 		};
 	}
+	const timeZone = parseStrictBookingTimeZone(input.timeZone);
+	if (timeZone === null) return {
+		ok: false,
+		field: "timeZone",
+		reason: "invalid_time_zone",
+		value: typeof input.timeZone === "string" ? input.timeZone : ""
+	};
+	return {
+		ok: true,
+		value: {
+			startsAt,
+			timeZone,
+			locale: input.locale
+		}
+	};
 }
 function parseScheduledBookingDateRange(input) {
 	const start = parseScheduledBookingDateTime(input);
@@ -345,10 +365,7 @@ function toScheduledBookingDateRange(input) {
 function formatBookingInstant(isoString, options) {
 	const date = new Date(isoString);
 	if (Number.isNaN(date.getTime())) return isoString;
-	return new Intl.DateTimeFormat(options.locale ?? DEFAULT_LOCALE, {
-		...options.format,
-		timeZone: getSafeTimeZone(options.timeZone)
-	}).format(date);
+	return getCachedDateTimeFormatter(options.locale ?? DEFAULT_LOCALE, getSafeTimeZone(options.timeZone), options.format).format(date);
 }
 function formatBookingDate(input, format = {
 	weekday: "long",
@@ -1402,98 +1419,2433 @@ const coursePricingSchema = z$1.object({
 	paymentTerms: blockBookingPaymentTermsSchema,
 	options: z$1.array(coursePricingOptionSchema)
 });
-/**
-* Zod schema for public course data
-*/
-const publicCourseSchema = z$1.object({
-	id: z$1.string(),
-	seriesId: z$1.string(),
-	title: z$1.string(),
-	slug: z$1.string(),
-	description: z$1.unknown().nullable(),
-	teamMembers: z$1.array(courseTeamMemberSummarySchema).optional(),
-	enrollmentOpen: z$1.boolean(),
-	pricing: coursePricingSchema.optional(),
-	priceCents: z$1.number().nullable(),
-	currency: z$1.string(),
-	paymentTerms: blockBookingPaymentTermsSchema,
-	enrollmentCapacity: z$1.number().nullable(),
-	acceptsMemberships: z$1.boolean(),
-	status: z$1.enum([
-		"active",
-		"draft",
-		"cancelled"
-	]),
-	sessionsCount: z$1.number(),
-	enrolledCount: z$1.number(),
-	availableSpots: z$1.number().nullable(),
-	sessions: z$1.array(courseSessionSchema),
-	venue: courseVenueSchema.nullable(),
-	contentEntryId: z$1.string().nullable()
+/**
+* Zod schema for public course data
+*/
+const publicCourseSchema = z$1.object({
+	id: z$1.string(),
+	seriesId: z$1.string(),
+	title: z$1.string(),
+	slug: z$1.string(),
+	description: z$1.unknown().nullable(),
+	teamMembers: z$1.array(courseTeamMemberSummarySchema).optional(),
+	enrollmentOpen: z$1.boolean(),
+	pricing: coursePricingSchema.optional(),
+	priceCents: z$1.number().nullable(),
+	currency: z$1.string(),
+	paymentTerms: blockBookingPaymentTermsSchema,
+	enrollmentCapacity: z$1.number().nullable(),
+	acceptsMemberships: z$1.boolean(),
+	status: z$1.enum([
+		"active",
+		"draft",
+		"cancelled"
+	]),
+	sessionsCount: z$1.number(),
+	enrolledCount: z$1.number(),
+	availableSpots: z$1.number().nullable(),
+	sessions: z$1.array(courseSessionSchema),
+	venue: courseVenueSchema.nullable(),
+	contentEntryId: z$1.string().nullable()
+});
+z$1.array(publicCourseSchema);
+//#endregion
+//#region ../blocks/src/system/blocks/event-registration.shared.ts
+/**
+* Flat occurrence context passed from `PageRenderer.$root.occurrenceContext`.
+* Kept in a shared module so the block definition and runtime contracts can
+* depend on the same schema without creating an initialization cycle.
+*/
+const occurrenceContextSchema$1 = z$1.object({
+	id: z$1.string(),
+	seriesId: z$1.string(),
+	startsAt: z$1.string(),
+	endsAt: z$1.string(),
+	timeZone: z$1.string(),
+	capacityOverride: z$1.number().nullable().optional(),
+	overrides: z$1.record(z$1.string(), z$1.unknown()).nullable().optional()
+}).nullable();
+//#endregion
+//#region ../blocks/src/system/constants/events.ts
+/**
+* Content type slugs that represent event content.
+* These are the standard slugs used when creating event content types in the CMS.
+*
+* Used by:
+* - Occurrence resolution to detect event pages
+* - Event Calendar block to identify event content
+* - Content type definitions
+*/
+const EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
+const eventCalendarDisplayModeValues = [
+	"combined",
+	"calendar",
+	"list",
+	"timetable",
+	"week-board"
+];
+const eventCalendarDefaultViewValues = ["month", "week"];
+const eventCalendarListLayoutValues = [
+	"stack",
+	"grid",
+	"compact"
+];
+/**
+* Check if a content type slug represents an event type
+*/
+function isEventContentType(slug) {
+	if (!slug) return false;
+	return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
+}
+//#endregion
+//#region ../theme-core/src/buttons/effectClassification.ts
+/**
+* Exhaustive live policy for every registered effect id.
+*
+* The resolver consumes the transition payload directly, so adding an effect
+* cannot update classification without also defining its runtime behavior.
+*/
+const BUTTON_EFFECT_POLICIES = {
+	"darken-background": {
+		classification: "colour-transition",
+		transition: {
+			kind: "adjust-shade",
+			direction: "darker"
+		}
+	},
+	"lighten-background": {
+		classification: "colour-transition",
+		transition: {
+			kind: "adjust-shade",
+			direction: "lighter"
+		}
+	},
+	"background-on-hover": {
+		classification: "colour-transition",
+		transition: { kind: "replace-background" }
+	},
+	"background-on-hover-alpha": {
+		classification: "unsupported-colour",
+		reason: "alpha_requires_surface"
+	},
+	"fade-background": {
+		classification: "unsupported-colour",
+		reason: "changes_element_opacity"
+	},
+	"opacity-reduce": {
+		classification: "unsupported-colour",
+		reason: "changes_element_opacity"
+	},
+	"gradient-text": {
+		classification: "unsupported-colour",
+		reason: "changes_foreground"
+	},
+	"text-color-change": {
+		classification: "unsupported-colour",
+		reason: "changes_foreground"
+	},
+	"border-color-change": {
+		classification: "unsupported-colour",
+		reason: "changes_border"
+	},
+	"aurora-glow": {
+		classification: "unsupported-background-overlay",
+		reason: "unresolved_background_overlay"
+	},
+	"cosmic-stardust": {
+		classification: "unsupported-background-overlay",
+		reason: "unresolved_background_overlay"
+	},
+	"gradient-border-fill": {
+		classification: "unsupported-background-overlay",
+		reason: "unresolved_background_overlay"
+	},
+	"animated-gradient-border-fill": {
+		classification: "unsupported-background-overlay",
+		reason: "unresolved_background_overlay"
+	},
+	"nav-underline": {
+		classification: "not-button",
+		reason: "not_button_effect"
+	},
+	"nav-frosted-base": {
+		classification: "not-button",
+		reason: "not_button_effect"
+	},
+	"nav-frosted-hover": {
+		classification: "not-button",
+		reason: "not_button_effect"
+	},
+	"nav-frosted-active": {
+		classification: "not-button",
+		reason: "not_button_effect"
+	},
+	"animated-gradient": { classification: "non-colour" },
+	"border-glow": { classification: "non-colour" },
+	"drop-shadow": { classification: "non-colour" },
+	"inner-shadow": { classification: "non-colour" },
+	"neumorphic-shadow": { classification: "non-colour" },
+	"outer-glow": { classification: "non-colour" },
+	"retro-3d-shadow": { classification: "non-colour" },
+	"scale-up": { classification: "non-colour" },
+	"scale-down": { classification: "non-colour" },
+	lift: { classification: "non-colour" },
+	"press-down": { classification: "non-colour" },
+	pop: { classification: "non-colour" },
+	"border-bottom-grow": { classification: "non-colour" },
+	"sketchy-border": { classification: "non-colour" },
+	"pulse-animation": { classification: "non-colour" }
+};
+function getButtonEffectPolicy(effectId) {
+	return Object.prototype.hasOwnProperty.call(BUTTON_EFFECT_POLICIES, effectId) ? BUTTON_EFFECT_POLICIES[effectId] : null;
+}
+function classifyButtonEffectId(effectId) {
+	return getButtonEffectPolicy(effectId)?.classification ?? "unknown";
+}
+//#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"
+];
+z$1.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$1.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.
+*
+* Block content references variants by role; the active theme determines
+* what each role looks like.
+*/
+const VARIANT_ROLES = [
+	"primary",
+	"secondary",
+	"outline",
+	"ghost",
+	"link",
+	"tertiary",
+	"accent"
+];
+function parseOpaqueButtonColourToken(value) {
+	const token = parseThemeColorToken(value);
+	if (token === null) return null;
+	const parts = parseColorTokenParts(token);
+	return parts.kind === "token" && parts.opacityPercent === null ? token : null;
+}
+function unsafeAsOpaqueButtonColourToken(value) {
+	return value;
+}
+const opaqueButtonColourTokenSchema = themeColorTokenSchema.refine((value) => parseOpaqueButtonColourToken(value) !== null, "Button colour tokens must be opaque").transform((value) => {
+	const token = parseOpaqueButtonColourToken(value);
+	if (token === null) throw new Error("Invariant: opaque button token passed its schema");
+	return token;
+});
+const cornerStyleSchema = z$1.enum([
+	"square",
+	"rounded",
+	"pill"
+]);
+const shadowSizeSchema = z$1.enum([
+	"none",
+	"low",
+	"medium",
+	"high"
+]);
+const textTransformSchema = z$1.enum([
+	"none",
+	"uppercase",
+	"lowercase",
+	"capitalize"
+]);
+const fontWeightSchema = z$1.union([
+	z$1.literal(500),
+	z$1.literal(600),
+	z$1.literal(700)
+]);
+const buttonTypographySchema = z$1.enum(["body", "heading"]);
+const letterSpacingSchema = z$1.enum([
+	"tight",
+	"normal",
+	"loose"
+]);
+const hoverTransformSchema = z$1.enum([
+	"none",
+	"lift",
+	"scale",
+	"press"
+]);
+const hoverColorSchema = z$1.enum([
+	"none",
+	"brighten",
+	"darken",
+	"saturate",
+	"token"
+]);
+const buttonPaddingPresetSchema = z$1.enum([
+	"compact",
+	"default",
+	"spacious"
+]);
+const gradientStyleSchema = z$1.enum([
+	"linear",
+	"radial",
+	"conic"
+]);
+const gradientSharpnessSchema = z$1.enum([
+	"smooth",
+	"medium",
+	"hard"
+]);
+const prioritySchema = z$1.union([
+	z$1.literal(1),
+	z$1.literal(2),
+	z$1.literal(3)
+]);
+z$1.enum(VARIANT_ROLES);
+const buttonSizeNameSchema = z$1.enum([
+	"sm",
+	"md",
+	"lg",
+	"xl"
+]);
+/**
+* CSS padding string in `"<vertical> <horizontal>"` shorthand form.
+*
+* Exactly two space-separated CSS length tokens. Each token is either the
+* literal `0` or a number followed by `rem`/`em`/`px`/`%`. This lets the
+* generator trust the shape rather than defensively defaulting downstream.
+*/
+const PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
+const paddingShorthandSchema = z$1.string().refine((value) => {
+	const parts = value.split(/\s+/).filter(Boolean);
+	return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
+}, { message: "Padding must be two space-separated CSS length tokens (e.g. \"0.5rem 1rem\"). Use `0` for zero." });
+const buttonSizeConfigSchema = z$1.object({
+	padding: paddingShorthandSchema,
+	fontSize: z$1.string().optional()
+});
+/**
+* `xl` is optional on the wire so themes persisted before the `xl` size was
+* added (e.g. SWTS) continue to parse. When `xl` is missing the schema
+* backfills it from `lg`, keeping `ButtonSizes` a complete `sm/md/lg/xl` map
+* downstream — generators never need to deal with an undefined `xl`.
+*/
+const buttonSizesSchema = z$1.object({
+	sm: buttonSizeConfigSchema,
+	md: buttonSizeConfigSchema,
+	lg: buttonSizeConfigSchema,
+	xl: buttonSizeConfigSchema.optional()
+}).transform(({ sm, md, lg, xl }) => ({
+	sm,
+	md,
+	lg,
+	xl: xl ?? lg
+}));
+const canonicalButtonGlobalSettingsSchema = z$1.object({
+	cornerStyle: cornerStyleSchema,
+	cornerRadius: z$1.number().min(0).max(24).optional(),
+	/**
+	* Family-level shadow inherited by variants that don't set their own.
+	* Optional and flat-by-default: when omitted, buttons carry no drop shadow
+	* (`elevation: 'none'`). A personality opts the whole family into a shadow by
+	* setting this; individual variants still override. There is no system-level
+	* shadow-by-default — shadows only appear when explicitly declared.
+	*/
+	shadow: shadowSizeSchema.optional(),
+	textTransform: textTransformSchema,
+	fontWeight: fontWeightSchema,
+	/**
+	* @deprecated Set per-variant via `variant.border.widthClass` instead.
+	* Schema field is preserved so existing presets parse; the value is unread
+	* by the current generator and will be removed once the legacy
+	* `primitives/content/components/Button.tsx` slot exports are deleted.
+	*/
+	borderWidth: z$1.union([
+		z$1.literal(1),
+		z$1.literal(2),
+		z$1.literal(3)
+	]),
+	typography: buttonTypographySchema.optional(),
+	fontSize: z$1.string().optional(),
+	letterSpacing: letterSpacingSchema.optional(),
+	italic: z$1.boolean().optional(),
+	paddingPreset: buttonPaddingPresetSchema.optional(),
+	hoverTransform: hoverTransformSchema,
+	hoverColor: hoverColorSchema,
+	hoverColorToken: opaqueButtonColourTokenSchema.optional(),
+	gradientStyle: gradientStyleSchema.optional(),
+	gradientAngle: z$1.number().min(0).max(360).optional(),
+	gradientSharpness: gradientSharpnessSchema.optional()
+});
+const buttonGlobalSettingsSchema = z$1.preprocess(normalizeLegacyButtonGlobalInput, canonicalButtonGlobalSettingsSchema);
+const gradientDirectionSchema$1 = z$1.enum([
+	"to-r",
+	"to-l",
+	"to-t",
+	"to-b",
+	"to-tr",
+	"to-tl",
+	"to-br",
+	"to-bl"
+]);
+const buttonColourTreatmentSchema = z$1.discriminatedUnion("type", [
+	z$1.object({
+		type: z$1.literal("solid"),
+		colorToken: opaqueButtonColourTokenSchema
+	}),
+	z$1.object({
+		type: z$1.literal("gradient"),
+		stops: z$1.array(opaqueButtonColourTokenSchema).min(2).transform((stops) => {
+			const [first, second, ...rest] = stops;
+			if (first === void 0 || second === void 0) throw new Error("Invariant: gradient stops passed the minimum length schema");
+			return [
+				first,
+				second,
+				...rest
+			];
+		}),
+		direction: gradientDirectionSchema$1,
+		foregroundToken: opaqueButtonColourTokenSchema
+	}),
+	z$1.object({
+		type: z$1.literal("surface"),
+		role: z$1.literal("link")
+	})
+]);
+const buttonBackgroundSchema = buttonColourTreatmentSchema;
+const effectApplicationSchema = z$1.object({
+	effectId: z$1.string(),
+	options: z$1.record(z$1.string(), z$1.json()).optional()
+});
+const buttonBorderSchema = z$1.object({ widthClass: z$1.string() });
+const buttonVariantAffordanceSchema = z$1.object({ iconId: z$1.string().min(1) });
+const variantShadowSchema = z$1.object({
+	elevation: z$1.enum([
+		"none",
+		"low",
+		"medium",
+		"high"
+	]),
+	softness: z$1.enum([
+		"crisp",
+		"soft",
+		"hard"
+	]).nullable(),
+	position: z$1.enum(["bottom", "bottom-right"]).default("bottom"),
+	colorToken: themeColorTokenSchema.optional()
+});
+const variantEffectsSchema = z$1.object({
+	base: z$1.array(effectApplicationSchema).optional(),
+	hover: z$1.array(effectApplicationSchema).optional(),
+	active: z$1.array(effectApplicationSchema).optional(),
+	focus: z$1.array(effectApplicationSchema).optional()
+});
+/**
+* Per-variant size overrides schema — every entry is optional.
+*
+* For each size key present, the values override the theme's `sizes` config
+* for that size on this variant. Missing sizes fall through to theme.sizes,
+* then system defaults.
+*/
+const variantSizeOverridesSchema = z$1.object({
+	sm: buttonSizeConfigSchema.optional(),
+	md: buttonSizeConfigSchema.optional(),
+	lg: buttonSizeConfigSchema.optional(),
+	xl: buttonSizeConfigSchema.optional()
+});
+/**
+* Unified variant schema. Every variant participates in the size system; the
+* optional `sizes` field lets a variant scale differently than the theme
+* default (e.g. link-style variants declaring zero horizontal padding at
+* every size).
+*/
+const canonicalButtonVariantSchema = z$1.object({
+	id: z$1.string(),
+	name: z$1.string().min(1).max(20),
+	enabled: z$1.boolean(),
+	priority: prioritySchema,
+	background: buttonBackgroundSchema,
+	/** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
+	borderRadius: z$1.string().optional(),
+	shadow: variantShadowSchema.optional(),
+	border: buttonBorderSchema.optional(),
+	hoverBackgroundToken: opaqueButtonColourTokenSchema.optional(),
+	effects: variantEffectsSchema.optional(),
+	sizes: variantSizeOverridesSchema.optional(),
+	affordance: buttonVariantAffordanceSchema.optional()
+});
+/**
+* Temporary persisted-theme admission boundary for issue #1206.
+*
+* Production inventory on 2026-07-22 found 22 rows using the old independent
+* `textColorToken`/border colour shape. New source and all downstream code use
+* only the canonical relationship. Delete this preprocessor after the reviewed
+* production rewrite reports zero legacy rows.
+*/
+const buttonVariantSchema = z$1.preprocess(normalizeLegacyButtonVariantInput, canonicalButtonVariantSchema);
+const buttonSystemSchema = z$1.object({
+	global: buttonGlobalSettingsSchema,
+	variants: z$1.array(buttonVariantSchema).min(1).max(6),
+	sizes: buttonSizesSchema.optional()
+});
+function normalizeLegacyButtonVariantInput(input) {
+	if (!isUnknownRecord(input)) return input;
+	const background = input.background;
+	if (!isUnknownRecord(background)) return input;
+	if (!(background.type === "transparent" || Object.prototype.hasOwnProperty.call(input, "textColorToken") || isUnknownRecord(input.border) && Object.prototype.hasOwnProperty.call(input.border, "colorToken") || hasLegacyButtonEffects(input.effects) || hasLegacyAlphaToken(input, background))) return input;
+	const { textColorToken, ...withoutLegacyText } = input;
+	const normalizedBorder = isUnknownRecord(input.border) && typeof input.border.widthClass === "string" ? { widthClass: input.border.widthClass } : input.border;
+	const normalizedAffordance = isUnknownRecord(input.affordance) && typeof input.affordance.iconId === "string" ? { iconId: input.affordance.iconId } : input.affordance;
+	const normalizedEffects = normalizeLegacyButtonEffects(input.effects, background.type);
+	const hoverBackgroundToken = stripLegacyTokenAlpha(input.hoverBackgroundToken);
+	if (background.type === "transparent") return {
+		...withoutLegacyText,
+		background: {
+			type: "surface",
+			role: "link"
+		},
+		border: normalizedBorder,
+		affordance: normalizedAffordance,
+		effects: normalizedEffects,
+		hoverBackgroundToken
+	};
+	if (background.type === "gradient") {
+		const stops = Array.isArray(background.stops) ? background.stops.map(stripLegacyTokenAlpha) : background.stops;
+		return {
+			...withoutLegacyText,
+			background: {
+				...background,
+				stops,
+				foregroundToken: stripLegacyTokenAlpha(background.foregroundToken ?? textColorToken)
+			},
+			border: normalizedBorder,
+			affordance: normalizedAffordance,
+			effects: normalizedEffects,
+			hoverBackgroundToken
+		};
+	}
+	return {
+		...withoutLegacyText,
+		background: background.type === "solid" ? {
+			...background,
+			colorToken: stripLegacyTokenAlpha(background.colorToken)
+		} : background,
+		border: normalizedBorder,
+		affordance: normalizedAffordance,
+		effects: normalizedEffects,
+		hoverBackgroundToken
+	};
+}
+function normalizeLegacyButtonGlobalInput(input) {
+	if (!isUnknownRecord(input)) return input;
+	const hoverColorToken = stripLegacyTokenAlpha(input.hoverColorToken);
+	return hoverColorToken === input.hoverColorToken ? input : {
+		...input,
+		hoverColorToken
+	};
+}
+function hasLegacyAlphaToken(input, background) {
+	const stops = isUnknownArray(background.stops) ? background.stops : [];
+	return [
+		input.hoverBackgroundToken,
+		background.colorToken,
+		background.foregroundToken,
+		...stops
+	].some((token) => stripLegacyTokenAlpha(token) !== token);
+}
+function stripLegacyTokenAlpha(value) {
+	if (typeof value !== "string") return value;
+	const slashIndex = value.indexOf("/");
+	return slashIndex < 0 ? value : value.slice(0, slashIndex);
+}
+function hasLegacyButtonEffects(input) {
+	if (!isUnknownRecord(input)) return false;
+	return [
+		"base",
+		"hover",
+		"active",
+		"focus"
+	].some((state) => {
+		const effects = input[state];
+		return Array.isArray(effects) && effects.some((effect) => {
+			if (!isUnknownRecord(effect) || typeof effect.effectId !== "string") return true;
+			const classification = classifyButtonEffectId(effect.effectId);
+			if (classification !== "colour-transition" && classification !== "non-colour") return true;
+			return effect.effectId === "background-on-hover" && isUnknownRecord(effect.options) && stripLegacyTokenAlpha(effect.options.colorToken) !== effect.options.colorToken;
+		});
+	});
+}
+function normalizeLegacyButtonEffects(input, backgroundType) {
+	if (!isUnknownRecord(input)) return input;
+	const normalized = {};
+	for (const state of [
+		"base",
+		"hover",
+		"active",
+		"focus"
+	]) {
+		const effects = input[state];
+		if (!Array.isArray(effects)) continue;
+		const safeEffects = effects.flatMap((effect) => {
+			if (!isUnknownRecord(effect) || typeof effect.effectId !== "string") return [];
+			const classification = classifyButtonEffectId(effect.effectId);
+			if (classification === "non-colour") return [effect];
+			if (classification !== "colour-transition") return [];
+			if (effect.effectId === "background-on-hover") {
+				const options = isUnknownRecord(effect.options) ? effect.options : null;
+				const colorToken = options === null ? null : parseOpaqueButtonColourToken(stripLegacyTokenAlpha(options.colorToken));
+				return colorToken === null ? [] : [{
+					...effect,
+					options: {
+						...options,
+						colorToken
+					}
+				}];
+			}
+			if (backgroundType !== "solid") return [];
+			const rawAmount = isUnknownRecord(effect.options) ? effect.options.amount : void 0;
+			const amount = typeof rawAmount === "number" && rawAmount > 0 ? Math.max(100, Math.round(rawAmount / 100) * 100) : 100;
+			return [{
+				...effect,
+				options: {
+					...isUnknownRecord(effect.options) ? effect.options : {},
+					amount
+				}
+			}];
+		});
+		if (safeEffects.length > 0) normalized[state] = safeEffects;
+	}
+	return Object.keys(normalized).length === 0 ? void 0 : normalized;
+}
+function isUnknownRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+//#endregion
+//#region ../theme-core/src/buttons/classNames.ts
+function themeButtonVariantClassNames(variant) {
+	if (variant === "default") return [variant];
+	return [variant, `button-${variant}`];
+}
+function themeButtonSizeClassName(size) {
+	return `btn-${size}`;
+}
+function themeButtonClassName(spec) {
+	return [
+		...themeButtonVariantClassNames(spec.variant),
+		themeButtonSizeClassName(spec.size),
+		spec.extraClassName
+	].filter(Boolean).join(" ");
+}
+//#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;
+}
+buttonSizeNameSchema.options;
+//#endregion
+//#region ../theme-core/src/buttons/styles/domain.ts
+const PUBLIC_BUTTON_ROLES = [
+	"primary",
+	"secondary",
+	"outline",
+	"ghost",
+	"accent"
+];
+function defineButtonStyleRecipe(recipe) {
+	return recipe;
+}
+function materializeButtonRoles(definitions) {
+	const primary = materializeCompleteRole("primary", definitions.primary.appearance);
+	const secondary = materializeCompleteRole("secondary", definitions.secondary.appearance);
+	const completeRoles = {
+		primary,
+		secondary
+	};
+	return {
+		primary,
+		secondary,
+		outline: materializeSupportingRole("outline", definitions.outline, completeRoles),
+		ghost: materializeSupportingRole("ghost", definitions.ghost, completeRoles),
+		accent: materializeSupportingRole("accent", definitions.accent, completeRoles)
+	};
+}
+function resolveButtonStyleRecipe(recipe, parameters) {
+	const parsedParameters = recipe.parameterSchema.safeParse(parameters);
+	if (!parsedParameters.success) return {
+		kind: "error",
+		error: {
+			kind: "invalid-parameters",
+			styleId: recipe.id,
+			issues: parsedParameters.error.issues.map((issue) => issue.message)
+		}
+	};
+	const definition = recipe.defineSystem(parsedParameters.data);
+	const roles = materializeButtonRoles(definition.roles);
+	const buttonSystem = {
+		global: definition.global,
+		variants: PUBLIC_BUTTON_ROLES.map((role) => roles[role]),
+		...definition.sizes ? { sizes: definition.sizes } : {}
+	};
+	const parsedButtonSystem = buttonSystemSchema.safeParse(buttonSystem);
+	if (!parsedButtonSystem.success) return {
+		kind: "error",
+		error: {
+			kind: "invalid-button-system",
+			styleId: recipe.id,
+			issues: parsedButtonSystem.error.issues.map((issue) => issue.message)
+		}
+	};
+	return {
+		kind: "resolved",
+		buttonSystem: parsedButtonSystem.data
+	};
+}
+function materializeSupportingRole(role, definition, completeRoles) {
+	if (definition.kind === "complete") return materializeCompleteRole(role, definition.appearance);
+	return {
+		...completeRoles[definition.from],
+		...definition.overrides,
+		id: role,
+		name: roleName(role),
+		enabled: true,
+		priority: 3
+	};
+}
+function materializeCompleteRole(role, appearance) {
+	return {
+		...appearance,
+		id: role,
+		name: roleName(role),
+		enabled: true,
+		priority: rolePriority(role)
+	};
+}
+function roleName(role) {
+	return role.charAt(0).toUpperCase() + role.slice(1);
+}
+function rolePriority(role) {
+	if (role === "primary") return 1;
+	if (role === "secondary") return 2;
+	return 3;
+}
+//#endregion
+//#region ../theme-core/src/buttons/styles/selection.ts
+const BUTTON_STYLE_IDS = [
+	"soft-pill",
+	"earth-pill",
+	"confident-chip",
+	"editorial-link",
+	"pebble",
+	"ink-stamp",
+	"flat-ink",
+	"brushed-wash",
+	"showtime-pill",
+	"joy-stamp",
+	"ornate-ritual",
+	"quiet-arrow"
+];
+const quietArrowParametersSchema = z$1.object({ secondaryTreatment: z$1.enum(["outlined", "solid-accent"]) }).strict();
+const emptyParametersSchema$1 = z$1.object({}).strict();
+function selectionBranch(styleId, parameters) {
+	return z$1.object({
+		styleId: z$1.literal(styleId),
+		parameters
+	}).strict();
+}
+z$1.discriminatedUnion("styleId", [
+	selectionBranch("soft-pill", emptyParametersSchema$1),
+	selectionBranch("earth-pill", emptyParametersSchema$1),
+	selectionBranch("confident-chip", emptyParametersSchema$1),
+	selectionBranch("editorial-link", emptyParametersSchema$1),
+	selectionBranch("pebble", emptyParametersSchema$1),
+	selectionBranch("ink-stamp", emptyParametersSchema$1),
+	selectionBranch("flat-ink", emptyParametersSchema$1),
+	selectionBranch("brushed-wash", emptyParametersSchema$1),
+	selectionBranch("showtime-pill", emptyParametersSchema$1),
+	selectionBranch("joy-stamp", emptyParametersSchema$1),
+	selectionBranch("ornate-ritual", emptyParametersSchema$1),
+	selectionBranch("quiet-arrow", quietArrowParametersSchema)
+]);
+//#endregion
+//#region ../theme-core/src/buttons/styles/recipes/quietArrow.ts
+const quietArrowRecipe = defineButtonStyleRecipe({
+	id: "quiet-arrow",
+	accessibilityLabel: "Wide uppercase buttons with trailing arrows",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "editorial"
+	},
+	parameterSchema: quietArrowParametersSchema,
+	defaultParameters: { secondaryTreatment: "outlined" },
+	controls: [{
+		kind: "choice",
+		parameter: "secondaryTreatment",
+		label: "Secondary button treatment",
+		options: [{
+			value: "outlined",
+			label: "Outlined"
+		}, {
+			value: "solid-accent",
+			label: "Solid accent"
+		}]
+	}],
+	defineSystem: (parameters) => ({
+		global: {
+			cornerStyle: "rounded",
+			textTransform: "uppercase",
+			fontWeight: 500,
+			borderWidth: 1,
+			typography: "body",
+			fontSize: "text-sm",
+			letterSpacing: "loose",
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.25rem",
+				fontSize: "text-xs"
+			},
+			md: {
+				padding: "0.8125rem 1.75rem",
+				fontSize: "text-sm"
+			},
+			lg: {
+				padding: "0.9375rem 2.125rem",
+				fontSize: "text-sm"
+			},
+			xl: {
+				padding: "1.0625rem 2.5rem",
+				fontSize: "text-base"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: unsafeAsOpaqueButtonColourToken("primary")
+					},
+					borderRadius: "rounded-xl",
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{
+						effectId: "darken-background",
+						options: { amount: 100 }
+					}] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: parameters.secondaryTreatment === "solid-accent" ? {
+					background: {
+						type: "solid",
+						colorToken: unsafeAsOpaqueButtonColourToken("accent")
+					},
+					borderRadius: "rounded-xl",
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{
+						effectId: "darken-background",
+						options: { amount: 100 }
+					}] }
+				} : {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-xl",
+					border: { widthClass: "border" },
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surfaceAlt" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-xl",
+					border: { widthClass: "border" }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-xl"
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: unsafeAsOpaqueButtonColourToken("accent")
+				} }
+			}
+		}
+	})
+});
+//#endregion
+//#region ../theme-core/src/buttons/styles/recipes/defineStaticButtonStyleRecipe.ts
+const emptyParametersSchema = z$1.object({}).strict();
+function defineStaticButtonStyleRecipe(input) {
+	const system = normalizeSystem(input.system);
+	return defineButtonStyleRecipe({
+		id: input.id,
+		accessibilityLabel: input.accessibilityLabel,
+		tags: input.tags,
+		parameterSchema: emptyParametersSchema,
+		defaultParameters: {},
+		controls: [],
+		defineSystem: () => system
+	});
+}
+function normalizeSystem(input) {
+	return {
+		global: buttonGlobalSettingsSchema.parse(input.global),
+		...input.sizes ? { sizes: input.sizes } : {},
+		roles: {
+			primary: normalizeCompleteRole(input.roles.primary),
+			secondary: normalizeCompleteRole(input.roles.secondary),
+			outline: normalizeSupportingRole(input.roles.outline),
+			ghost: normalizeSupportingRole(input.roles.ghost),
+			accent: normalizeSupportingRole(input.roles.accent)
+		}
+	};
+}
+function normalizeCompleteRole(role) {
+	return {
+		kind: "complete",
+		appearance: normalizeAppearance(role.appearance)
+	};
+}
+function normalizeSupportingRole(role) {
+	if (role.kind === "complete") return normalizeCompleteRole(role);
+	return {
+		kind: "derive",
+		from: role.from,
+		...role.overrides ? { overrides: normalizeAppearanceOverrides(role.overrides) } : {}
+	};
+}
+function normalizeAppearance(appearance) {
+	const { background, hoverBackgroundToken, ...rest } = appearance;
+	return {
+		...rest,
+		background: buttonColourTreatmentSchema.parse(background),
+		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
+	};
+}
+function normalizeAppearanceOverrides(overrides) {
+	const { background, hoverBackgroundToken, ...rest } = overrides;
+	return {
+		...rest,
+		...background ? { background: buttonColourTreatmentSchema.parse(background) } : {},
+		...hoverBackgroundToken ? { hoverBackgroundToken: opaqueButtonColourTokenSchema.parse(hoverBackgroundToken) } : {}
+	};
+}
+//#endregion
+//#region ../theme-core/src/buttons/styles/recipes/staticRecipes.ts
+const softPillRecipe = defineStaticButtonStyleRecipe({
+	id: "soft-pill",
+	accessibilityLabel: "Rounded pill buttons with a gentle hover lift",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			shadow: "low",
+			textTransform: "none",
+			fontWeight: 500,
+			borderWidth: 2,
+			hoverTransform: "lift",
+			hoverColor: "none"
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					shadow: {
+						elevation: "low",
+						softness: "soft",
+						position: "bottom"
+					},
+					effects: {
+						hover: [{
+							effectId: "lift",
+							options: { translateY: "-1px" }
+						}],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.98" }
+						}]
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const earthPillRecipe = defineStaticButtonStyleRecipe({
+	id: "earth-pill",
+	accessibilityLabel: "Compact rounded buttons with a quiet hover lift",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			shadow: "low",
+			textTransform: "none",
+			fontWeight: 500,
+			borderWidth: 1,
+			hoverTransform: "lift",
+			hoverColor: "none",
+			typography: "body",
+			paddingPreset: "default"
+		},
+		sizes: {
+			sm: {
+				padding: "0.5rem 1rem",
+				fontSize: "text-sm"
+			},
+			md: { padding: "0.625rem 1.35rem" },
+			lg: {
+				padding: "0.75rem 1.65rem",
+				fontSize: "text-lg"
+			},
+			xl: {
+				padding: "0.875rem 2rem",
+				fontSize: "text-xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					shadow: {
+						elevation: "low",
+						softness: "soft",
+						position: "bottom"
+					},
+					effects: {
+						hover: [{
+							effectId: "lift",
+							options: { translateY: "-1px" }
+						}, {
+							effectId: "background-on-hover",
+							options: { colorToken: "accent" }
+						}],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.98" }
+						}]
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "muted" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surfaceAlt" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					shadow: {
+						elevation: "none",
+						softness: null,
+						position: "bottom"
+					},
+					sizes: {
+						sm: {
+							padding: "0.25rem 0",
+							fontSize: "text-sm"
+						},
+						md: { padding: "0.375rem 0" },
+						lg: {
+							padding: "0.5rem 0",
+							fontSize: "text-lg"
+						},
+						xl: {
+							padding: "0.625rem 0",
+							fontSize: "text-xl"
+						}
+					}
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const confidentChipRecipe = defineStaticButtonStyleRecipe({
+	id: "confident-chip",
+	accessibilityLabel: "Moderately rounded solid buttons with a crisp hover",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "standard",
+		era: "modern"
+	},
+	system: {
+		global: {
+			cornerStyle: "rounded",
+			shadow: "medium",
+			textTransform: "none",
+			fontWeight: 600,
+			borderWidth: 1,
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-md",
+					shadow: {
+						elevation: "medium",
+						softness: "soft",
+						position: "bottom"
+					},
+					effects: {
+						hover: [{
+							effectId: "darken-background",
+							options: { amount: 100 }
+						}],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.97" }
+						}]
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "surface"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "background" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const editorialSizes = {
+	sm: { padding: "0.25rem 0" },
+	md: { padding: "0.5rem 0" },
+	lg: { padding: "0.625rem 0" },
+	xl: { padding: "0.75rem 0" }
+};
+const editorialLinkRecipe = defineStaticButtonStyleRecipe({
+	id: "editorial-link",
+	accessibilityLabel: "Flat typographic buttons with an underline treatment",
+	tags: {
+		tone: "minimal",
+		energy: "calm",
+		motion: "subtle",
+		era: "editorial"
+	},
+	system: {
+		global: {
+			cornerStyle: "square",
+			textTransform: "none",
+			fontWeight: 500,
+			borderWidth: 1,
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: editorialSizes,
+					effects: { base: [{
+						effectId: "border-bottom-grow",
+						options: {
+							height: 2,
+							colorToken: "text",
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: editorialSizes,
+					effects: { base: [{
+						effectId: "border-bottom-grow",
+						options: {
+							height: 1,
+							colorToken: "mutedText",
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: editorialSizes,
+					effects: { base: [{
+						effectId: "border-bottom-grow",
+						options: {
+							height: 1,
+							colorToken: "accent",
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: editorialSizes
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { effects: { base: [{
+					effectId: "border-bottom-grow",
+					options: {
+						height: 2,
+						colorToken: "accent",
+						origin: "left"
+					}
+				}] } }
+			}
+		}
+	}
+});
+const pebbleRecipe = defineStaticButtonStyleRecipe({
+	id: "pebble",
+	accessibilityLabel: "Generously padded pill buttons",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "standard",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			textTransform: "none",
+			fontWeight: 500,
+			borderWidth: 2,
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.75rem",
+				fontSize: "text-sm"
+			},
+			md: { padding: "0.875rem 2.25rem" },
+			lg: {
+				padding: "1.125rem 2.75rem",
+				fontSize: "text-lg"
+			},
+			xl: {
+				padding: "1.5rem 3.5rem",
+				fontSize: "text-xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{
+						effectId: "darken-background",
+						options: { amount: 100 }
+					}] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "accent" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					sizes: {
+						sm: {
+							padding: "0.375rem 0.875rem",
+							fontSize: "text-sm"
+						},
+						md: { padding: "0.5rem 1rem" },
+						lg: {
+							padding: "0.625rem 1.25rem",
+							fontSize: "text-lg"
+						},
+						xl: {
+							padding: "0.75rem 1.5rem",
+							fontSize: "text-xl"
+						}
+					}
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const brushedWashRecipe = defineStaticButtonStyleRecipe({
+	id: "brushed-wash",
+	accessibilityLabel: "Generously padded gradient buttons with soft shadows",
+	tags: {
+		tone: "classic",
+		energy: "vibrant",
+		motion: "standard",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "rounded",
+			shadow: "low",
+			textTransform: "none",
+			fontWeight: 500,
+			borderWidth: 1,
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.75rem 2rem",
+				fontSize: "text-sm"
+			},
+			md: { padding: "1rem 2.5rem" },
+			lg: {
+				padding: "1.25rem 3rem",
+				fontSize: "text-lg"
+			},
+			xl: {
+				padding: "1.625rem 3.75rem",
+				fontSize: "text-xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "gradient",
+						stops: ["primary", "accent"],
+						direction: "to-r",
+						foregroundToken: "primaryForeground"
+					},
+					borderRadius: "rounded-lg",
+					shadow: {
+						elevation: "low",
+						softness: "soft",
+						position: "bottom"
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "gradient",
+						stops: ["secondary", "accent"],
+						direction: "to-br",
+						foregroundToken: "primaryForeground"
+					},
+					borderRadius: "rounded-lg",
+					shadow: {
+						elevation: "low",
+						softness: "soft",
+						position: "bottom"
+					}
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const inkStampRecipe = defineStaticButtonStyleRecipe({
+	id: "ink-stamp",
+	accessibilityLabel: "Uppercase block-print buttons with a playful hover",
+	tags: {
+		tone: "bold",
+		energy: "vibrant",
+		motion: "standard",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "rounded",
+			textTransform: "uppercase",
+			fontWeight: 600,
+			borderWidth: 1,
+			hoverTransform: "none",
+			hoverColor: "none",
+			letterSpacing: "loose"
+		},
+		sizes: {
+			sm: {
+				padding: "0.5rem 1.25rem",
+				fontSize: "text-xs"
+			},
+			md: {
+				padding: "0.75rem 1.75rem",
+				fontSize: "text-sm"
+			},
+			lg: {
+				padding: "0.875rem 2.25rem",
+				fontSize: "text-base"
+			},
+			xl: {
+				padding: "1.125rem 2.75rem",
+				fontSize: "text-lg"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-md",
+					effects: {
+						hover: [{
+							effectId: "drop-shadow",
+							options: { intensity: "medium" }
+						}, {
+							effectId: "scale-up",
+							options: { scale: "1.02" }
+						}],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.98" }
+						}]
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: {
+						sm: {
+							padding: "0.375rem 0",
+							fontSize: "text-xs"
+						},
+						md: {
+							padding: "0.5rem 0",
+							fontSize: "text-sm"
+						},
+						lg: {
+							padding: "0.625rem 0",
+							fontSize: "text-base"
+						},
+						xl: {
+							padding: "0.75rem 0",
+							fontSize: "text-lg"
+						}
+					},
+					effects: { base: [{
+						effectId: "border-bottom-grow",
+						options: {
+							height: 1,
+							colorToken: "accent",
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const flatInkRecipe = defineStaticButtonStyleRecipe({
+	id: "flat-ink",
+	accessibilityLabel: "Flat rounded buttons with arrow affordances",
+	tags: {
+		tone: "classic",
+		energy: "calm",
+		motion: "subtle",
+		era: "editorial"
+	},
+	system: {
+		global: {
+			cornerStyle: "rounded",
+			textTransform: "none",
+			fontWeight: 600,
+			borderWidth: 1,
+			typography: "body",
+			letterSpacing: "tight",
+			paddingPreset: "default",
+			hoverTransform: "lift",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.125rem",
+				fontSize: "text-sm"
+			},
+			md: { padding: "0.8125rem 1.375rem" },
+			lg: {
+				padding: "0.9375rem 1.625rem",
+				fontSize: "text-lg"
+			},
+			xl: {
+				padding: "1.0625rem 2rem",
+				fontSize: "text-xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-lg",
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{
+						effectId: "lift",
+						options: { translateY: "-2px" }
+					}, {
+						effectId: "background-on-hover",
+						options: { colorToken: "secondary" }
+					}] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "lift",
+						options: { translateY: "-2px" }
+					}, {
+						effectId: "background-on-hover",
+						options: { colorToken: "surfaceAlt" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "lift",
+						options: { translateY: "-2px" }
+					}, {
+						effectId: "background-on-hover",
+						options: { colorToken: "surfaceAlt" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					effects: { hover: [{
+						effectId: "lift",
+						options: { translateY: "-2px" }
+					}] }
+				}
+			},
+			accent: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "accent"
+					},
+					borderRadius: "rounded-lg",
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{
+						effectId: "lift",
+						options: { translateY: "-2px" }
+					}] }
+				}
+			}
+		}
+	}
+});
+const showtimePillRecipe = defineStaticButtonStyleRecipe({
+	id: "showtime-pill",
+	accessibilityLabel: "Bold uppercase pill buttons with playful movement",
+	tags: {
+		tone: "bold",
+		energy: "vibrant",
+		motion: "expressive",
+		era: "modern"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			shadow: "low",
+			textTransform: "uppercase",
+			fontWeight: 700,
+			borderWidth: 2,
+			hoverTransform: "lift",
+			hoverColor: "darken",
+			typography: "body",
+			paddingPreset: "spacious",
+			italic: false
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.25rem",
+				fontSize: "0.875rem"
+			},
+			md: {
+				padding: "0.875rem 1.75rem",
+				fontSize: "1rem"
+			},
+			lg: {
+				padding: "1.125rem 2.25rem",
+				fontSize: "1.125rem"
+			},
+			xl: {
+				padding: "1.125rem 2.25rem",
+				fontSize: "1.125rem"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{ effectId: "pop" }] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{ effectId: "pop" }] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border-2" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "background" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			accent: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "secondary"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{ effectId: "pop" }] }
+				}
+			}
+		}
+	}
+});
+const joyStampRecipe = defineStaticButtonStyleRecipe({
+	id: "joy-stamp",
+	accessibilityLabel: "Bold pill buttons with a hard offset shadow",
+	tags: {
+		tone: "bold",
+		energy: "vibrant",
+		motion: "expressive",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "pill",
+			shadow: "high",
+			textTransform: "none",
+			typography: "heading",
+			fontWeight: 700,
+			fontSize: "text-lg",
+			borderWidth: 2,
+			hoverTransform: "none",
+			hoverColor: "none"
+		},
+		sizes: {
+			sm: {
+				padding: "0.625rem 1.25rem",
+				fontSize: "text-base"
+			},
+			md: {
+				padding: "0.875rem 1.75rem",
+				fontSize: "text-lg"
+			},
+			lg: {
+				padding: "1.125rem 2.25rem",
+				fontSize: "text-xl"
+			},
+			xl: {
+				padding: "1.25rem 2.75rem",
+				fontSize: "text-2xl"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-full",
+					shadow: {
+						elevation: "high",
+						softness: "hard",
+						position: "bottom-right",
+						colorToken: "text"
+					},
+					effects: { hover: [{ effectId: "press-down" }] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border-2" },
+					shadow: {
+						elevation: "high",
+						softness: "hard",
+						position: "bottom-right",
+						colorToken: "secondary"
+					},
+					effects: { hover: [{ effectId: "press-down" }] }
+				}
+			},
+			outline: {
+				kind: "derive",
+				from: "secondary"
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{ effectId: "press-down" }] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+const ornateRitualRecipe = defineStaticButtonStyleRecipe({
+	id: "ornate-ritual",
+	accessibilityLabel: "Uppercase framed buttons with restrained movement",
+	tags: {
+		tone: "classic",
+		energy: "vibrant",
+		motion: "subtle",
+		era: "organic"
+	},
+	system: {
+		global: {
+			cornerStyle: "rounded",
+			textTransform: "uppercase",
+			fontWeight: 600,
+			borderWidth: 1,
+			hoverTransform: "none",
+			hoverColor: "none",
+			letterSpacing: "loose"
+		},
+		sizes: {
+			sm: {
+				padding: "0.5625rem 1.25rem",
+				fontSize: "text-xs"
+			},
+			md: {
+				padding: "0.75rem 1.75rem",
+				fontSize: "text-xs"
+			},
+			lg: {
+				padding: "0.875rem 2.25rem",
+				fontSize: "text-sm"
+			},
+			xl: {
+				padding: "1rem 2.75rem",
+				fontSize: "text-base"
+			}
+		},
+		roles: {
+			primary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "primary"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: {
+						hover: [{
+							effectId: "background-on-hover",
+							options: { colorToken: "primary-100" }
+						}],
+						active: [{
+							effectId: "scale-down",
+							options: { scale: "0.98" }
+						}]
+					}
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "secondary"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "surface" }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: "muted" }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-none",
+					sizes: {
+						sm: {
+							padding: "0.375rem 0",
+							fontSize: "text-xs"
+						},
+						md: {
+							padding: "0.5rem 0",
+							fontSize: "text-sm"
+						},
+						lg: {
+							padding: "0.625rem 0",
+							fontSize: "text-base"
+						},
+						xl: {
+							padding: "0.75rem 0",
+							fontSize: "text-lg"
+						}
+					},
+					effects: { base: [{
+						effectId: "border-bottom-grow",
+						options: {
+							height: 1,
+							colorToken: "accent",
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
 });
-z$1.array(publicCourseSchema);
 //#endregion
-//#region ../blocks/src/system/blocks/event-registration.shared.ts
-/**
-* Flat occurrence context passed from `PageRenderer.$root.occurrenceContext`.
-* Kept in a shared module so the block definition and runtime contracts can
-* depend on the same schema without creating an initialization cycle.
-*/
-const occurrenceContextSchema$1 = z$1.object({
-	id: z$1.string(),
-	seriesId: z$1.string(),
-	startsAt: z$1.string(),
-	endsAt: z$1.string(),
-	timeZone: z$1.string(),
-	capacityOverride: z$1.number().nullable().optional(),
-	overrides: z$1.record(z$1.string(), z$1.unknown()).nullable().optional()
-}).nullable();
+//#region ../theme-core/src/buttons/styles/registry.ts
+const buttonStyleRecipes = [
+	softPillRecipe,
+	earthPillRecipe,
+	confidentChipRecipe,
+	editorialLinkRecipe,
+	pebbleRecipe,
+	inkStampRecipe,
+	flatInkRecipe,
+	brushedWashRecipe,
+	showtimePillRecipe,
+	joyStampRecipe,
+	ornateRitualRecipe,
+	quietArrowRecipe
+];
+const recipesById = new Map(buttonStyleRecipes.map((recipe) => [recipe.id, recipe]));
+function findButtonStyleRecipe(id) {
+	const recipe = recipesById.get(id);
+	if (recipe === void 0) throw new Error(`Button style registry is missing known style ${id}`);
+	return recipe;
+}
+function resolveButtonStyleSelection(selection) {
+	switch (selection.styleId) {
+		case "soft-pill": return resolveButtonStyleRecipe(softPillRecipe, selection.parameters);
+		case "earth-pill": return resolveButtonStyleRecipe(earthPillRecipe, selection.parameters);
+		case "confident-chip": return resolveButtonStyleRecipe(confidentChipRecipe, selection.parameters);
+		case "editorial-link": return resolveButtonStyleRecipe(editorialLinkRecipe, selection.parameters);
+		case "pebble": return resolveButtonStyleRecipe(pebbleRecipe, selection.parameters);
+		case "ink-stamp": return resolveButtonStyleRecipe(inkStampRecipe, selection.parameters);
+		case "flat-ink": return resolveButtonStyleRecipe(flatInkRecipe, selection.parameters);
+		case "brushed-wash": return resolveButtonStyleRecipe(brushedWashRecipe, selection.parameters);
+		case "showtime-pill": return resolveButtonStyleRecipe(showtimePillRecipe, selection.parameters);
+		case "joy-stamp": return resolveButtonStyleRecipe(joyStampRecipe, selection.parameters);
+		case "ornate-ritual": return resolveButtonStyleRecipe(ornateRitualRecipe, selection.parameters);
+		case "quiet-arrow": return resolveButtonStyleRecipe(quietArrowRecipe, selection.parameters);
+	}
+}
+function defaultButtonStyleSelectionFor(styleId) {
+	return {
+		styleId,
+		parameters: findButtonStyleRecipe(styleId).defaultParameters
+	};
+}
+if (buttonStyleRecipes.map((recipe) => recipe.id).length !== BUTTON_STYLE_IDS.length || BUTTON_STYLE_IDS.some((id) => !recipesById.has(id))) throw new Error("Button style registry and ButtonStyleId catalog are out of sync");
+buttonStyleRecipes.map((recipe) => {
+	const resolved = resolveButtonStyleSelection(defaultButtonStyleSelectionFor(recipe.id));
+	if (resolved.kind === "error") throw new Error(`Invalid registered button style ${recipe.id}: ${resolved.error.issues.join(", ")}`);
+	return {
+		id: recipe.id,
+		name: recipe.accessibilityLabel,
+		description: recipe.accessibilityLabel,
+		category: presetCategory(recipe),
+		buttonSystem: resolved.buttonSystem,
+		compatibility: {
+			...recipe.tags.tone ? { tones: [recipe.tags.tone] } : {},
+			...recipe.tags.energy ? { energies: [recipe.tags.energy] } : {}
+		}
+	};
+});
+function presetCategory(recipe) {
+	switch (recipe.tags.era) {
+		case "retro": return "retro";
+		case "editorial": return "minimal";
+		case "organic": return "artistic";
+		case "modern": return recipe.tags.tone === "bold" ? "modern" : "technical";
+		case "technical": return "technical";
+		case void 0: return "modern";
+	}
+}
 //#endregion
-//#region ../blocks/src/system/constants/events.ts
+//#region ../blocks/src/system/constants/buttonRoles.ts
 /**
-* Content type slugs that represent event content.
-* These are the standard slugs used when creating event content types in the CMS.
+* Semantic button roles available to block authors.
 *
-* Used by:
-* - Occurrence resolution to detect event pages
-* - Event Calendar block to identify event content
-* - Content type definitions
+* These roles are deliberately independent of a site's visual button style:
+* the active theme owns how each role looks.
 */
-const EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
-const eventCalendarDisplayModeValues = [
-	"combined",
-	"calendar",
-	"list",
-	"timetable",
-	"week-board"
-];
-const eventCalendarDefaultViewValues = ["month", "week"];
-const eventCalendarListLayoutValues = [
-	"stack",
-	"grid",
-	"compact"
-];
+const BLOCK_BUTTON_ROLES = PUBLIC_BUTTON_ROLES;
+const blockButtonRoleSchema = z$1.enum(BLOCK_BUTTON_ROLES);
 /**
-* Check if a content type slug represents an event type
+* Temporary rollout boundary for persisted content written before issue #1220.
+* Authoring remains strict through `blockButtonRoleSchema`; this parser exists
+* only until the post-deploy role rewrite has been audited in production.
 */
-function isEventContentType(slug) {
-	if (!slug) return false;
-	return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
-}
+function canonicalizePersistedBlockButtonRole(value) {
+	return value === "link" || value === "tertiary" ? "ghost" : value;
+}
+const persistedBlockButtonRoleSchema = z$1.preprocess((value) => typeof value === "string" ? canonicalizePersistedBlockButtonRole(value) : value, blockButtonRoleSchema);
+const BLOCK_BUTTON_ROLE_LABELS = {
+	primary: "Primary",
+	secondary: "Secondary",
+	outline: "Outline",
+	ghost: "Ghost",
+	accent: "Accent"
+};
+BLOCK_BUTTON_ROLES.map((value) => ({
+	value,
+	label: BLOCK_BUTTON_ROLE_LABELS[value]
+}));
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
 const previewStageSchema = z$1.enum(["preview", "published"]);
-const registrationButtonVariantSchema = z$1.enum([
-	"primary",
-	"secondary",
-	"outline"
-]);
-const eventButtonVariantSchema = z$1.enum([
-	"primary",
-	"secondary",
-	"outline",
-	"link"
-]);
+const registrationButtonVariantSchema = blockButtonRoleSchema;
+const eventButtonVariantSchema = persistedBlockButtonRoleSchema;
 const eventLayoutSchema = z$1.enum(eventCalendarListLayoutValues);
 const eventCalendarDisplayModeSchema = z$1.enum(eventCalendarDisplayModeValues);
 const eventCalendarDefaultViewSchema = z$1.enum(eventCalendarDefaultViewValues);
@@ -1689,105 +4041,6 @@ const courseRegistrationInteractiveIslandPropsCodec = createInteractiveIslandCod
 	})
 });
 //#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"
-];
-z$1.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$1.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
-//#endregion
 //#region ../theme-core/src/cards/types.ts
 const cardVariantRoleValues = ["default", "alternative"];
 const boxlessCardVariantValue = "none";
@@ -4450,6 +6703,20 @@ const blockCategoryEnum = z$1.enum([
 	"layout",
 	"interactive"
 ]);
+const blockContentSourceSchema = z$1.object({
+	kind: z$1.enum([
+		"inline",
+		"entries",
+		"mixed"
+	]),
+	contentType: z$1.string().min(1).optional()
+}).superRefine((value, ctx) => {
+	if (value.kind === "inline" && value.contentType) ctx.addIssue({
+		code: z$1.ZodIssueCode.custom,
+		path: ["contentType"],
+		message: "contentType is not allowed when contentSource.kind is \"inline\""
+	});
+});
 z$1.object({
 	name: z$1.string().min(1),
 	version: z$1.string().min(1),
@@ -4480,6 +6747,12 @@ z$1.object({
 	}).optional()).optional(),
 	category: blockCategoryEnum.optional(),
 	contentTypes: z$1.array(z$1.string()).optional(),
+	/**
+	* Explicit content-source classification (inline / entries / mixed). Optional at the
+	* schema level for backward compatibility with SDK-defined custom blocks, but every
+	* registered SYSTEM block must declare it (enforced by a registry-wide test).
+	*/
+	contentSource: blockContentSourceSchema.optional(),
 	tags: z$1.array(z$1.string()).optional(),
 	icon: z$1.string().optional()
 });
@@ -5515,6 +7788,7 @@ function createBlockManifest(config) {
 		previewCustomize: config.previewCustomize,
 		category: config.category,
 		contentTypes: config.contentTypes ? [...config.contentTypes] : void 0,
+		contentSource: config.contentSource,
 		tags: config.tags ? [...config.tags] : [],
 		icon: config.icon ?? "Box",
 		layout,
@@ -5551,6 +7825,7 @@ createBlockManifest({
 	titleSource: "heading",
 	description: "Date/time, venue, map, and other dates for an event",
 	category: "content",
+	contentSource: { kind: "entries" },
 	tags: [
 		"events",
 		"venue",
@@ -6863,11 +9138,7 @@ const newsletterPresetSchema = z$1.enum([
 	"emailNameCompany"
 ]);
 const newsletterDestinationProviderSchema = z$1.enum(["riverbank", "mailchimp"]);
-const newsletterButtonVariantSchema = z$1.enum([
-	"primary",
-	"secondary",
-	"outline"
-]);
+const newsletterButtonVariantSchema = blockButtonRoleSchema;
 const newsletterFieldSchema = z$1.object({
 	id: z$1.string(),
 	type: z$1.enum(["email", "text"]),
@@ -7444,12 +9715,7 @@ const shopSourceSchema = z$1.object({
 	showPrices: z$1.boolean().optional(),
 	showValidityPeriod: z$1.boolean().optional(),
 	showPricePerCredit: z$1.boolean().nullable().optional(),
-	buttonVariant: z$1.enum([
-		"primary",
-		"secondary",
-		"outline",
-		"link"
-	]).optional(),
+	buttonVariant: blockButtonRoleSchema.optional(),
 	passesHeading: z$1.string().optional(),
 	membershipsHeading: z$1.string().optional(),
 	buyButtonText: z$1.string().optional(),
@@ -7594,12 +9860,7 @@ const passesMembershipsHydrationSchema = z$1.object({
 	passes: z$1.array(publicPassProductSchema),
 	memberships: z$1.array(publicMembershipProductSchema),
 	passPurchaseMode: z$1.enum(["add_to_cart", "buy_now"]),
-	buttonVariant: z$1.enum([
-		"primary",
-		"secondary",
-		"outline",
-		"link"
-	])
+	buttonVariant: blockButtonRoleSchema
 });
 const productListHydrationSchema = z$1.object({
 	products: z$1.array(publicProductSchema),
@@ -7880,4 +10141,4 @@ function defineIslandPropsDecoder(kind) {
 	};
 }
 //#endregion
-export { themeColorTokenSchema as $, formatDate as A, getBookingLocalDateKey as At, resolveEventCta as B, publicEventScalarPrice as Bt, getWizardStepsForContext as C, reportWorkflowSuccess as Ct, normalizeCsvIds as D, formatBookingInstant as Dt, getEventRuntimeFiltersKey as E, formatBookingDateTime as Et, formatEventTeacherLine as F, parseEventPageSurfaceSubject as Ft, getLocalDateKey as G, resolveRuntimeEventPricing as H, formatCurrencyAmount as Ht, formatTime as I, formatBookingPriceDisplay as It, createRichTextDocFromMarkdown as J, getLocalMinuteOfDay as K, getCardOrientation as L, publicEventPricingCurrency as Lt, formatEventDateParts as M, resolveBookingTimeZoneId as Mt, formatEventPrice as N, toBookingTimeZone as Nt, normalizeCsvString as O, formatBookingTime as Ot, formatEventPriceDisplay as P, toScheduledBookingDateTime as Pt, parseThemeColorToken as Q, getContainerClass as R, publicEventPricingMode as Rt, getStepNumber as S, reportWorkflowError as St, buildEventRuntimeFilters as T, formatBookingDate as Tt, getEventAvailability as U, assertNever$2 as Ut, resolveEventLinkProps as V, publicEventTicketTypes as Vt, getEventAvailabilityStatus as W, isRecord$3 as X, unwrapRichTextRoot as Y, normalizeCardVariantRole as Z, findPreSelectedEvent as _, assertNever$1 as _t, buildProductDetailDisplay as a, getBookingRedirectStateFromLocation as at, resolveRegistrationTarget as b, ok as bt, EMPTY_COMMERCE_CART_STATE as c, isBookingServiceSlidingAmountInRange as ct, deriveCommerceCheckoutState as d, resolveAppointmentCheckoutVerificationState as dt, resolveEventRegistrationScopedEvents as et, parseStoredCommerceCartState as f, resolveBookingPaymentStep as ft, findEventByOccurrenceId as g, BOOKING_FORM_DATA_RESERVED_KEYS as gt, toRegistrationEvents as h, toSelectedCollectionOptionKind as ht, buildProductCardDisplay as i, formatBookingSubmissionPreparationError as it, formatEventCompactDateRail as j, parseBookingLocalDate as jt, normalizeOptionalId as k, formatLocalScheduleDate as kt, buildPassCartItem as l, parseBookingCurrencyInputToCents as lt, reduceCommerceCart as m, resolveDefaultBookingServiceId as mt, getShopDisplayForItems as n, deriveBookingFormViewState as nt, formatCommercePrice as o, getBookingServiceSlidingScale as ot, productItemKey as p, resolveBookingSiteId as pt, normalizeEventBlockKind as q, buildCartDisplay as r, formatBookingCentsAsCurrencyInput as rt, formatInterval as s, getBookingSuccessMessage as st, defineIslandPropsDecoder as t, logger as tt, buildProductCartItem as u, prepareBookingSubmission as ut, resolveDiscountContext as v, clearWorkflowFeedback as vt, buildEventCalendarListingRender as w, addLocalScheduleDays as wt, WIZARD_STEPS as x, okWith as xt, resolveEventRequiresPayment as y, err as yt, groupEventsByDate as z, publicEventPricingType as zt };
+export { relativeLuminance as $, formatDate as A, formatBookingTime as At, resolveEventCta as B, publicEventPricingMode as Bt, getWizardStepsForContext as C, okWith as Ct, normalizeCsvIds as D, formatBookingDate as Dt, getEventRuntimeFiltersKey as E, addLocalScheduleDays as Et, formatEventTeacherLine as F, toBookingTimeZone as Ft, getLocalDateKey as G, assertNever$2 as Gt, resolveRuntimeEventPricing as H, publicEventScalarPrice as Ht, formatTime as I, toScheduledBookingDateTime as It, createRichTextDocFromMarkdown as J, getLocalMinuteOfDay as K, getCardOrientation as L, parseEventPageSurfaceSubject as Lt, formatEventDateParts as M, getBookingLocalDateKey as Mt, formatEventPrice as N, parseBookingLocalDate as Nt, normalizeCsvString as O, formatBookingDateTime as Ot, formatEventPriceDisplay as P, resolveBookingTimeZoneId as Pt, resolveEventRegistrationScopedEvents as Q, getContainerClass as R, formatBookingPriceDisplay as Rt, getStepNumber as S, ok as St, buildEventRuntimeFilters as T, reportWorkflowSuccess as Tt, getEventAvailability as U, publicEventTicketTypes as Ut, resolveEventLinkProps as V, publicEventPricingType as Vt, getEventAvailabilityStatus as W, formatCurrencyAmount as Wt, isRecord$3 as X, unwrapRichTextRoot as Y, normalizeCardVariantRole as Z, findPreSelectedEvent as _, toSelectedCollectionOptionKind as _t, buildProductDetailDisplay as a, formatBookingCentsAsCurrencyInput as at, resolveRegistrationTarget as b, clearWorkflowFeedback as bt, EMPTY_COMMERCE_CART_STATE as c, getBookingServiceSlidingScale as ct, deriveCommerceCheckoutState as d, parseBookingCurrencyInputToCents as dt, hexToRgb as et, parseStoredCommerceCartState as f, prepareBookingSubmission as ft, findEventByOccurrenceId as g, resolveDefaultBookingServiceId as gt, toRegistrationEvents as h, resolveBookingSiteId as ht, buildProductCardDisplay as i, deriveBookingFormViewState as it, formatEventCompactDateRail as j, formatLocalScheduleDate as jt, normalizeOptionalId as k, formatBookingInstant as kt, buildPassCartItem as l, getBookingSuccessMessage as lt, reduceCommerceCart as m, resolveBookingPaymentStep as mt, getShopDisplayForItems as n, parseThemeColorToken as nt, formatCommercePrice as o, formatBookingSubmissionPreparationError as ot, productItemKey as p, resolveAppointmentCheckoutVerificationState as pt, normalizeEventBlockKind as q, buildCartDisplay as r, logger as rt, formatInterval as s, getBookingRedirectStateFromLocation as st, defineIslandPropsDecoder as t, themeButtonClassName as tt, buildProductCartItem as u, isBookingServiceSlidingAmountInRange as ut, resolveDiscountContext as v, BOOKING_FORM_DATA_RESERVED_KEYS as vt, buildEventCalendarListingRender as w, reportWorkflowError as wt, WIZARD_STEPS as x, err as xt, resolveEventRequiresPayment as y, assertNever$1 as yt, groupEventsByDate as z, publicEventPricingCurrency as zt };