@riverbankcms/sdk 0.109.0 → 0.118.0

package/dist/client/{propsDecoder-CkXxkdSR.mjs → propsDecoder-DreFXjNP.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 { 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 z, { z as z$1 } from "zod";
 //#region ../core/src/assert-never.ts
 function assertNever$2(value, message = "Unexpected variant") {
@@ -1498,214 +1498,6 @@ function isEventContentType(slug) {
 	return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
 }
 //#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 eventLayoutSchema = z$1.enum(eventCalendarListLayoutValues);
-const eventCalendarDisplayModeSchema = z$1.enum(eventCalendarDisplayModeValues);
-const eventCalendarDefaultViewSchema = z$1.enum(eventCalendarDefaultViewValues);
-const columnOptionSchema = z$1.enum([
-	"2",
-	"3",
-	"4"
-]);
-const weekStartSchema = z$1.enum(["sunday", "monday"]);
-const filterAutoShowSchema = z$1.enum([
-	"auto",
-	"always",
-	"never"
-]);
-const calendarTabViewsSchema = z$1.enum([
-	"both",
-	"month",
-	"week"
-]);
-const unsupportedEventRegistrationPageSurfaceSubjectSchema = z$1.object({
-	kind: z$1.literal("unsupported"),
-	reason: z$1.enum([
-		"unsupportedSubject",
-		"invalidEventSeriesId",
-		"invalidEventOfferingId"
-	])
-});
-const eventRegistrationPageSurfaceSubjectSchema = z$1.unknown().transform((value, ctx) => {
-	const unsupported = unsupportedEventRegistrationPageSurfaceSubjectSchema.safeParse(value);
-	if (unsupported.success) return unsupported.data;
-	const parsed = parseEventPageSurfaceSubject(value);
-	if (parsed.ok) return parsed.value;
-	ctx.addIssue({
-		code: z$1.ZodIssueCode.custom,
-		message: `Invalid event page-surface subject (${parsed.error.kind})`
-	});
-	return z$1.NEVER;
-});
-function resolveEventRegistrationScope(context) {
-	const occurrenceSeriesId = context.occurrenceContext?.seriesId;
-	if (occurrenceSeriesId) return {
-		kind: "occurrenceSeries",
-		seriesId: occurrenceSeriesId
-	};
-	if (context.subject?.kind === "eventSeries") return {
-		kind: "pageSurfaceSeries",
-		seriesId: context.subject.eventSeriesId
-	};
-	if (context.subject?.kind === "eventOffering") return {
-		kind: "pageSurfaceOffering",
-		offeringId: context.subject.eventOfferingId,
-		seriesIds: context.subject.availableEventSeriesIds
-	};
-	if (context.subject?.kind === "unsupported") return {
-		kind: "unsupportedPageSurfaceSubject",
-		reason: context.subject.reason
-	};
-	const entrySlug = context.contentEntry?.slug;
-	const entryContentType = context.contentEntry?.contentTypeSlug;
-	if (entrySlug && entryContentType && isEventContentType(entryContentType)) return {
-		kind: "legacyEventSlug",
-		slug: entrySlug
-	};
-	return { kind: "unscoped" };
-}
-function applyEventRegistrationScope(events, scope) {
-	switch (scope.kind) {
-		case "occurrenceSeries":
-		case "pageSurfaceSeries": return events.filter((event) => event.seriesId === scope.seriesId);
-		case "pageSurfaceOffering": {
-			const seriesIds = new Set(scope.seriesIds);
-			return events.filter((event) => seriesIds.has(event.seriesId));
-		}
-		case "legacyEventSlug": return events.filter((event) => event.slug === scope.slug);
-		case "unsupportedPageSurfaceSubject": return [];
-		case "unscoped": return [...events];
-	}
-}
-function resolveEventRegistrationScopedEvents(events, context) {
-	return applyEventRegistrationScope(events, resolveEventRegistrationScope(context));
-}
-//#endregion
-//#region ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-const contentEntrySchema$2 = z$1.object({
-	id: z$1.string(),
-	slug: z$1.string(),
-	contentTypeSlug: z$1.string()
-});
-const courseEntrySubrouteContextSchema = z$1.union([z$1.object({
-	kind: z$1.literal("course-run"),
-	run: z$1.object({
-		courseId: z$1.string(),
-		seriesId: z$1.string(),
-		runSlug: z$1.string(),
-		runName: z$1.string().nullable()
-	})
-}), z$1.object({
-	kind: z$1.literal("event-occurrence"),
-	occurrence: occurrenceContextSchema$1
-})]);
-const courseRegistrationSourceSchema = z$1.object({
-	siteId: z$1.string().optional(),
-	apiBaseUrl: z$1.string().optional(),
-	portalToken: z$1.string().nullable().optional(),
-	contentEntry: contentEntrySchema$2.nullable().optional(),
-	entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
-	courses: z$1.array(publicCourseSchema).nullable().optional(),
-	className: z$1.string().nullable().optional(),
-	showSessions: z$1.boolean().optional(),
-	showPrice: z$1.boolean().optional(),
-	showCapacity: z$1.boolean().optional(),
-	showVenue: z$1.boolean().optional(),
-	successMessage: z$1.string().optional(),
-	waitlistMessage: z$1.string().optional(),
-	membershipMessage: z$1.string().optional(),
-	buttonText: z$1.string().nullable().optional(),
-	buttonVariant: registrationButtonVariantSchema.optional(),
-	stage: previewStageSchema.optional()
-});
-const courseRegistrationDisplaySchema = z$1.object({
-	kind: z$1.literal("course-registration"),
-	state: z$1.literal("shell"),
-	className: z$1.string().nullable(),
-	summaryButtonText: z$1.string()
-});
-const courseRegistrationHydrationSchema = z$1.object({
-	contentEntry: contentEntrySchema$2.nullable().optional(),
-	entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
-	courses: z$1.array(publicCourseSchema).nullable().optional(),
-	showSessions: z$1.boolean().optional(),
-	showPrice: z$1.boolean().optional(),
-	showCapacity: z$1.boolean().optional(),
-	showVenue: z$1.boolean().optional(),
-	successMessage: z$1.string().optional(),
-	waitlistMessage: z$1.string().optional(),
-	membershipMessage: z$1.string().optional(),
-	buttonVariant: registrationButtonVariantSchema.optional()
-});
-const courseRegistrationRenderSchema = z$1.object({
-	display: courseRegistrationDisplaySchema,
-	hydration: courseRegistrationHydrationSchema
-});
-const courseRegistrationIslandMetaCodec = createZodCodec(z$1.object({
-	siteId: z$1.string().optional(),
-	apiBaseUrl: z$1.string().optional(),
-	portalToken: z$1.string().nullable().optional(),
-	stage: previewStageSchema.optional()
-}));
-const courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "portalToken", "stage");
-function buildCourseRegistrationDisplay(source) {
-	return {
-		kind: "course-registration",
-		state: "shell",
-		className: source.className ?? null,
-		summaryButtonText: source.buttonText?.trim() || "Sign up"
-	};
-}
-const courseRegistrationInteractiveIslandPropsCodec = createInteractiveIslandCodec({
-	runtime: defineClientOwnedBlockRuntime({
-		kind: "client-owned",
-		contracts: {
-			source: createZodCodec(courseRegistrationSourceSchema),
-			render: createZodCodec(courseRegistrationRenderSchema)
-		},
-		buildRender: (source) => ({
-			display: buildCourseRegistrationDisplay(source),
-			hydration: {
-				contentEntry: source.contentEntry ?? null,
-				entrySubrouteContext: source.entrySubrouteContext ?? null,
-				subject: source.subject ?? null,
-				courses: source.courses ?? null,
-				showSessions: source.showSessions,
-				showPrice: source.showPrice,
-				showCapacity: source.showCapacity,
-				showVenue: source.showVenue,
-				successMessage: source.successMessage,
-				waitlistMessage: source.waitlistMessage,
-				membershipMessage: source.membershipMessage,
-				buttonVariant: source.buttonVariant
-			}
-		})
-	}),
-	mode: "course-registration",
-	meta: courseRegistrationIslandMetaCodec,
-	metaKeys: courseRegistrationIslandMetaKeys,
-	selectMeta: (value) => ({
-		siteId: value.siteId,
-		apiBaseUrl: value.apiBaseUrl,
-		portalToken: value.portalToken,
-		stage: value.stage
-	})
-});
-//#endregion
 //#region ../theme-core/src/tokens/blockColorTokens.ts
 const blockColorTokenNames = [
 	"text",
@@ -1805,23 +1597,457 @@ function parseThemeColorToken(value) {
 }
 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";
-const legacyCardVariantRoleAliases = {
-	variant1: "alternative",
-	variant2: "alternative"
-};
-const cardSpacingSchema = z$1.enum([
+//#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"
+];
+/**
+* Canonical persisted/CSS-safe button variant identifier.
+*
+* IDs become class selectors, so keep the contract deliberately narrower than
+* an arbitrary string and shared with every authoring/runtime boundary.
+*/
+const buttonVariantIdSchema = z$1.string().min(1).max(50).regex(/^[a-z0-9-]+$/, "Button variant IDs may contain lowercase letters, numbers, and hyphens only");
+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 buttonShadeAmountSchema = z$1.number().finite().min(0).max(900).multipleOf(100);
+const buttonShadowIntensitySchema = z$1.enum([
+	"subtle",
+	"medium",
+	"strong"
+]);
+/**
+* The complete persisted button-effect contract.
+*
+* Navigation has its own generic interactive-effect model. Button variants use
+* this closed union so unsupported effect IDs, unknown option keys, and unsafe
+* CSS values cannot become representable after the schema boundary.
+*/
+const buttonEffectApplicationSchema = z$1.discriminatedUnion("effectId", [
+	z$1.strictObject({
+		effectId: z$1.literal("darken-background"),
+		options: z$1.strictObject({ amount: buttonShadeAmountSchema.optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("lighten-background"),
+		options: z$1.strictObject({ amount: buttonShadeAmountSchema.optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("background-on-hover"),
+		options: z$1.strictObject({ colorToken: opaqueButtonColourTokenSchema.optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("animated-gradient"),
+		options: z$1.strictObject({ direction: z$1.enum(["horizontal", "vertical"]).optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("drop-shadow"),
+		options: z$1.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("inner-shadow"),
+		options: z$1.strictObject({}).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("neumorphic-shadow"),
+		options: z$1.strictObject({
+			mode: z$1.enum(["raised", "pressed"]).optional(),
+			intensity: buttonShadowIntensitySchema.optional()
+		}).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("retro-3d-shadow"),
+		options: z$1.strictObject({}).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("scale-up"),
+		options: z$1.strictObject({ scale: z$1.enum([
+			"1.02",
+			"1.03",
+			"1.05",
+			"1.10"
+		]).optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("scale-down"),
+		options: z$1.strictObject({ scale: z$1.enum([
+			"0.90",
+			"0.95",
+			"0.97",
+			"0.98"
+		]).optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("lift"),
+		options: z$1.strictObject({ amount: z$1.enum([
+			"0.25",
+			"0.5",
+			"1"
+		]).optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("press-down"),
+		options: z$1.strictObject({}).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("pop"),
+		options: z$1.strictObject({ intensity: z$1.enum([
+			"subtle",
+			"medium",
+			"dramatic"
+		]).optional() }).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("border-bottom-grow"),
+		options: z$1.strictObject({
+			height: z$1.union([z$1.literal(1), z$1.literal(2)]).optional(),
+			origin: z$1.enum([
+				"left",
+				"center",
+				"right"
+			]).optional()
+		}).optional()
+	}),
+	z$1.strictObject({
+		effectId: z$1.literal("sketchy-border"),
+		options: z$1.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
+	})
+]);
+const cornerStyleSchema = z$1.enum([
+	"square",
+	"rounded",
+	"pill"
+]);
+const shadowSizeSchema = z$1.enum([
 	"none",
-	"compact",
-	"cozy",
+	"low",
 	"medium",
-	"comfortable",
-	"spacious"
+	"high"
 ]);
-const gradientDirectionSchema = z$1.enum([
-	"to-r",
+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"
+]);
+z$1.enum(["none", "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 buttonGlobalSettingsBaseSchema = z$1.strictObject({
+	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,
+	typography: buttonTypographySchema.optional(),
+	fontSize: z$1.string().optional(),
+	letterSpacing: letterSpacingSchema.optional(),
+	italic: z$1.boolean().optional(),
+	paddingPreset: buttonPaddingPresetSchema.optional(),
+	hoverTransform: hoverTransformSchema,
+	gradientStyle: gradientStyleSchema.optional(),
+	gradientAngle: z$1.number().min(0).max(360).optional(),
+	gradientSharpness: gradientSharpnessSchema.optional()
+});
+const buttonGlobalSettingsSchema = z$1.discriminatedUnion("hoverColor", [buttonGlobalSettingsBaseSchema.extend({
+	hoverColor: z$1.literal("none"),
+	hoverColorToken: z$1.never().optional()
+}), buttonGlobalSettingsBaseSchema.extend({
+	hoverColor: z$1.literal("token"),
+	hoverColorToken: opaqueButtonColourTokenSchema
+})]);
+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.strictObject({
+		type: z$1.literal("solid"),
+		colorToken: opaqueButtonColourTokenSchema
+	}),
+	z$1.strictObject({
+		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.strictObject({
+		type: z$1.literal("surface"),
+		role: z$1.literal("link")
+	})
+]);
+const buttonBackgroundSchema = buttonColourTreatmentSchema;
+const buttonBorderSchema = z$1.strictObject({ widthClass: z$1.string() });
+const buttonVariantAffordanceSchema = z$1.strictObject({ iconId: z$1.string().min(1) });
+const variantShadowSchema = z$1.strictObject({
+	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: opaqueButtonColourTokenSchema.optional()
+});
+const variantEffectsSchema = z$1.strictObject({
+	base: z$1.array(buttonEffectApplicationSchema).optional(),
+	hover: z$1.array(buttonEffectApplicationSchema).optional(),
+	active: z$1.array(buttonEffectApplicationSchema).optional(),
+	focus: z$1.array(buttonEffectApplicationSchema).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 buttonVariantSchema = z$1.strictObject({
+	id: buttonVariantIdSchema,
+	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()
+});
+const buttonSystemSchema = z$1.strictObject({
+	global: buttonGlobalSettingsSchema,
+	variants: z$1.array(buttonVariantSchema).min(1).max(6),
+	sizes: buttonSizesSchema.optional()
+}).superRefine((system, ctx) => {
+	const seen = /* @__PURE__ */ new Set();
+	system.variants.forEach((variant, index) => {
+		if (seen.has(variant.id)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"variants",
+				index,
+				"id"
+			],
+			message: `Duplicate button variant ID: ${variant.id}`
+		});
+		seen.add(variant.id);
+	});
+});
+//#endregion
+//#region ../theme-core/src/lib/media.ts
+const hotspotSchema$1 = z.object({
+	x: z.number().min(0).max(1),
+	y: z.number().min(0).max(1),
+	radius: z.number().optional()
+});
+const rotationSchema$1 = z.union([
+	z.literal(0),
+	z.literal(90),
+	z.literal(180),
+	z.literal(270)
+]);
+const rectSchema$1 = z.tuple([
+	z.number(),
+	z.number(),
+	z.number(),
+	z.number()
+]);
+const aspectCropSchema$1 = z.object({
+	aspect: z.preprocess((value) => value == null ? void 0 : value, z.string().optional()),
+	rect: z.preprocess((value) => value == null ? void 0 : value, rectSchema$1.optional()),
+	hotspot: z.preprocess((value) => value == null ? void 0 : value, hotspotSchema$1.optional()),
+	rotation: z.preprocess((value) => value == null ? void 0 : value, rotationSchema$1.optional())
+});
+const transformSchema$1 = z.object({
+	aspectCrops: z.preprocess((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		return value;
+	}, z.record(z.string(), aspectCropSchema$1.catch({}))).optional(),
+	rect: rectSchema$1.optional(),
+	hotspot: hotspotSchema$1.optional(),
+	rotation: rotationSchema$1.optional()
+});
+const mediaSchema$1 = z.object({
+	type: z.enum([
+		"image",
+		"video",
+		"audio",
+		"document",
+		"spreadsheet",
+		"archive"
+	]),
+	purpose: z.string().optional(),
+	placeholder: z.boolean().default(true).optional(),
+	assetId: z.string().optional(),
+	identifier: z.string().optional(),
+	src: z.string().optional(),
+	alt: z.string().optional(),
+	filename: z.string().optional(),
+	mimeType: z.string().optional(),
+	width: z.number().optional(),
+	height: z.number().optional(),
+	storageBucket: z.string().optional(),
+	storagePath: z.string().optional(),
+	transform: transformSchema$1.optional()
+});
+//#endregion
+//#region ../theme-core/src/cards/types.ts
+const cardVariantRoleValues = ["default", "alternative"];
+const boxlessCardVariantValue = "none";
+const legacyCardVariantRoleAliases = {
+	variant1: "alternative",
+	variant2: "alternative"
+};
+const cardSpacingSchema = z$1.enum([
+	"none",
+	"compact",
+	"cozy",
+	"medium",
+	"comfortable",
+	"spacious"
+]);
+const gradientDirectionSchema = z$1.enum([
+	"to-r",
 	"to-l",
 	"to-t",
 	"to-b",
@@ -1831,102 +2057,3772 @@ const gradientDirectionSchema = z$1.enum([
 	"to-bl"
 ]);
 const cardVariantRoleSchema = z$1.enum(cardVariantRoleValues);
-z$1.enum([...cardVariantRoleValues, boxlessCardVariantValue]);
+const boxStylesCardVariantSchema = z$1.enum([...cardVariantRoleValues, boxlessCardVariantValue]);
 function isCardVariantRole(value) {
 	return typeof value === "string" && cardVariantRoleValues.includes(value);
 }
-function normalizeCardVariantRole(value) {
-	if (isCardVariantRole(value)) return value;
-	if (typeof value !== "string") return null;
-	return legacyCardVariantRoleAliases[value] ?? null;
+function normalizeCardVariantRole(value) {
+	if (isCardVariantRole(value)) return value;
+	if (typeof value !== "string") return null;
+	return legacyCardVariantRoleAliases[value] ?? null;
+}
+const cardBackgroundSchema = z$1.discriminatedUnion("type", [
+	z$1.object({
+		type: z$1.literal("solid"),
+		colorToken: themeColorTokenSchema
+	}),
+	z$1.object({
+		type: z$1.literal("gradient"),
+		fromToken: themeColorTokenSchema,
+		toToken: themeColorTokenSchema,
+		direction: gradientDirectionSchema
+	}),
+	z$1.object({ type: z$1.literal("transparent") })
+]);
+const cardBorderSchema = z$1.object({
+	widthClass: z$1.string(),
+	colorToken: themeColorTokenSchema
+});
+/** Per-corner radius value. `expressive` is a large block-radius multiple. */
+const cardCornerValueSchema = z$1.enum([
+	"square",
+	"soft",
+	"rounded",
+	"pill",
+	"expressive"
+]);
+/**
+* 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.
+*/
+const cardAccentEdgeSchema = z$1.object({
+	edge: z$1.enum([
+		"left",
+		"top",
+		"right",
+		"bottom"
+	]),
+	colorToken: themeColorTokenSchema,
+	width: z$1.enum([
+		"thin",
+		"medium",
+		"thick",
+		"heavy"
+	])
+});
+const cardCornerRadiiSchema = z$1.object({
+	topLeft: cardCornerValueSchema.optional(),
+	topRight: cardCornerValueSchema.optional(),
+	bottomLeft: cardCornerValueSchema.optional(),
+	bottomRight: cardCornerValueSchema.optional()
+});
+const cardVariantSchema = z$1.object({
+	id: z$1.string(),
+	name: z$1.string().min(1).max(20),
+	enabled: z$1.boolean(),
+	priority: z$1.union([
+		z$1.literal(1),
+		z$1.literal(2),
+		z$1.literal(3)
+	]),
+	background: cardBackgroundSchema,
+	spacing: cardSpacingSchema,
+	foregroundToken: themeColorTokenSchema.optional(),
+	shadow: 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")
+	}).optional(),
+	corners: z$1.enum([
+		"square",
+		"soft",
+		"rounded",
+		"pill"
+	]).optional(),
+	cornerRadii: cardCornerRadiiSchema.optional(),
+	border: cardBorderSchema.optional(),
+	accentEdge: cardAccentEdgeSchema.optional()
+});
+const cardSystemSchema = z$1.object({ variants: z$1.array(cardVariantSchema).min(1).max(3) });
+//#endregion
+//#region ../theme-core/src/accordions/types.ts
+/**
+* Accordion icon styles for expand/collapse indicators
+*/
+const accordionIconSchema = z$1.enum([
+	"plus-minus",
+	"chevron",
+	"caret",
+	"arrow",
+	"circle-plus-minus"
+]);
+/**
+* Accordion configuration for a theme
+* Single style per theme (no variants needed)
+*/
+const accordionSystemSchema = z$1.object({
+	background: z$1.object({
+		type: z$1.literal("solid"),
+		colorToken: themeColorTokenSchema
+	}).nullable(),
+	spacing: z$1.enum([
+		"none",
+		"compact",
+		"cozy",
+		"medium",
+		"comfortable",
+		"spacious"
+	]),
+	corners: z$1.enum([
+		"square",
+		"soft",
+		"rounded",
+		"pill"
+	]).nullable(),
+	border: z$1.object({
+		widthClass: z$1.string(),
+		colorToken: themeColorTokenSchema
+	}).nullable(),
+	shadow: z$1.object({
+		elevation: z$1.enum([
+			"none",
+			"low",
+			"medium",
+			"high"
+		]),
+		softness: z$1.enum([
+			"soft",
+			"crisp",
+			"hard"
+		]).nullable(),
+		position: z$1.enum(["bottom", "bottom-right"])
+	}).nullable(),
+	icon: z$1.object({
+		style: accordionIconSchema,
+		position: z$1.enum(["left", "right"]),
+		size: z$1.enum([
+			"sm",
+			"md",
+			"lg"
+		]),
+		colorToken: themeColorTokenSchema.optional()
+	}),
+	trigger: z$1.object({
+		textColorToken: themeColorTokenSchema,
+		fontWeight: z$1.enum([
+			"regular",
+			"medium",
+			"semibold",
+			"bold"
+		]).nullable(),
+		fontFamily: z$1.enum(["body", "heading"]).optional(),
+		fontScale: z$1.enum([
+			"body",
+			"md",
+			"lg"
+		]).optional(),
+		letterSpacing: z$1.enum([
+			"normal",
+			"tight",
+			"wide"
+		]).optional(),
+		textTransform: z$1.enum(["none", "uppercase"]).optional()
+	}),
+	hover: z$1.object({
+		backgroundColorToken: themeColorTokenSchema.optional(),
+		textColorToken: themeColorTokenSchema.optional(),
+		borderColorToken: themeColorTokenSchema.optional()
+	}),
+	openState: z$1.object({
+		backgroundColorToken: themeColorTokenSchema.optional(),
+		triggerColorToken: themeColorTokenSchema.optional(),
+		accent: z$1.object({
+			edge: z$1.enum([
+				"left",
+				"top",
+				"bottom"
+			]),
+			colorToken: themeColorTokenSchema,
+			thickness: z$1.enum([
+				"thin",
+				"medium",
+				"thick"
+			])
+		}).optional()
+	}).optional(),
+	content: z$1.object({ textColorToken: themeColorTokenSchema })
+});
+//#endregion
+//#region ../theme-core/src/inputs/types.ts
+/**
+* Input styling configuration for a theme
+*
+* Provides comprehensive control over form input appearance including:
+* - Base styling (background, borders, spacing)
+* - Label styling
+* - Focus, error, and disabled states
+*
+* Single configuration per theme (no variants needed for inputs)
+*/
+const inputSystemSchema = z$1.object({
+	base: z$1.object({
+		background: z$1.union([z$1.object({
+			type: z$1.literal("solid"),
+			colorToken: themeColorTokenSchema
+		}), z$1.object({ type: z$1.literal("transparent") })]),
+		textColorToken: themeColorTokenSchema,
+		border: z$1.object({
+			widthClass: z$1.string(),
+			colorToken: themeColorTokenSchema,
+			style: z$1.enum(["all", "underline"]).optional()
+		}),
+		corners: z$1.enum([
+			"square",
+			"soft",
+			"rounded",
+			"pill"
+		]).nullable(),
+		shadow: z$1.object({
+			elevation: z$1.enum([
+				"none",
+				"low",
+				"medium"
+			]),
+			softness: z$1.enum([
+				"soft",
+				"crisp",
+				"hard"
+			]).nullable()
+		}).nullable(),
+		spacing: z$1.enum([
+			"compact",
+			"cozy",
+			"medium",
+			"comfortable"
+		]),
+		fontSize: z$1.enum([
+			"sm",
+			"base",
+			"lg"
+		])
+	}),
+	label: z$1.object({
+		textColorToken: themeColorTokenSchema,
+		fontWeight: z$1.enum([
+			"regular",
+			"medium",
+			"semibold",
+			"bold",
+			"black"
+		]),
+		fontSize: z$1.enum([
+			"2xs",
+			"xs",
+			"sm",
+			"base"
+		]),
+		textTransform: z$1.enum([
+			"none",
+			"uppercase",
+			"lowercase",
+			"capitalize"
+		]).optional(),
+		letterSpacing: z$1.enum([
+			"normal",
+			"wide",
+			"wider",
+			"widest"
+		]).optional(),
+		opacity: z$1.number().min(.2).max(1).optional()
+	}),
+	focus: z$1.object({
+		ringColorToken: themeColorTokenSchema,
+		ringWidth: z$1.enum([
+			"0",
+			"1",
+			"2",
+			"3"
+		]),
+		borderColorToken: themeColorTokenSchema.optional()
+	}),
+	error: z$1.object({
+		borderColorToken: themeColorTokenSchema,
+		textColorToken: themeColorTokenSchema
+	}),
+	disabled: z$1.object({
+		backgroundColorToken: themeColorTokenSchema,
+		textColorToken: themeColorTokenSchema,
+		opacity: z$1.number().min(.3).max(.7)
+	})
+});
+//#endregion
+//#region ../theme-core/src/gradients/types.ts
+/**
+* Gradient configuration types and schemas
+*/
+/**
+* Gradient color stop
+*/
+const gradientStopSchema = z$1.object({
+	color: themeColorTokenSchema,
+	position: z$1.number().min(0).max(100)
+});
+/**
+* Radial gradient shape. Optional; defaults to `circle` (the historical shape)
+* so existing radial gradients are byte-identical.
+*
+* Named `RadialGradientShape` to avoid clashing with `styles/gradients.ts`'s
+* `GradientShape` (which names the gradient *kind*: linear/radial/conic).
+*/
+const radialGradientShapeSchema = z$1.enum(["circle", "ellipse"]);
+/**
+* Gradient configuration.
+*
+* `type` is optional and defaults to `'linear'` so gradients persisted without a
+* type (or with an explicit `'linear'`) render exactly as before. `'radial'` and
+* `'conic'` are additive kinds:
+*   - linear: `angle` (degrees)
+*   - radial: optional `shape` (circle/ellipse) + `position`
+*   - conic:  optional `angle` (from-angle, degrees) + `position`
+*/
+const gradientConfigSchema = z$1.object({
+	type: z$1.enum([
+		"linear",
+		"radial",
+		"conic"
+	]).default("linear"),
+	angle: z$1.number().min(0).max(360).optional(),
+	shape: radialGradientShapeSchema.optional(),
+	position: z$1.string().optional(),
+	stops: z$1.array(gradientStopSchema).min(2)
+});
+//#endregion
+//#region ../theme-core/src/interactive/baseSchema.ts
+/**
+* Shared Base Schemas for Interactive Elements
+*
+* These Zod schemas are shared by buttons and nav links for DRY architecture.
+*/
+/**
+* Typography settings shared by buttons and nav links
+*/
+const interactiveTypographySchema = z$1.object({
+	/** Font family source */
+	typography: z$1.enum(["body", "heading"]).default("body"),
+	/** Font weight */
+	fontWeight: z$1.enum([
+		"regular",
+		"medium",
+		"semibold",
+		"bold"
+	]).default("medium"),
+	/** Text transform */
+	textTransform: z$1.enum([
+		"none",
+		"uppercase",
+		"capitalize"
+	]).default("none"),
+	/** Italic style */
+	italic: z$1.boolean().default(false)
+});
+/**
+* Effect application reference (shared between buttons and nav)
+*/
+const effectApplicationSchema = z$1.object({
+	/** Effect preset ID */
+	effectId: z$1.string(),
+	/** User-provided customization options */
+	options: z$1.record(z$1.string(), z$1.any()).optional()
+});
+/**
+* Effect composition by state (shared pattern)
+*/
+const effectCompositionSchema = z$1.object({
+	/** Effects always applied */
+	base: z$1.array(effectApplicationSchema).optional(),
+	/** Effects applied on hover */
+	hover: z$1.array(effectApplicationSchema).optional(),
+	/** Effects applied on active/pressed */
+	active: z$1.array(effectApplicationSchema).optional(),
+	/** Effects applied on focus */
+	focus: z$1.array(effectApplicationSchema).optional()
+});
+//#endregion
+//#region ../theme-core/src/navigation/types.ts
+/**
+* Navigation Link Style Types
+*
+* Schema and types for composable nav link styling used by header and footer.
+*/
+/**
+* Padding preset options for nav links
+*/
+const navLinkPaddingSchema = z$1.enum([
+	"none",
+	"compact",
+	"default"
+]);
+/**
+* Horizontal padding override for nav links.
+* When set, overrides only the horizontal component of the `padding` preset.
+*/
+const navLinkPaddingXSchema = z$1.enum([
+	"none",
+	"tight",
+	"compact",
+	"default",
+	"relaxed",
+	"spacious"
+]);
+/**
+* Border radius options for nav links
+*/
+const navLinkBorderRadiusSchema = z$1.enum([
+	"none",
+	"sm",
+	"md",
+	"full"
+]);
+/**
+* Typography size options for nav links.
+*/
+const navLinkTextSizeSchema = z$1.enum([
+	"xs",
+	"sm",
+	"base",
+	"lg",
+	"xl"
+]);
+/**
+* Letter spacing options for nav links.
+*/
+const navLinkLetterSpacingSchema = z$1.enum([
+	"normal",
+	"wide",
+	"wider",
+	"widest"
+]);
+/**
+* Optional legibility aid for nav text that floats over uncertain imagery or color.
+*/
+const navLinkContrastTreatmentSchema = z$1.enum(["none", "soft-glow"]);
+/**
+* Nav link style schema
+*
+* Extends interactive typography base with nav-specific settings.
+*/
+const navLinkStyleSchema = z$1.object({
+	/** Display name for the style */
+	name: z$1.string().min(1).max(30).optional(),
+	/** Typography settings (inherited from interactive base) */
+	...interactiveTypographySchema.shape,
+	/** Text color token */
+	colorToken: themeColorTokenSchema.default("text"),
+	/** Optional text size override */
+	textSize: navLinkTextSizeSchema.optional(),
+	/** Optional letter spacing override */
+	letterSpacing: navLinkLetterSpacingSchema.optional(),
+	/** Optional text-only contrast treatment for transparent/overlay navigation */
+	contrastTreatment: navLinkContrastTreatmentSchema.optional(),
+	/** Hover/active color token (for color-change effects) */
+	hoverColorToken: themeColorTokenSchema.nullable().optional(),
+	/** Padding preset */
+	padding: navLinkPaddingSchema.default("compact"),
+	/** Horizontal padding override (overrides horizontal component of padding preset) */
+	paddingX: navLinkPaddingXSchema.optional(),
+	/** Border radius (for capsule/pill styles) */
+	borderRadius: navLinkBorderRadiusSchema.default("none"),
+	/** Composable effects */
+	effects: effectCompositionSchema.optional()
+});
+//#endregion
+//#region ../theme-core/src/customCss/validation.ts
+/**
+* Custom CSS Validation Schemas
+*
+* Zod schemas for validating custom CSS rules.
+* Enforces security constraints by construction.
+*/
+/** Global selectors that could affect elements outside theme scope */
+const FORBIDDEN_SELECTORS = [
+	":root",
+	"html",
+	"body"
+];
+/** Universal selector - forbidden because it affects everything */
+const UNIVERSAL_SELECTOR = "*";
+/** Pattern to detect remote URL references (http://, https://, //) */
+const REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
+/** Pattern to detect javascript: URLs */
+const JAVASCRIPT_URL_PATTERN = /javascript\s*:/i;
+/**
+* Check if a single selector part (no commas) is forbidden.
+*/
+function isForbiddenSelectorPart(part) {
+	const normalized = part.toLowerCase().trim();
+	if (!normalized) return true;
+	if (normalized === UNIVERSAL_SELECTOR || normalized.startsWith("* ") || normalized.endsWith(" *") || normalized.includes(" * ")) return true;
+	for (const forbidden of FORBIDDEN_SELECTORS) {
+		if (normalized === forbidden) return true;
+		if (normalized.startsWith(forbidden + " ")) return true;
+		if (normalized.startsWith(forbidden + ">")) return true;
+		if (normalized.startsWith(forbidden + "+")) return true;
+		if (normalized.startsWith(forbidden + "~")) return true;
+		if (normalized.startsWith(forbidden + ".")) return true;
+		if (normalized.startsWith(forbidden + "#")) return true;
+		if (normalized.startsWith(forbidden + "[")) return true;
+		if (normalized.startsWith(forbidden + ":") && !normalized.startsWith(forbidden + "::")) return true;
+	}
+	return false;
+}
+/**
+* Check if a selector uses sibling combinators with & that could escape scope.
+* Patterns like "& ~ .outside" or "& + .sibling" can select elements outside the scope.
+*/
+function hasScopeEscapingSiblingCombinator(selector) {
+	const normalized = selector.trim();
+	return /&\s*[+~]/.test(normalized);
+}
+/**
+* Check if a selector contains forbidden global selectors.
+* Handles selectors like ":root", "html body", "body.class", "body, .x", etc.
+*/
+function containsForbiddenSelector(selector) {
+	const normalized = selector.toLowerCase().trim();
+	if (!normalized) return true;
+	if (hasScopeEscapingSiblingCombinator(selector)) return true;
+	const parts = normalized.split(",");
+	for (const part of parts) if (isForbiddenSelectorPart(part)) return true;
+	return false;
+}
+/**
+* Validates a CSS selector for safety.
+*/
+const selectorSchema = z$1.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine((s) => !containsForbiddenSelector(s), { message: "Global selectors (:root, html, body, *) are not allowed" });
+/**
+* Check if a CSS value contains a remote URL.
+*/
+function containsRemoteUrl(value) {
+	return REMOTE_URL_PATTERN.test(value);
+}
+/**
+* Check if a CSS value contains a javascript: URL.
+*/
+function containsJavascriptUrl(value) {
+	return JAVASCRIPT_URL_PATTERN.test(value);
+}
+/**
+* Validates a CSS declaration value for safety.
+* Allows: url(#id), url(data:...), url(/path), var(--)
+* Forbids: url(http...), url(//...), javascript:
+*/
+const declarationValueSchema = z$1.string().max(500, "Declaration value too long (max 500 characters)").refine((v) => !containsRemoteUrl(v), { message: "Remote url() references are not allowed. Use local paths, data URIs, or fragment IDs." }).refine((v) => !containsJavascriptUrl(v), { message: "javascript: URLs are not allowed" });
+/**
+* Schema for CSS declarations object (property -> value map).
+*/
+const declarationsSchema = z$1.record(z$1.string().min(1).max(100), declarationValueSchema);
+/**
+* Schema for a single custom CSS rule.
+*/
+const customCssRuleSchema = z$1.object({
+	id: z$1.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+	selector: selectorSchema,
+	declarations: declarationsSchema
+});
+/**
+* Schema for block-specific CSS rule.
+*/
+const blockCustomCssRuleSchema = customCssRuleSchema.extend({ blockKind: z$1.string().min(1, "Block kind is required").max(50, "Block kind too long") });
+/**
+* Array of custom CSS rules for theme-level styling.
+*/
+const customCssRulesSchema = z$1.array(customCssRuleSchema).optional();
+/**
+* Array of block-specific CSS rules.
+*/
+const blockCustomCssRulesSchema = z$1.array(blockCustomCssRuleSchema).optional();
+//#endregion
+//#region ../theme-core/src/customCss/atRuleValidation.ts
+/**
+* CSS At-Rule Validation Schemas
+*
+* Zod schemas for validating CSS at-rules.
+* Blocks @import for security.
+*/
+/** Valid keyframe offset values - requires % for numeric values */
+const KEYFRAME_OFFSET_PATTERN = /^(from|to|\d{1,3}%)$/i;
+/** Valid animation name (CSS identifier) */
+const ANIMATION_NAME_PATTERN = /^[a-zA-Z_-][a-zA-Z0-9_-]*$/;
+/** Blocked at-rules in raw CSS */
+const BLOCKED_AT_RULES = ["@import", "@charset"];
+/** Pattern to detect blocked at-rules */
+const BLOCKED_AT_RULE_PATTERN = /@(?:import|charset)\b/i;
+/** Rule ID schema - reused from main validation */
+const ruleIdSchema = z$1.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+/** Nested rule schema for @media and @supports */
+const nestedRuleSchema = z$1.object({
+	selector: selectorSchema,
+	declarations: declarationsSchema
+});
+/**
+* Validate keyframe offset is in valid range (0-100%).
+* Returns true for 'from', 'to', or numeric values 0-100.
+*/
+function isValidKeyframeOffset(offset) {
+	const trimmed = offset.trim().toLowerCase();
+	if (trimmed === "from" || trimmed === "to") return true;
+	const match = trimmed.match(/^(\d{1,3})%$/);
+	if (!match || match[1] === void 0) return false;
+	const value = parseInt(match[1], 10);
+	return value >= 0 && value <= 100;
+}
+/** Keyframe offset validation (0%, 50%, 100%, from, to) */
+const keyframeOffsetSchema = z$1.string().transform((offset) => offset.trim()).refine((offset) => KEYFRAME_OFFSET_PATTERN.test(offset), { message: "Invalid keyframe offset. Use percentages (0%, 50%, 100%) or \"from\"/\"to\"" }).refine(isValidKeyframeOffset, { message: "Keyframe offset must be between 0% and 100%" });
+/** Animation name validation (CSS identifier) */
+const animationNameSchema = z$1.string().min(1, "Animation name is required").max(50, "Animation name too long").refine((name) => ANIMATION_NAME_PATTERN.test(name), { message: "Invalid animation name. Use letters, numbers, dashes, underscores (start with letter, dash, or underscore)" });
+/** Single keyframe (offset + declarations) */
+const keyframeSchema = z$1.object({
+	offset: keyframeOffsetSchema,
+	declarations: declarationsSchema
+});
+/** @keyframes rule schema */
+const keyframesAtRuleSchema = z$1.object({
+	id: ruleIdSchema,
+	type: z$1.literal("keyframes"),
+	name: animationNameSchema,
+	frames: z$1.array(keyframeSchema).min(1, "At least one keyframe is required")
+});
+/** Font-face declarations - uses standard declarations but with font-specific validation */
+const fontFaceDeclarationsSchema = z$1.record(z$1.string().min(1).max(100), declarationValueSchema).refine((decls) => "fontFamily" in decls || "font-family" in decls, { message: "font-family is required in @font-face" });
+/** @font-face rule schema */
+const fontFaceAtRuleSchema = z$1.object({
+	id: ruleIdSchema,
+	type: z$1.literal("font-face"),
+	declarations: fontFaceDeclarationsSchema
+});
+/** Media query string validation */
+const mediaQuerySchema = z$1.string().min(1, "Media query is required").max(200, "Media query too long");
+/** @media rule schema */
+const mediaAtRuleSchema = z$1.object({
+	id: ruleIdSchema,
+	type: z$1.literal("media"),
+	query: mediaQuerySchema,
+	rules: z$1.array(nestedRuleSchema).min(1, "At least one rule is required")
+});
+/** Supports condition string validation */
+const supportsConditionSchema = z$1.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+/** @supports rule schema */
+const supportsAtRuleSchema = z$1.object({
+	id: ruleIdSchema,
+	type: z$1.literal("supports"),
+	condition: supportsConditionSchema,
+	rules: z$1.array(nestedRuleSchema).min(1, "At least one rule is required")
+});
+/**
+* Check if raw CSS contains blocked at-rules.
+*/
+function containsBlockedAtRule(css) {
+	return BLOCKED_AT_RULE_PATTERN.test(css);
+}
+/** Raw CSS validation - blocks @import, @charset, must start with @ */
+const rawCssSchema = z$1.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine((css) => css.trim().startsWith("@"), { message: "Raw at-rule must start with @" }).refine((css) => !containsBlockedAtRule(css), { message: `Blocked at-rules: ${BLOCKED_AT_RULES.join(", ")}. Use typed at-rules or local assets instead.` });
+/** Raw at-rule schema */
+const rawAtRuleSchema = z$1.object({
+	id: ruleIdSchema,
+	type: z$1.literal("raw"),
+	css: rawCssSchema
+});
+/**
+* Discriminated union schema for all at-rule types.
+*/
+const customCssAtRuleSchema = z$1.discriminatedUnion("type", [
+	keyframesAtRuleSchema,
+	fontFaceAtRuleSchema,
+	mediaAtRuleSchema,
+	supportsAtRuleSchema,
+	rawAtRuleSchema
+]);
+/**
+* Array of at-rules for theme-level styling.
+*/
+const customCssAtRulesSchema = z$1.array(customCssAtRuleSchema).optional();
+//#endregion
+//#region ../theme-core/src/shared/componentStyles.ts
+/**
+* Shared Component Style Schemas
+*
+* Reusable schemas for border and shadow styling that can be shared across
+* themed components (header, buttons, cards, accordions, inputs).
+*
+* Design decisions:
+* - Shadow elevation uses CSS-aligned names (none/sm/md/lg/xl/2xl)
+* - Shadow softness is controlled globally, not per-component
+* - Border position is component-specific, not in shared schema
+*/
+/**
+* Shared border schema for themed components.
+* Position is excluded - each component determines its own border position.
+*/
+const componentBorderSchema = z$1.object({
+	width: z$1.enum([
+		"none",
+		"hairline",
+		"thin",
+		"medium",
+		"thick"
+	]).default("none"),
+	style: z$1.enum(["solid", "dashed"]).default("solid"),
+	colorToken: themeColorTokenSchema.optional()
+});
+/**
+* Shared shadow schema for themed components.
+* Softness is inherited from global theme, not configurable per-component.
+*/
+const componentShadowSchema = z$1.object({ elevation: z$1.enum([
+	"none",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl"
+]).default("sm") });
+//#endregion
+//#region ../theme-core/src/site-styles/types.ts
+function asSiteStyleId(value) {
+	const siteStyleId = brandNonEmptyString(value, "SiteStyleId");
+	if (!siteStyleId.startsWith("site-style:")) throw new Error(`SiteStyleId must start with "site-style:". Received: ${value}`);
+	return siteStyleId;
+}
+function brandNonEmptyString(value, label) {
+	if (value.length === 0) throw new Error(`${label} must be a non-empty string.`);
+	return value;
+}
+const tileTreatmentValues = [
+	"default",
+	"quiet",
+	"brand-depth"
+];
+const eventListTreatmentValues = [
+	"plain",
+	"lined-panel",
+	"ruled-register",
+	"editorial-register",
+	"dense-index"
+];
+const eyebrowTreatmentValues = [
+	"plain",
+	"accent",
+	"pill",
+	"accent-pill",
+	"pill-bounce",
+	"accent-pill-bounce"
+];
+const visibleHeadingDecorationFamilyValues = ["organic-squiggle", "short-center-rule"];
+const headingDecorationOverrideValues = ["site-default", "off"];
+const headingDecorationColorTokenValues = [
+	"text",
+	"primary",
+	"secondary",
+	"accent",
+	"border",
+	"muted"
+];
+const accordionIconSetValues = [
+	"plus",
+	"chevron",
+	"caret",
+	"minimal-cross"
+];
+const accordionIconColorTokenValues = [
+	"text",
+	"muted",
+	"primary",
+	"secondary",
+	"accent",
+	"current"
+];
+const accordionIconMotionValues = [
+	"none",
+	"rotate",
+	"swap"
+];
+//#endregion
+//#region ../theme-core/src/site-styles/logoBranding.ts
+const logoTextConfidenceValues = [
+	"low",
+	"medium",
+	"high"
+];
+const logoAssetShapeValues = [
+	"none",
+	"horizontal",
+	"square",
+	"portrait",
+	"tall"
+];
+const logoKindValues = [
+	"mark",
+	"wordmark",
+	"lockup",
+	"badge",
+	"stacked-wordmark",
+	"unknown"
+];
+const logoDensityValues = [
+	"simple",
+	"detailed",
+	"unknown"
+];
+const logoContainsTextSchema = z$1.discriminatedUnion("kind", [
+	z$1.object({
+		kind: z$1.literal("contains-text"),
+		confidence: z$1.enum(logoTextConfidenceValues),
+		text: z$1.string().trim().min(1).max(200).optional()
+	}),
+	z$1.object({
+		kind: z$1.literal("no-text"),
+		confidence: z$1.enum(logoTextConfidenceValues)
+	}),
+	z$1.object({
+		kind: z$1.literal("unknown"),
+		reason: z$1.enum([
+			"analysis-unavailable",
+			"unsupported-file",
+			"low-confidence"
+		])
+	})
+]);
+const logoAnalysisSourceSchema = z$1.discriminatedUnion("kind", [
+	z$1.object({ kind: z$1.literal("none") }),
+	z$1.object({
+		kind: z$1.literal("deterministic"),
+		reason: z$1.enum(["dimensions", "fallback"])
+	}),
+	z$1.object({
+		kind: z$1.literal("llm"),
+		model: z$1.literal("gpt-5.4-mini"),
+		analyzedAt: z$1.string().trim().min(1).max(80).optional()
+	}),
+	z$1.object({ kind: z$1.literal("manual-override") })
+]);
+z$1.object({
+	shape: z$1.enum(logoAssetShapeValues),
+	containsText: logoContainsTextSchema,
+	kind: z$1.enum(logoKindValues),
+	density: z$1.enum(logoDensityValues),
+	source: logoAnalysisSourceSchema
+});
+const brandDisplayModeValues = [
+	"auto",
+	"logo-only",
+	"logo-plus-title",
+	"title-only"
+];
+const logoAccommodationPatternValues = [
+	"title-only",
+	"inline-logo-only",
+	"inline-wordmark",
+	"inline-mark-with-title",
+	"logo-plate",
+	"centered-badge",
+	"popout-badge",
+	"centered-masthead",
+	"hero-badge"
+];
+const logoSizePolicyValues = [
+	"auto",
+	"compact",
+	"standard",
+	"generous",
+	"display"
+];
+//#endregion
+//#region ../theme-core/src/site-styles/rawStyleFields.ts
+const themeV2RuntimeStyleFieldNames = [
+	"_frameStyles",
+	"_sectionStyles",
+	"_containerStyles",
+	"_cardStyles",
+	"_transitionStyles",
+	"styleGroup"
+];
+const themeV2BlockSpecificRawStyleFieldNames = [
+	"_contentCardStyles",
+	"_heroLayoutStyles",
+	"_textCardStyles"
+];
+const themeV2NormalEditorRawStyleFieldNames = [...themeV2RuntimeStyleFieldNames, ...themeV2BlockSpecificRawStyleFieldNames];
+new Set(themeV2NormalEditorRawStyleFieldNames);
+[...themeV2RuntimeStyleFieldNames, ...themeV2BlockSpecificRawStyleFieldNames];
+const pageDesignEditorBackgroundOverrideOwner = "page-design-editor";
+const siteChromeBackgroundOverrideOwner = "site-chrome-editor";
+//#endregion
+//#region ../theme-core/src/utils/tokenOrColor.ts
+/**
+* Runtime color-reference fields intentionally accept any string, including
+* the legacy empty-string "no color" sentinel. Semantic validation needs
+* palette context and happens in `parseThemeColorReference`.
+*/
+const tokenOrCssColorValueSchema = z$1.string();
+const CSS_COLOR_FUNCTION_PATTERN = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\(/i;
+const CSS_HEX_COLOR_PATTERN = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const CSS_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
+	"transparent",
+	"currentcolor",
+	"inherit",
+	"initial",
+	"revert",
+	"revert-layer",
+	"unset"
+]);
+const COMMON_CSS_NAMED_COLORS = /* @__PURE__ */ new Set([
+	"black",
+	"blue",
+	"gray",
+	"green",
+	"grey",
+	"orange",
+	"pink",
+	"purple",
+	"red",
+	"white",
+	"yellow"
+]);
+function isCssColorLiteral(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return false;
+	return CSS_HEX_COLOR_PATTERN.test(trimmed) || CSS_COLOR_FUNCTION_PATTERN.test(trimmed) || /^var\(/i.test(trimmed) || CSS_COLOR_KEYWORDS.has(trimmed.toLowerCase());
+}
+function parseThemeToken(token) {
+	const trimmed = token.trim();
+	const match = trimmed.match(/^(.*?)-(\d{2,3})$/);
+	if (!match) return {
+		role: trimmed,
+		shade: null
+	};
+	const role = match[1] ?? trimmed;
+	const shade = match[2] ? Number(match[2]) : null;
+	return {
+		role,
+		shade: Number.isFinite(shade) ? shade : null
+	};
+}
+function parseContextThemeColorToken(value, context) {
+	const parts = parseColorTokenParts(value);
+	if (parts.kind !== "token") return null;
+	if (!(Boolean(context?.palette?.[value.trim()]) || parts.opacityPercent !== null && Boolean(context?.palette?.[parts.token]))) return null;
+	return value.trim();
+}
+function isTokenShapedTypo(value) {
+	if (COMMON_CSS_NAMED_COLORS.has(value.toLowerCase())) return false;
+	if (!/^[a-zA-Z][a-zA-Z0-9]*(?:-[a-zA-Z0-9]+)*(?:\/[^/]+)?$/.test(value)) return false;
+	return !isCssColorLiteral(value);
+}
+function warnUnknownThemeColorReference(value) {
+	if (!isTokenShapedTypo(value)) return;
+	console.warn(`[theme-core] Unknown Theme V2 color token "${value}" treated as literal CSS. Use raw:* for deliberate custom CSS values.`);
+}
+function parseThemeColorReference(input, context) {
+	const trimmed = input.trim();
+	if (trimmed.startsWith("raw:")) return {
+		kind: "literal-css",
+		value: trimmed.slice(4)
+	};
+	const contextToken = parseContextThemeColorToken(trimmed, context);
+	if (contextToken) return {
+		kind: "palette-context-token",
+		token: contextToken
+	};
+	const knownToken = parseThemeColorToken(trimmed);
+	if (knownToken) return {
+		kind: "theme-token",
+		token: knownToken
+	};
+	warnUnknownThemeColorReference(trimmed);
+	return {
+		kind: "literal-css",
+		value: trimmed
+	};
+}
+function resolveThemeColorReferenceValue(input, context) {
+	const reference = parseThemeColorReference(input, context);
+	return reference.kind === "literal-css" ? reference.value : rgbColorValue(reference.token);
+}
+function resolveTokenOrCssColorValue(input, context) {
+	return resolveThemeColorReferenceValue(input, context);
+}
+function resolveOnColorForThemeToken(token) {
+	if (!parseThemeColorToken(token)) return null;
+	const parts = parseColorTokenParts(token);
+	if (parts.kind !== "token") return null;
+	const { role, shade } = parseThemeToken(parts.token);
+	const normalizedRole = role.trim();
+	if (!normalizedRole) return null;
+	if (!shade) return rgbColorValue(`on${normalizedRole.charAt(0).toUpperCase() + normalizedRole.slice(1)}`);
+	return shade <= 400 ? "#000000" : "#FFFFFF";
+}
+//#endregion
+//#region ../theme-core/src/schema.ts
+const axesSchema = z$1.object({
+	tone: z$1.enum([
+		"minimal",
+		"classic",
+		"bold"
+	]),
+	energy: z$1.enum(["calm", "vibrant"]),
+	density: z$1.enum([
+		"airy",
+		"regular",
+		"compact"
+	]),
+	mediaBias: z$1.enum([
+		"text",
+		"media",
+		"mixed"
+	]),
+	conversionBias: z$1.enum([
+		"low",
+		"med",
+		"high"
+	]),
+	motion: z$1.enum([
+		"subtle",
+		"standard",
+		"expressive"
+	])
+});
+const colourHexString = z$1.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+const paletteColorSchema = z$1.object({
+	name: z$1.string().min(1),
+	hex: colourHexString
+});
+const paletteMetaSchema = z$1.object({ mode: z$1.enum(["light", "dark"]) });
+const paletteSchema = z$1.object({
+	colors: z$1.array(paletteColorSchema),
+	meta: paletteMetaSchema
+});
+const typographyStyleSchema = z$1.object({
+	family: z$1.string().min(1),
+	weight: z$1.enum([
+		"light",
+		"regular",
+		"medium",
+		"semibold",
+		"bold"
+	]),
+	letterSpacing: z$1.enum([
+		"tight",
+		"normal",
+		"loose"
+	]),
+	lineHeight: z$1.enum([
+		"normal",
+		"relaxed",
+		"loose"
+	])
+});
+const bodyTypographyStyleSchema = typographyStyleSchema.extend({ size: z$1.enum([
+	"md",
+	"lg",
+	"xl"
+]) });
+const headingSizeSchema = z$1.enum([
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl"
+]);
+const headingTypographyOverridesSchema = z$1.object({
+	weight: z$1.enum([
+		"light",
+		"regular",
+		"medium",
+		"semibold",
+		"bold"
+	]).nullable().optional(),
+	letterSpacing: z$1.enum([
+		"tight",
+		"normal",
+		"loose"
+	]).nullable().optional(),
+	size: headingSizeSchema.nullable().optional(),
+	lineHeight: z$1.enum([
+		"tight",
+		"snug",
+		"normal",
+		"relaxed",
+		"loose"
+	]).nullable().optional(),
+	italic: z$1.boolean().nullable().optional(),
+	colorToken: themeColorTokenSchema.nullable().optional()
+});
+const headingTypographyStyleSchema = typographyStyleSchema.extend({
+	case: z$1.enum([
+		"uppercase",
+		"normal",
+		"smallCaps"
+	]).nullable(),
+	italic: z$1.boolean().nullable(),
+	colorToken: themeColorTokenSchema.nullable().optional()
+});
+const proseLinkUnderlineStyleSchema = z$1.enum([
+	"solid",
+	"dotted",
+	"dashed"
+]);
+const proseLinkUnderlineThicknessSchema = z$1.enum([
+	"auto",
+	"fromFont",
+	"thin",
+	"medium",
+	"thick"
+]);
+const proseLinkUnderlineOffsetSchema = z$1.enum([
+	"auto",
+	"tight",
+	"normal",
+	"loose"
+]);
+const proseLinkStyleSchema = z$1.object({
+	colorToken: themeColorTokenSchema.optional(),
+	hoverColorToken: themeColorTokenSchema.optional(),
+	underline: z$1.boolean().optional(),
+	decorationColorToken: themeColorTokenSchema.optional(),
+	hoverDecorationColorToken: themeColorTokenSchema.optional(),
+	underlineStyle: proseLinkUnderlineStyleSchema.optional(),
+	underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
+	underlineOffset: proseLinkUnderlineOffsetSchema.optional()
+});
+const semanticSpacingSchema = z$1.enum([
+	"none",
+	"compact",
+	"cozy",
+	"medium",
+	"comfortable",
+	"spacious"
+]);
+const boxRoundedSchema = z$1.enum([
+	"none",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"2xl",
+	"full"
+]);
+const boxBackgroundOverlaySchema = z$1.object({
+	type: z$1.enum([
+		"none",
+		"color",
+		"gradient"
+	]).nullable().optional(),
+	color: tokenOrCssColorValueSchema.nullable().optional(),
+	gradient: z$1.string().nullable().optional(),
+	opacity: z$1.number().min(0).max(1).nullable().optional()
+});
+const boxBackgroundSchema = z$1.object({
+	type: z$1.enum([
+		"color",
+		"gradient",
+		"image"
+	]).optional(),
+	contentOwner: z$1.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
+	color: tokenOrCssColorValueSchema.nullable().optional(),
+	gradient: z$1.string().nullable().optional(),
+	gradientPresetId: z$1.string().min(1).nullable().optional(),
+	image: mediaSchema$1.nullable().optional(),
+	objectFit: z$1.enum([
+		"fill",
+		"fit",
+		"original",
+		"custom"
+	]).nullable().optional(),
+	scale: z$1.string().nullable().optional(),
+	position: z$1.string().nullable().optional(),
+	opacity: z$1.number().min(0).max(1).nullable().optional(),
+	motion: z$1.enum(["static", "fixed-frame"]).nullable().optional(),
+	overlay: boxBackgroundOverlaySchema.nullable().optional(),
+	textColor: tokenOrCssColorValueSchema.nullable().optional(),
+	headingColor: tokenOrCssColorValueSchema.nullable().optional(),
+	linkColor: tokenOrCssColorValueSchema.nullable().optional(),
+	supportingColor: tokenOrCssColorValueSchema.nullable().optional()
+});
+const noHeadingDecorationSchema = z$1.object({ family: z$1.literal("none") });
+const visibleHeadingDecorationSchema = z$1.object({
+	family: z$1.enum(visibleHeadingDecorationFamilyValues),
+	colorToken: z$1.enum(headingDecorationColorTokenValues).optional()
+});
+const headingDecorationSchema = z$1.union([noHeadingDecorationSchema, visibleHeadingDecorationSchema]);
+const headingDecorationOverrideSchema = z$1.union([z$1.enum(headingDecorationOverrideValues), z$1.literal("on").transform(() => "site-default")]);
+const accordionIconTreatmentSchema = z$1.object({
+	iconSet: z$1.enum(accordionIconSetValues),
+	colorToken: z$1.enum(accordionIconColorTokenValues),
+	openColorToken: z$1.enum(accordionIconColorTokenValues).optional(),
+	motion: z$1.enum(accordionIconMotionValues)
+});
+const sectionStylesOverrideSchema = z$1.object({
+	background: boxBackgroundSchema.nullable().optional(),
+	spacing: semanticSpacingSchema.nullable().optional(),
+	minHeight: z$1.enum([
+		"none",
+		"banner",
+		"hero",
+		"immersive"
+	]).nullable().optional(),
+	tileTreatment: z$1.enum(tileTreatmentValues).nullable().optional(),
+	eventListTreatment: z$1.enum(eventListTreatmentValues).nullable().optional(),
+	eyebrowTreatment: z$1.enum(eyebrowTreatmentValues).nullable().optional(),
+	headingDecoration: headingDecorationSchema.nullable().optional(),
+	headingDecorationOverride: headingDecorationOverrideSchema.nullable().optional(),
+	accordionIconTreatment: accordionIconTreatmentSchema.nullable().optional()
+});
+const containerStylesOverrideSchema = z$1.object({
+	background: boxBackgroundSchema.nullable().optional(),
+	spacing: semanticSpacingSchema.nullable().optional(),
+	raised: z$1.boolean().nullable().optional(),
+	rounded: boxRoundedSchema.nullable().optional(),
+	fullWidth: z$1.boolean().nullable().optional()
+});
+const cardBorderOverrideSchema = z$1.object({
+	enabled: z$1.boolean().nullable().optional(),
+	width: z$1.enum([
+		"none",
+		"1",
+		"2",
+		"3"
+	]).nullable().optional(),
+	colorToken: themeColorTokenSchema.nullable().optional()
+});
+const cardStylesOverrideSchema = z$1.object({
+	background: boxBackgroundSchema.nullable().optional(),
+	border: cardBorderOverrideSchema.nullable().optional(),
+	spacing: semanticSpacingSchema.nullable().optional(),
+	raised: z$1.boolean().nullable().optional(),
+	rounded: boxRoundedSchema.nullable().optional(),
+	treatment: z$1.enum([
+		"accent-quote",
+		"editorial-rule",
+		"soft-panel",
+		"editorial-serif-quote",
+		"editorial-open",
+		"color-blocked"
+	]).nullable().optional(),
+	cardVariant: boxStylesCardVariantSchema.nullable().optional()
+});
+const blockStyleOverridesSchema = z$1.object({
+	sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
+	containerStyles: containerStylesOverrideSchema.nullable().optional(),
+	cardStyles: cardStylesOverrideSchema.nullable().optional()
+});
+const blockThemeOverrideSchema = z$1.object({
+	typography: z$1.object({ proseLinkStyle: proseLinkStyleSchema.optional() }).optional(),
+	styles: blockStyleOverridesSchema.optional()
+});
+const typographyScaleSchema = z$1.enum([
+	"compact",
+	"balanced",
+	"spacious",
+	"minorThird",
+	"majorThird",
+	"perfectFourth"
+]);
+const eyebrowTypographyStyleSchema = z$1.object({
+	family: z$1.string().min(1),
+	size: z$1.enum([
+		"sm",
+		"md",
+		"lg"
+	]).optional(),
+	weight: z$1.enum([
+		"light",
+		"regular",
+		"medium",
+		"semibold",
+		"bold"
+	]).optional(),
+	letterSpacing: z$1.enum([
+		"tight",
+		"normal",
+		"loose",
+		"wide"
+	]).optional(),
+	case: z$1.enum(["uppercase", "normal"]).optional()
+});
+const typographySchema = z$1.object({
+	body: bodyTypographyStyleSchema,
+	headings: z$1.object({
+		default: headingTypographyStyleSchema,
+		h1: headingTypographyOverridesSchema,
+		h2: headingTypographyOverridesSchema,
+		h3: headingTypographyOverridesSchema,
+		h4: headingTypographyOverridesSchema.optional(),
+		h5: headingTypographyOverridesSchema.optional(),
+		h6: headingTypographyOverridesSchema.optional()
+	}),
+	scale: typographyScaleSchema,
+	proseLinkStyle: proseLinkStyleSchema.optional(),
+	eyebrow: eyebrowTypographyStyleSchema.optional()
+});
+const spaceSchema = z$1.enum([
+	"comfortable",
+	"standard",
+	"dense"
+]);
+const corners = z$1.enum([
+	"square",
+	"soft",
+	"rounded",
+	"pill"
+]);
+const shadow = 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 border = z$1.object({
+	width: z$1.enum([
+		"none",
+		"hairline",
+		"thin",
+		"thick"
+	]),
+	style: z$1.enum(["solid", "dashed"])
+});
+const motion = z$1.object({
+	level: z$1.enum([
+		"off",
+		"low",
+		"medium",
+		"high"
+	]),
+	easing: z$1.enum([
+		"standard",
+		"snappy",
+		"gentle"
+	]).nullable()
+});
+z$1.object({ shape: corners });
+z$1.object({
+	elevation: z$1.enum([
+		"none",
+		"low",
+		"medium",
+		"high"
+	]),
+	border: z$1.enum([
+		"none",
+		"subtle",
+		"defined"
+	]),
+	shape: corners,
+	headerStyle: z$1.enum([
+		"plain",
+		"accentBar",
+		"subtleBg"
+	]).nullable(),
+	mediaTreatment: z$1.enum([
+		"square",
+		"rounded",
+		"bleed"
+	]).nullable()
+});
+const inputStyle = z$1.object({
+	shape: corners,
+	border: z$1.enum([
+		"subtle",
+		"defined",
+		"underline"
+	]),
+	focus: z$1.enum([
+		"glow",
+		"ring",
+		"underline"
+	]),
+	label: z$1.enum(["inside", "above"])
+});
+const headerVariant = z$1.enum([
+	"classic",
+	"centered",
+	"transparent",
+	"floating"
+]);
+const headerPositioning = z$1.enum([
+	"static",
+	"sticky",
+	"fixed"
+]);
+const headerNavStyle = z$1.enum([
+	"minimal",
+	"underline",
+	"underline-grow",
+	"capsule",
+	"scale",
+	"frosted",
+	"solid"
+]);
+const navFontWeight = z$1.enum([
+	"regular",
+	"medium",
+	"semibold",
+	"bold"
+]);
+const headerMaxWidth = z$1.enum(["container", "full"]);
+const headerBarFrame = z$1.enum(["full-bleed", "inset-shell"]);
+const headerContainerSchema = z$1.object({
+	rounded: z$1.enum([
+		"none",
+		"sm",
+		"md",
+		"lg",
+		"xl",
+		"2xl"
+	]).default("xl"),
+	border: z$1.boolean().default(true),
+	shadow: z$1.boolean().default(true),
+	padding: z$1.enum([
+		"sm",
+		"md",
+		"lg"
+	]).default("md"),
+	tint: z$1.string().nullable().optional(),
+	opacity: z$1.number().min(0).max(1).default(.12)
+}).optional();
+const headerBorderSchema = componentBorderSchema.extend({ position: z$1.enum([
+	"bottom",
+	"top",
+	"both",
+	"none"
+]).default("bottom") }).optional();
+const logoStyleSchema = z$1.object({
+	fontFamily: z$1.enum(["heading", "body"]).default("heading"),
+	letterSpacing: z$1.enum([
+		"normal",
+		"wide",
+		"wider",
+		"widest"
+	]).default("normal"),
+	gradient: z$1.boolean().default(false),
+	brandDisplay: z$1.enum(brandDisplayModeValues).optional(),
+	size: z$1.enum(logoSizePolicyValues).optional(),
+	accommodation: z$1.enum(logoAccommodationPatternValues).optional()
+}).optional();
+const headerLogoTextSchema = z$1.object({
+	mobileWrapLines: z$1.union([z$1.literal(1), z$1.literal(2)]).optional(),
+	mobileMaxWidth: z$1.enum([
+		"xs",
+		"sm",
+		"md"
+	]).optional(),
+	hideOnShrink: z$1.boolean().optional()
+}).optional();
+const navEffectsSchema = z$1.object({
+	underlineGradient: z$1.boolean().default(false),
+	glow: z$1.boolean().default(false),
+	glowColor: z$1.string().optional(),
+	neumorphic: z$1.boolean().default(false)
+}).optional();
+const dropdownStyleSchema = z$1.object({
+	background: themeColorTokenSchema.default("surface"),
+	textColor: themeColorTokenSchema.default("text"),
+	borderColor: themeColorTokenSchema.nullable().default("border"),
+	shadow: z$1.enum([
+		"none",
+		"sm",
+		"md",
+		"lg"
+	]).default("md"),
+	borderRadius: z$1.enum([
+		"none",
+		"sm",
+		"md",
+		"lg"
+	]).default("md"),
+	hoverBackground: themeColorTokenSchema.nullable().optional(),
+	hoverTextColor: themeColorTokenSchema.nullable().optional(),
+	textTransform: z$1.enum([
+		"none",
+		"uppercase",
+		"capitalize"
+	]).default("none"),
+	letterSpacing: z$1.enum([
+		"normal",
+		"wide",
+		"wider"
+	]).default("normal"),
+	fontWeight: z$1.enum([
+		"regular",
+		"medium",
+		"semibold",
+		"bold"
+	]).optional(),
+	textSize: z$1.enum([
+		"xs",
+		"sm",
+		"base",
+		"lg"
+	]).optional()
+}).optional();
+/**
+* CTA button gap (left margin) for desktop header.
+* Controls the spacing between nav links and the CTA button.
+*/
+const headerCtaGapSchema = z$1.enum([
+	"none",
+	"tight",
+	"compact",
+	"default",
+	"relaxed",
+	"spacious"
+]);
+const headerCtaTreatmentSchema = z$1.enum([
+	"default",
+	"primary",
+	"secondary",
+	"inverted",
+	"outline",
+	"ghost"
+]);
+const navContainerSchema = z$1.object({
+	type: z$1.enum([
+		"none",
+		"pill",
+		"glass"
+	]).default("none"),
+	tint: z$1.string().nullable().optional(),
+	opacity: z$1.number().min(0).max(1).default(.15)
+}).default({
+	type: "none",
+	tint: null,
+	opacity: .15
+});
+const headerBackgroundSchema = z$1.object({
+	type: z$1.enum([
+		"color",
+		"gradient",
+		"image"
+	]),
+	contentOwner: z$1.literal(siteChromeBackgroundOverrideOwner).optional(),
+	color: tokenOrCssColorValueSchema.nullable().optional(),
+	gradient: gradientConfigSchema.nullable().optional(),
+	image: mediaSchema$1.nullable().optional(),
+	textColor: tokenOrCssColorValueSchema.nullable().optional()
+});
+const headerSchema = z$1.object({
+	variant: headerVariant,
+	positioning: headerPositioning,
+	shrinkOnScroll: z$1.boolean(),
+	maxWidth: headerMaxWidth,
+	barFrame: headerBarFrame.optional(),
+	logoOverride: mediaSchema$1.nullable().optional(),
+	background: headerBackgroundSchema.default({
+		type: "color",
+		color: "surface"
+	}),
+	textColor: themeColorTokenSchema.nullable().optional(),
+	navStyle: headerNavStyle,
+	navColor: themeColorTokenSchema.nullable().optional(),
+	navWeight: navFontWeight.default("medium"),
+	navFontRole: z$1.enum(["body", "heading"]).optional(),
+	navTypography: z$1.enum(["body", "heading"]).optional(),
+	navTextSize: navLinkStyleSchema.shape.textSize,
+	navPlacement: z$1.enum(["end", "center"]).optional(),
+	container: headerContainerSchema,
+	border: headerBorderSchema,
+	shadow: componentShadowSchema.optional(),
+	logo: logoStyleSchema,
+	logoText: headerLogoTextSchema,
+	navEffects: navEffectsSchema,
+	navContainer: navContainerSchema,
+	navLinkStyle: navLinkStyleSchema.optional(),
+	ctaGap: headerCtaGapSchema.optional(),
+	ctaTreatment: headerCtaTreatmentSchema.optional(),
+	ctaVariant: z$1.string().min(1).optional(),
+	dropdownStyle: dropdownStyleSchema
+}).transform(normaliseHeaderNavFontRole);
+/**
+* Normalises the legacy `navTypography` font-role alias into the canonical
+* `navFontRole` field so persisted themes migrate at the parse boundary without
+* a data migration. `navFontRole` always wins when both are present; the legacy
+* field is dropped so we never carry a dual write forward.
+*/
+function normaliseHeaderNavFontRole(header) {
+	if (header.navTypography === void 0) return header;
+	const { navTypography, ...rest } = header;
+	return header.navFontRole === void 0 ? {
+		...rest,
+		navFontRole: navTypography
+	} : rest;
+}
+const footerVariant = z$1.enum([
+	"simple",
+	"columns",
+	"split"
+]);
+const footerMaxWidth = z$1.enum(["container", "full"]);
+const footerMode = z$1.enum([
+	"default",
+	"blocks",
+	"default+blocks",
+	"none"
+]);
+const footerNavLayoutMode = z$1.enum([
+	"stack",
+	"inline",
+	"inline-wrap"
+]);
+const footerNavLayoutAlign = z$1.enum([
+	"start",
+	"center",
+	"end",
+	"space-between"
+]);
+const footerSpacing = z$1.enum([
+	"none",
+	"tight",
+	"compact",
+	"default",
+	"relaxed",
+	"spacious"
+]);
+const footerLogoPlacement = z$1.enum([
+	"left",
+	"right",
+	"above",
+	"below"
+]);
+const footerLogoSize = z$1.enum([
+	"sm",
+	"md",
+	"lg",
+	"xl"
+]);
+const footerLogoMaxHeight = z$1.enum([
+	"sm",
+	"md",
+	"lg",
+	"xl"
+]);
+const footerBottomTextLinkStyleSchema = z$1.object({
+	colorToken: themeColorTokenSchema.optional(),
+	hoverColorToken: themeColorTokenSchema.nullable().optional(),
+	decorationColorToken: themeColorTokenSchema.nullable().optional(),
+	underline: z$1.boolean().optional()
+});
+const footerBottomBarSchema = z$1.object({
+	enabled: z$1.boolean().optional(),
+	fullBleed: z$1.boolean().optional(),
+	background: headerBackgroundSchema.optional(),
+	textColor: themeColorTokenSchema.nullable().optional(),
+	textAlign: z$1.enum([
+		"left",
+		"center",
+		"right"
+	]).optional(),
+	paddingY: footerSpacing.optional(),
+	paddingX: footerSpacing.optional(),
+	borderTop: z$1.object({
+		colorToken: themeColorTokenSchema.nullable().optional(),
+		width: z$1.enum([
+			"none",
+			"thin",
+			"medium",
+			"thick"
+		]).optional()
+	}).optional()
+});
+const footerNavLayoutSchema = z$1.object({
+	layout: footerNavLayoutMode.optional(),
+	align: footerNavLayoutAlign.optional(),
+	gapX: footerSpacing.optional(),
+	gapY: footerSpacing.optional(),
+	columns: z$1.number().int().min(1).max(6).optional()
+});
+const footerLogoSchema = z$1.object({
+	showLogo: z$1.boolean().default(true),
+	showLogoText: z$1.boolean().optional(),
+	placement: footerLogoPlacement.optional(),
+	size: footerLogoSize.optional(),
+	maxHeight: footerLogoMaxHeight.optional(),
+	align: z$1.enum([
+		"start",
+		"center",
+		"end"
+	]).optional()
+});
+const footerSchema = z$1.object({
+	/**
+	* SDK-only footer rendering mode.
+	*
+	* Backwards compatible: missing/undefined behaves as 'default'.
+	*/
+	mode: footerMode.optional(),
+	variant: footerVariant,
+	maxWidth: footerMaxWidth,
+	showLogoText: z$1.boolean().optional(),
+	background: headerBackgroundSchema.default({
+		type: "color",
+		color: "surface"
+	}),
+	navStyle: headerNavStyle.default("minimal"),
+	navColor: themeColorTokenSchema.nullable().optional(),
+	navWeight: navFontWeight.default("medium"),
+	navLinkStyle: navLinkStyleSchema.optional(),
+	bottomTextLinkStyle: footerBottomTextLinkStyleSchema.optional(),
+	navLayout: footerNavLayoutSchema.optional(),
+	logo: footerLogoSchema.optional(),
+	bottomBar: footerBottomBarSchema.optional()
+});
+const containerPaddingPresetSchema = z$1.enum([
+	"tight",
+	"compact",
+	"default",
+	"relaxed"
+]);
+const layoutSchema = z$1.object({ containerPadding: z$1.object({
+	mobile: containerPaddingPresetSchema.optional(),
+	tablet: containerPaddingPresetSchema.optional(),
+	desktop: containerPaddingPresetSchema.optional()
+}).optional() }).optional();
+const heroTypographySizeSchema = z$1.enum([
+	"sm",
+	"base",
+	"lg",
+	"xl",
+	"2xl",
+	"3xl",
+	"4xl",
+	"5xl",
+	"6xl",
+	"editorial"
+]);
+const heroTypographyLineHeightSchema = z$1.enum([
+	"tight",
+	"snug",
+	"normal",
+	"relaxed"
+]);
+const heroResponsiveTypographySchema = z$1.object({
+	headlineSize: heroTypographySizeSchema.optional(),
+	headlineLineHeight: heroTypographyLineHeightSchema.optional(),
+	subheadlineSize: heroTypographySizeSchema.optional(),
+	subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
+});
+const heroTypographySchema = z$1.object({
+	headlineSize: heroTypographySizeSchema.optional(),
+	headlineLineHeight: heroTypographyLineHeightSchema.optional(),
+	subheadlineSize: heroTypographySizeSchema.optional(),
+	subheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+	microHeadlineSize: heroTypographySizeSchema.optional(),
+	microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+	microSubheadlineSize: heroTypographySizeSchema.optional(),
+	microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+	responsive: z$1.object({
+		tablet: heroResponsiveTypographySchema.optional(),
+		mobile: heroResponsiveTypographySchema.optional()
+	}).optional()
+});
+const heroSchema = z$1.object({ typography: heroTypographySchema.optional() }).optional();
+const bodyTextIntroTypographySizeSchema = z$1.enum(["default", "editorial"]);
+const bodyTextSchema = z$1.object({ intro: z$1.object({
+	paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
+	headingSize: bodyTextIntroTypographySizeSchema.optional()
+}).optional() }).optional();
+const gradientsSchema = z$1.object({
+	button: z$1.string().min(1).nullable().optional(),
+	hero: z$1.string().min(1).nullable().optional(),
+	background: z$1.string().min(1).nullable().optional()
+});
+/**
+* Testimonial quote-mark treatment, owned by the site style (analogous to the
+* accordion icon). `style` is the coarse selector; the optional fields fine-tune
+* it. `none` hides the mark. The block renders the mark; the site style decides
+* its character; a look may still hide it.
+*/
+const testimonialQuoteTreatmentSchema = z$1.object({
+	style: z$1.enum([
+		"serif-display",
+		"accent-glyph",
+		"none"
+	]),
+	fontFamily: z$1.enum(["heading", "body"]).optional(),
+	scale: z$1.enum([
+		"sm",
+		"md",
+		"lg",
+		"xl"
+	]).optional(),
+	colorToken: themeColorTokenSchema.optional(),
+	opacity: z$1.number().min(0).max(1).optional()
+});
+const themeSchema = z$1.object({
+	name: z$1.string().min(1).max(30),
+	description: z$1.string().min(1).max(400),
+	rationale: z$1.string().min(1).max(400),
+	siteStyleId: z$1.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+	axes: axesSchema,
+	palette: paletteSchema,
+	typography: typographySchema,
+	space: spaceSchema,
+	border,
+	shadow,
+	motion,
+	corners,
+	gradients: gradientsSchema.optional(),
+	layout: layoutSchema,
+	hero: heroSchema,
+	bodyText: bodyTextSchema,
+	header: headerSchema,
+	footer: footerSchema,
+	buttons: buttonSystemSchema.optional(),
+	cards: cardSystemSchema.optional(),
+	accordions: accordionSystemSchema.optional(),
+	testimonialQuote: testimonialQuoteTreatmentSchema.optional(),
+	inputs: inputSystemSchema.optional(),
+	inputStyle: inputStyle.optional(),
+	blockCustomVars: z$1.record(z$1.string(), z$1.record(z$1.string(), z$1.string())).optional(),
+	blockOverrides: z$1.record(z$1.string(), blockThemeOverrideSchema).optional(),
+	headingDecoration: headingDecorationSchema.optional(),
+	customCssRules: customCssRulesSchema,
+	blockCustomCssRules: blockCustomCssRulesSchema,
+	customCssAtRules: customCssAtRulesSchema,
+	/**
+	* Style groups define named visual presets that content authors can apply to blocks.
+	*
+	* Unlike variants (which change block structure/layout), style groups only affect
+	* CSS styling. The selected style group is rendered as a `data-style-group` attribute
+	* on the block wrapper, which can be targeted in `blockCustomCssRules`.
+	*
+	* @example
+	* ```typescript
+	* {
+	*   styleGroups: {
+	*     hero: ['bold', 'minimal', 'featured'],
+	*     'body-text': ['intro', 'compact'],
+	*   },
+	*   blockCustomCssRules: [
+	*     {
+	*       id: 'hero-bold-headline',
+	*       blockKind: 'hero',
+	*       selector: '&[data-style-group="bold"] .hero-headline',
+	*       declarations: { fontWeight: '800', fontSize: '3rem' }
+	*     }
+	*   ]
+	* }
+	* ```
+	*/
+	styleGroups: z$1.record(z$1.string(), z$1.array(z$1.string())).optional()
+});
+z$1.object({
+	message: z$1.string().min(1),
+	themes: z$1.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];
+	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(" ");
+}
+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,
+			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: unsafeAsOpaqueButtonColourToken("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,
+			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" }],
+						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: unsafeAsOpaqueButtonColourToken("surface") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+			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" }, {
+							effectId: "background-on-hover",
+							options: { colorToken: unsafeAsOpaqueButtonColourToken("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: unsafeAsOpaqueButtonColourToken("muted") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+			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: unsafeAsOpaqueButtonColourToken("background") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+			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,
+							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,
+							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,
+							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,
+						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,
+			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: unsafeAsOpaqueButtonColourToken("accent") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+			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: unsafeAsOpaqueButtonColourToken("surface") }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+			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: unsafeAsOpaqueButtonColourToken("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: unsafeAsOpaqueButtonColourToken("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,
+							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,
+			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" }, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("secondary") }
+					}] }
+				}
+			},
+			secondary: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					effects: { hover: [{ effectId: "lift" }, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					border: { widthClass: "border" },
+					effects: { hover: [{ effectId: "lift" }, {
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-lg",
+					effects: { hover: [{ effectId: "lift" }] }
+				}
+			},
+			accent: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "solid",
+						colorToken: "accent"
+					},
+					borderRadius: "rounded-lg",
+					affordance: { iconId: "ArrowRight" },
+					effects: { hover: [{ effectId: "lift" }] }
+				}
+			}
+		}
+	}
+});
+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,
+			hoverTransform: "lift",
+			hoverColor: "none",
+			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: unsafeAsOpaqueButtonColourToken("background") }
+					}] }
+				}
+			},
+			ghost: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-full",
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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",
+			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: unsafeAsOpaqueButtonColourToken("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: unsafeAsOpaqueButtonColourToken("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,
+			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: unsafeAsOpaqueButtonColourToken("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: unsafeAsOpaqueButtonColourToken("surface") }
+					}] }
+				}
+			},
+			outline: {
+				kind: "complete",
+				appearance: {
+					background: {
+						type: "surface",
+						role: "link"
+					},
+					borderRadius: "rounded-md",
+					border: { widthClass: "border" },
+					effects: { hover: [{
+						effectId: "background-on-hover",
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("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,
+							origin: "left"
+						}
+					}] }
+				}
+			},
+			accent: {
+				kind: "derive",
+				from: "primary",
+				overrides: { background: {
+					type: "solid",
+					colorToken: "accent"
+				} }
+			}
+		}
+	}
+});
+//#endregion
+//#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/buttonRoles.ts
+/**
+* Semantic button roles available to block authors.
+*
+* These roles are deliberately independent of a site's visual button style:
+* the active theme owns how each role looks.
+*/
+const BLOCK_BUTTON_ROLES = PUBLIC_BUTTON_ROLES;
+const blockButtonRoleSchema = z$1.enum(BLOCK_BUTTON_ROLES);
+/**
+* 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 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 = blockButtonRoleSchema;
+const eventButtonVariantSchema = persistedBlockButtonRoleSchema;
+const eventLayoutSchema = z$1.enum(eventCalendarListLayoutValues);
+const eventCalendarDisplayModeSchema = z$1.enum(eventCalendarDisplayModeValues);
+const eventCalendarDefaultViewSchema = z$1.enum(eventCalendarDefaultViewValues);
+const columnOptionSchema = z$1.enum([
+	"2",
+	"3",
+	"4"
+]);
+const weekStartSchema = z$1.enum(["sunday", "monday"]);
+const filterAutoShowSchema = z$1.enum([
+	"auto",
+	"always",
+	"never"
+]);
+const calendarTabViewsSchema = z$1.enum([
+	"both",
+	"month",
+	"week"
+]);
+const unsupportedEventRegistrationPageSurfaceSubjectSchema = z$1.object({
+	kind: z$1.literal("unsupported"),
+	reason: z$1.enum([
+		"unsupportedSubject",
+		"invalidEventSeriesId",
+		"invalidEventOfferingId"
+	])
+});
+const eventRegistrationPageSurfaceSubjectSchema = z$1.unknown().transform((value, ctx) => {
+	const unsupported = unsupportedEventRegistrationPageSurfaceSubjectSchema.safeParse(value);
+	if (unsupported.success) return unsupported.data;
+	const parsed = parseEventPageSurfaceSubject(value);
+	if (parsed.ok) return parsed.value;
+	ctx.addIssue({
+		code: z$1.ZodIssueCode.custom,
+		message: `Invalid event page-surface subject (${parsed.error.kind})`
+	});
+	return z$1.NEVER;
+});
+function resolveEventRegistrationScope(context) {
+	const occurrenceSeriesId = context.occurrenceContext?.seriesId;
+	if (occurrenceSeriesId) return {
+		kind: "occurrenceSeries",
+		seriesId: occurrenceSeriesId
+	};
+	if (context.subject?.kind === "eventSeries") return {
+		kind: "pageSurfaceSeries",
+		seriesId: context.subject.eventSeriesId
+	};
+	if (context.subject?.kind === "eventOffering") return {
+		kind: "pageSurfaceOffering",
+		offeringId: context.subject.eventOfferingId,
+		seriesIds: context.subject.availableEventSeriesIds
+	};
+	if (context.subject?.kind === "unsupported") return {
+		kind: "unsupportedPageSurfaceSubject",
+		reason: context.subject.reason
+	};
+	const entrySlug = context.contentEntry?.slug;
+	const entryContentType = context.contentEntry?.contentTypeSlug;
+	if (entrySlug && entryContentType && isEventContentType(entryContentType)) return {
+		kind: "legacyEventSlug",
+		slug: entrySlug
+	};
+	return { kind: "unscoped" };
+}
+function applyEventRegistrationScope(events, scope) {
+	switch (scope.kind) {
+		case "occurrenceSeries":
+		case "pageSurfaceSeries": return events.filter((event) => event.seriesId === scope.seriesId);
+		case "pageSurfaceOffering": {
+			const seriesIds = new Set(scope.seriesIds);
+			return events.filter((event) => seriesIds.has(event.seriesId));
+		}
+		case "legacyEventSlug": return events.filter((event) => event.slug === scope.slug);
+		case "unsupportedPageSurfaceSubject": return [];
+		case "unscoped": return [...events];
+	}
+}
+function resolveEventRegistrationScopedEvents(events, context) {
+	return applyEventRegistrationScope(events, resolveEventRegistrationScope(context));
 }
-const cardBackgroundSchema = z$1.discriminatedUnion("type", [
-	z$1.object({
-		type: z$1.literal("solid"),
-		colorToken: themeColorTokenSchema
-	}),
-	z$1.object({
-		type: z$1.literal("gradient"),
-		fromToken: themeColorTokenSchema,
-		toToken: themeColorTokenSchema,
-		direction: gradientDirectionSchema
-	}),
-	z$1.object({ type: z$1.literal("transparent") })
-]);
-const cardBorderSchema = z$1.object({
-	widthClass: z$1.string(),
-	colorToken: themeColorTokenSchema
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
+const contentEntrySchema$2 = z$1.object({
+	id: z$1.string(),
+	slug: z$1.string(),
+	contentTypeSlug: z$1.string()
 });
-/** Per-corner radius value. `expressive` is a large block-radius multiple. */
-const cardCornerValueSchema = z$1.enum([
-	"square",
-	"soft",
-	"rounded",
-	"pill",
-	"expressive"
-]);
-/**
-* 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.
-*/
-const cardAccentEdgeSchema = z$1.object({
-	edge: z$1.enum([
-		"left",
-		"top",
-		"right",
-		"bottom"
-	]),
-	colorToken: themeColorTokenSchema,
-	width: z$1.enum([
-		"thin",
-		"medium",
-		"thick",
-		"heavy"
-	])
+const courseEntrySubrouteContextSchema = z$1.union([z$1.object({
+	kind: z$1.literal("course-run"),
+	run: z$1.object({
+		courseId: z$1.string(),
+		seriesId: z$1.string(),
+		runSlug: z$1.string(),
+		runName: z$1.string().nullable()
+	})
+}), z$1.object({
+	kind: z$1.literal("event-occurrence"),
+	occurrence: occurrenceContextSchema$1
+})]);
+const courseRegistrationSourceSchema = z$1.object({
+	siteId: z$1.string().optional(),
+	apiBaseUrl: z$1.string().optional(),
+	portalToken: z$1.string().nullable().optional(),
+	contentEntry: contentEntrySchema$2.nullable().optional(),
+	entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
+	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
+	courses: z$1.array(publicCourseSchema).nullable().optional(),
+	className: z$1.string().nullable().optional(),
+	showSessions: z$1.boolean().optional(),
+	showPrice: z$1.boolean().optional(),
+	showCapacity: z$1.boolean().optional(),
+	showVenue: z$1.boolean().optional(),
+	successMessage: z$1.string().optional(),
+	waitlistMessage: z$1.string().optional(),
+	membershipMessage: z$1.string().optional(),
+	buttonText: z$1.string().nullable().optional(),
+	buttonVariant: registrationButtonVariantSchema.optional(),
+	stage: previewStageSchema.optional()
 });
-const cardCornerRadiiSchema = z$1.object({
-	topLeft: cardCornerValueSchema.optional(),
-	topRight: cardCornerValueSchema.optional(),
-	bottomLeft: cardCornerValueSchema.optional(),
-	bottomRight: cardCornerValueSchema.optional()
+const courseRegistrationDisplaySchema = z$1.object({
+	kind: z$1.literal("course-registration"),
+	state: z$1.literal("shell"),
+	className: z$1.string().nullable(),
+	summaryButtonText: z$1.string()
 });
-const cardVariantSchema = z$1.object({
-	id: z$1.string(),
-	name: z$1.string().min(1).max(20),
-	enabled: z$1.boolean(),
-	priority: z$1.union([
-		z$1.literal(1),
-		z$1.literal(2),
-		z$1.literal(3)
-	]),
-	background: cardBackgroundSchema,
-	spacing: cardSpacingSchema,
-	foregroundToken: themeColorTokenSchema.optional(),
-	shadow: 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")
-	}).optional(),
-	corners: z$1.enum([
-		"square",
-		"soft",
-		"rounded",
-		"pill"
-	]).optional(),
-	cornerRadii: cardCornerRadiiSchema.optional(),
-	border: cardBorderSchema.optional(),
-	accentEdge: cardAccentEdgeSchema.optional()
+const courseRegistrationHydrationSchema = z$1.object({
+	contentEntry: contentEntrySchema$2.nullable().optional(),
+	entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
+	subject: eventRegistrationPageSurfaceSubjectSchema.nullable().optional(),
+	courses: z$1.array(publicCourseSchema).nullable().optional(),
+	showSessions: z$1.boolean().optional(),
+	showPrice: z$1.boolean().optional(),
+	showCapacity: z$1.boolean().optional(),
+	showVenue: z$1.boolean().optional(),
+	successMessage: z$1.string().optional(),
+	waitlistMessage: z$1.string().optional(),
+	membershipMessage: z$1.string().optional(),
+	buttonVariant: registrationButtonVariantSchema.optional()
+});
+const courseRegistrationRenderSchema = z$1.object({
+	display: courseRegistrationDisplaySchema,
+	hydration: courseRegistrationHydrationSchema
+});
+const courseRegistrationIslandMetaCodec = createZodCodec(z$1.object({
+	siteId: z$1.string().optional(),
+	apiBaseUrl: z$1.string().optional(),
+	portalToken: z$1.string().nullable().optional(),
+	stage: previewStageSchema.optional()
+}));
+const courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "portalToken", "stage");
+function buildCourseRegistrationDisplay(source) {
+	return {
+		kind: "course-registration",
+		state: "shell",
+		className: source.className ?? null,
+		summaryButtonText: source.buttonText?.trim() || "Sign up"
+	};
+}
+const courseRegistrationInteractiveIslandPropsCodec = createInteractiveIslandCodec({
+	runtime: defineClientOwnedBlockRuntime({
+		kind: "client-owned",
+		contracts: {
+			source: createZodCodec(courseRegistrationSourceSchema),
+			render: createZodCodec(courseRegistrationRenderSchema)
+		},
+		buildRender: (source) => ({
+			display: buildCourseRegistrationDisplay(source),
+			hydration: {
+				contentEntry: source.contentEntry ?? null,
+				entrySubrouteContext: source.entrySubrouteContext ?? null,
+				subject: source.subject ?? null,
+				courses: source.courses ?? null,
+				showSessions: source.showSessions,
+				showPrice: source.showPrice,
+				showCapacity: source.showCapacity,
+				showVenue: source.showVenue,
+				successMessage: source.successMessage,
+				waitlistMessage: source.waitlistMessage,
+				membershipMessage: source.membershipMessage,
+				buttonVariant: source.buttonVariant
+			}
+		})
+	}),
+	mode: "course-registration",
+	meta: courseRegistrationIslandMetaCodec,
+	metaKeys: courseRegistrationIslandMetaKeys,
+	selectMeta: (value) => ({
+		siteId: value.siteId,
+		apiBaseUrl: value.apiBaseUrl,
+		portalToken: value.portalToken,
+		stage: value.stage
+	})
 });
-z$1.object({ variants: z$1.array(cardVariantSchema).min(1).max(3) });
 //#endregion
 //#region ../blocks/src/lib/media.ts
 const hotspotSchema = z.object({
@@ -2017,11 +5913,8 @@ function isRecord$3(value) {
 * This module provides a single source of truth for TipTap rich text validation
 * across both the block-form editor and the block rendering system.
 *
-* Format compatibility:
-* - Unwrapped format (new): { type: 'doc', content: [...] }
-* - Wrapped format (legacy): { doc: { type: 'doc', content: [...] } }
-*
-* Both formats are supported for backward compatibility during migration.
+* Rich-text fields use one canonical root shape:
+* `{ type: 'doc', content: [...] }`.
 */
 /**
 * TipTap document node schema (recursive structure)
@@ -2034,17 +5927,40 @@ function isRecord$3(value) {
 * - marks: Text formatting marks (e.g., bold, italic)
 */
 const TipTapMarkSchema = z$1.object({
-	type: z$1.string(),
+	type: z$1.string().min(1),
 	attrs: z$1.record(z$1.string(), z$1.unknown()).optional()
-});
+}).strict();
 const TipTapNodeSchema = z$1.lazy(() => z$1.object({
-	type: z$1.string(),
+	type: z$1.string().min(1),
 	content: z$1.array(TipTapNodeSchema).optional(),
 	text: z$1.string().optional(),
 	attrs: z$1.record(z$1.string(), z$1.unknown()).optional(),
 	marks: z$1.array(TipTapMarkSchema).optional()
+}).strict().superRefine((node, ctx) => {
+	if (node.type === "doc") ctx.addIssue({
+		code: "custom",
+		path: ["type"],
+		message: "Document nodes are only valid at the rich-text root"
+	});
+	if (node.type === "text") {
+		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "Text nodes require a non-empty text value"
+		});
+		if (node.content !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["content"],
+			message: "Text nodes cannot contain child nodes"
+		});
+		return;
+	}
+	if (node.text !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["text"],
+		message: "Only text nodes can contain a text value"
+	});
 }));
-z$1.union([TipTapNodeSchema, z$1.object({ doc: TipTapNodeSchema })]);
 /**
 * Canonical schema for a TipTap rich-text document root.
 *
@@ -2053,111 +5969,11 @@ z$1.union([TipTapNodeSchema, z$1.object({ doc: TipTapNodeSchema })]);
 * (dummy content, editor output, migrations) must emit, and the shape every
 * non-legacy consumer can rely on.
 *
-* Legacy envelopes are read-tolerated by {@link RichTextValueSchema} but
-* normalised before reaching anywhere typed as `RichTextDoc`.
 */
 const RichTextDocSchema = z$1.object({
 	type: z$1.literal("doc"),
 	content: z$1.array(TipTapNodeSchema)
-});
-/**
-* Permissive unwrap for a value known to be the root of a rich-text field.
-*
-* Producers should emit the canonical unwrapped form `{ type: 'doc', content: [...] }`,
-* but two legacy shapes still appear in older data and pre-Phase-1 fixtures:
-*
-*   - `{ doc: <typed-doc> }` — pre-migration DB storage.
-*   - `{ doc: <typed-doc>, html, plain }` — pre-Phase-1 dummy-content output.
-*
-* This helper is the single right place to tolerate either shape at a known
-* rich-text root (transforms, coercion, validators that operate on rich text).
-* The strictness sits on the inner node's `type === 'doc'`, which prevents
-* misidentifying random objects that happen to carry a field named `doc`.
-*
-* Returns the inner doc node when the input matches a legacy shape, otherwise
-* returns the input unchanged.
-*
-* For deep structural traversal where any nested key might be named `doc`
-* (and unwrapping would be incorrect), use the strict `isDocWrapper` private
-* helper inside `@riverbankcms/blocks/bindings`.
-*/
-function unwrapRichTextRoot(value) {
-	if (!isRecord$3(value)) return value;
-	if (!("doc" in value)) return value;
-	const inner = value.doc;
-	if (isRecord$3(inner) && inner.type === "doc") return inner;
-	return value;
-}
-function createHardBreakNode() {
-	return { type: "hardBreak" };
-}
-/**
-* Parse a small markdown subset into TipTap inline nodes.
-*
-* This intentionally supports only bold (`**text**`) because the SDK/content
-* import paths use it for lightweight default content, not full markdown.
-*/
-function parseRichTextInlineMarkdown(text) {
-	const out = [];
-	const pushText = (value, marks) => {
-		if (!value) return;
-		out.push(marks && marks.length > 0 ? {
-			type: "text",
-			text: value,
-			marks
-		} : {
-			type: "text",
-			text: value
-		});
-	};
-	let rest = text;
-	while (rest.length > 0) {
-		const start = rest.indexOf("**");
-		if (start === -1) {
-			pushText(rest);
-			break;
-		}
-		const end = rest.indexOf("**", start + 2);
-		if (end === -1) {
-			pushText(rest);
-			break;
-		}
-		pushText(rest.slice(0, start));
-		pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
-		rest = rest.slice(end + 2);
-	}
-	return out;
-}
-function parseRichTextParagraphInlineMarkdown(text) {
-	return text.split("\n").flatMap((line, index) => {
-		const lineNodes = parseRichTextInlineMarkdown(line.trim());
-		return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
-	});
-}
-/**
-* Convert a plain string with a tiny markdown subset to canonical TipTap JSON.
-*
-* Double newlines create semantic paragraphs. Single newlines remain inside the
-* current paragraph as TipTap `hardBreak` nodes for line-oriented content such
-* as addresses, opening hours, and contact details.
-*/
-function createRichTextDocFromMarkdown(markdown) {
-	const normalized = markdown.replace(/\r\n/g, "\n").trim();
-	if (!normalized) return {
-		type: "doc",
-		content: []
-	};
-	return {
-		type: "doc",
-		content: normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean).map((paragraph) => {
-			const inline = parseRichTextParagraphInlineMarkdown(paragraph);
-			return inline.length > 0 ? {
-				type: "paragraph",
-				content: inline
-			} : { type: "paragraph" };
-		})
-	};
-}
+}).strict();
 //#endregion
 //#region ../blocks/src/system/blocks/events/shared/schemas.ts
 const eventPresetSchema = z$1.enum([
@@ -3911,6 +7727,7 @@ const DISPLAY_MEDIA_KINDS = [
 	"video",
 	"audio"
 ];
+const DEFAULT_MEDIA_FIELD_KINDS = ["image"];
 const PUBLIC_FILE_FIELD_KINDS = [
 	"document",
 	"spreadsheet",
@@ -4111,18 +7928,28 @@ const inlineTextFieldSchema = baseFieldSchema.extend({
 	maxLength: z$1.number().int().positive().optional(),
 	plainTextField: z$1.string().min(1).optional()
 });
+function hasMediaDefaultIdentifier(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.identifier === "string" && value.identifier.trim().length > 0;
+}
+function validateMediaFieldDefault(field, ctx) {
+	if (field.defaultValue !== void 0 && field.defaultValue !== null && !hasMediaDefaultIdentifier(field.defaultValue)) ctx.addIssue({
+		code: z$1.ZodIssueCode.custom,
+		path: ["defaultValue"],
+		message: `${field.type} defaultValue must be null or an object with a non-empty identifier`
+	});
+}
 const mediaFieldSchema = baseFieldSchema.extend({
 	type: z$1.literal("media"),
-	mediaKinds: z$1.array(z$1.enum(MEDIA_KINDS)).default(["image"]).transform((kinds) => {
+	mediaKinds: z$1.array(z$1.enum(MEDIA_KINDS)).default([...DEFAULT_MEDIA_FIELD_KINDS]).transform((kinds) => {
 		const displayKinds = kinds.filter(isDisplayMediaKind);
-		return displayKinds.length > 0 ? displayKinds : ["image"];
+		return displayKinds.length > 0 ? displayKinds : [...DEFAULT_MEDIA_FIELD_KINDS];
 	}),
 	aspectRatio: z$1.string().optional()
-});
+}).superRefine(validateMediaFieldDefault);
 const fileFieldSchema = baseFieldSchema.extend({
 	type: z$1.literal("file"),
 	fileKinds: z$1.array(z$1.enum(PUBLIC_FILE_FIELD_KINDS)).default([...PUBLIC_FILE_FIELD_KINDS])
-});
+}).superRefine(validateMediaFieldDefault);
 const booleanFieldSchema = baseFieldSchema.extend({ type: z$1.literal("boolean") });
 const dateFieldSchema = baseFieldSchema.extend({ type: z$1.literal("date") });
 const timeFieldSchema = baseFieldSchema.extend({ type: z$1.literal("time") });
@@ -6902,11 +10729,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"]),
@@ -7483,12 +11306,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(),
@@ -7633,12 +11451,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),
@@ -7919,4 +11732,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 { hexToRgb as $, formatDate as A, formatBookingInstant as At, resolveEventCta as B, publicEventPricingCurrency as Bt, getWizardStepsForContext as C, ok as Ct, normalizeCsvIds as D, addLocalScheduleDays as Dt, getEventRuntimeFiltersKey as E, reportWorkflowSuccess as Et, formatEventTeacherLine as F, resolveBookingTimeZoneId as Ft, getLocalDateKey as G, formatCurrencyAmount as Gt, resolveRuntimeEventPricing as H, publicEventPricingType as Ht, formatTime as I, toBookingTimeZone as It, RichTextDocSchema as J, getLocalMinuteOfDay as K, assertNever$2 as Kt, getCardOrientation as L, toScheduledBookingDateTime as Lt, formatEventDateParts as M, formatLocalScheduleDate as Mt, formatEventPrice as N, getBookingLocalDateKey as Nt, normalizeCsvString as O, formatBookingDate as Ot, formatEventPriceDisplay as P, parseBookingLocalDate as Pt, relativeLuminance as Q, getContainerClass as R, parseEventPageSurfaceSubject as Rt, getStepNumber as S, err as St, buildEventRuntimeFilters as T, reportWorkflowError as Tt, getEventAvailability as U, publicEventScalarPrice as Ut, resolveEventLinkProps as V, publicEventPricingMode as Vt, getEventAvailabilityStatus 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, formatEventCompactDateRail as j, formatBookingTime as jt, normalizeOptionalId 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, normalizeEventBlockKind 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, groupEventsByDate as z, formatBookingPriceDisplay as zt };