@riverbankcms/sdk 0.111.0 → 0.119.0

package/dist/client/bookings.mjs

@@ -7329,111 +7329,6 @@ function useAppointmentCheckoutVerificationWithDeps(config, deps) {
 	};
 }
 //#endregion
-//#region ../theme-core/src/buttons/effectClassification.ts
-/**
-* Exhaustive live policy for every registered effect id.
-*
-* The resolver consumes the transition payload directly, so adding an effect
-* cannot update classification without also defining its runtime behavior.
-*/
-const BUTTON_EFFECT_POLICIES = {
-	"darken-background": {
-		classification: "colour-transition",
-		transition: {
-			kind: "adjust-shade",
-			direction: "darker"
-		}
-	},
-	"lighten-background": {
-		classification: "colour-transition",
-		transition: {
-			kind: "adjust-shade",
-			direction: "lighter"
-		}
-	},
-	"background-on-hover": {
-		classification: "colour-transition",
-		transition: { kind: "replace-background" }
-	},
-	"background-on-hover-alpha": {
-		classification: "unsupported-colour",
-		reason: "alpha_requires_surface"
-	},
-	"fade-background": {
-		classification: "unsupported-colour",
-		reason: "changes_element_opacity"
-	},
-	"opacity-reduce": {
-		classification: "unsupported-colour",
-		reason: "changes_element_opacity"
-	},
-	"gradient-text": {
-		classification: "unsupported-colour",
-		reason: "changes_foreground"
-	},
-	"text-color-change": {
-		classification: "unsupported-colour",
-		reason: "changes_foreground"
-	},
-	"border-color-change": {
-		classification: "unsupported-colour",
-		reason: "changes_border"
-	},
-	"aurora-glow": {
-		classification: "unsupported-background-overlay",
-		reason: "unresolved_background_overlay"
-	},
-	"cosmic-stardust": {
-		classification: "unsupported-background-overlay",
-		reason: "unresolved_background_overlay"
-	},
-	"gradient-border-fill": {
-		classification: "unsupported-background-overlay",
-		reason: "unresolved_background_overlay"
-	},
-	"animated-gradient-border-fill": {
-		classification: "unsupported-background-overlay",
-		reason: "unresolved_background_overlay"
-	},
-	"nav-underline": {
-		classification: "not-button",
-		reason: "not_button_effect"
-	},
-	"nav-frosted-base": {
-		classification: "not-button",
-		reason: "not_button_effect"
-	},
-	"nav-frosted-hover": {
-		classification: "not-button",
-		reason: "not_button_effect"
-	},
-	"nav-frosted-active": {
-		classification: "not-button",
-		reason: "not_button_effect"
-	},
-	"animated-gradient": { classification: "non-colour" },
-	"border-glow": { classification: "non-colour" },
-	"drop-shadow": { classification: "non-colour" },
-	"inner-shadow": { classification: "non-colour" },
-	"neumorphic-shadow": { classification: "non-colour" },
-	"outer-glow": { classification: "non-colour" },
-	"retro-3d-shadow": { classification: "non-colour" },
-	"scale-up": { classification: "non-colour" },
-	"scale-down": { classification: "non-colour" },
-	lift: { classification: "non-colour" },
-	"press-down": { classification: "non-colour" },
-	pop: { classification: "non-colour" },
-	"border-bottom-grow": { classification: "non-colour" },
-	"sketchy-border": { classification: "non-colour" },
-	"pulse-animation": { classification: "non-colour" }
-};
-function getButtonEffectPolicy(effectId) {
-	return Object.prototype.hasOwnProperty.call(BUTTON_EFFECT_POLICIES, effectId) ? BUTTON_EFFECT_POLICIES[effectId] : null;
-}
-function classifyButtonEffectId(effectId) {
-	return getButtonEffectPolicy(effectId)?.classification ?? "unknown";
-}
-//#endregion
 //#region ../theme-core/src/tokens/colorTokenParts.ts
 function parseOpacityPercent(source) {
 	const trimmed = source.trim();
@@ -7587,6 +7482,13 @@ const VARIANT_ROLES = [
 	"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;
@@ -7601,6 +7503,109 @@ const opaqueButtonColourTokenSchema = themeColorTokenSchema.refine((value) => pa
 	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",
@@ -7618,372 +7623,2080 @@ const textTransformSchema = z$1.enum([
 	"lowercase",
 	"capitalize"
 ]);
-const fontWeightSchema = z$1.union([
-	z$1.literal(500),
-	z$1.literal(600),
-	z$1.literal(700)
+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 cardSpacingSchema = z$1.enum([
+	"none",
+	"compact",
+	"cozy",
+	"medium",
+	"comfortable",
+	"spacious"
+]);
+const gradientDirectionSchema = z$1.enum([
+	"to-r",
+	"to-l",
+	"to-t",
+	"to-b",
+	"to-tr",
+	"to-tl",
+	"to-br",
+	"to-bl"
+]);
+z$1.enum(cardVariantRoleValues);
+const boxStylesCardVariantSchema = z$1.enum([...cardVariantRoleValues, boxlessCardVariantValue]);
+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();
+//#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 buttonTypographySchema = z$1.enum(["body", "heading"]);
-const letterSpacingSchema = z$1.enum([
-	"tight",
-	"normal",
-	"loose"
+const footerMaxWidth = z$1.enum(["container", "full"]);
+const footerMode = z$1.enum([
+	"default",
+	"blocks",
+	"default+blocks",
+	"none"
 ]);
-const hoverTransformSchema = z$1.enum([
-	"none",
-	"lift",
-	"scale",
-	"press"
+const footerNavLayoutMode = z$1.enum([
+	"stack",
+	"inline",
+	"inline-wrap"
 ]);
-const hoverColorSchema = z$1.enum([
-	"none",
-	"brighten",
-	"darken",
-	"saturate",
-	"token"
+const footerNavLayoutAlign = z$1.enum([
+	"start",
+	"center",
+	"end",
+	"space-between"
 ]);
-const buttonPaddingPresetSchema = z$1.enum([
+const footerSpacing = z$1.enum([
+	"none",
+	"tight",
 	"compact",
 	"default",
+	"relaxed",
 	"spacious"
 ]);
-const gradientStyleSchema = z$1.enum([
-	"linear",
-	"radial",
-	"conic"
-]);
-const gradientSharpnessSchema = z$1.enum([
-	"smooth",
-	"medium",
-	"hard"
+const footerLogoPlacement = z$1.enum([
+	"left",
+	"right",
+	"above",
+	"below"
 ]);
-const prioritySchema = z$1.union([
-	z$1.literal(1),
-	z$1.literal(2),
-	z$1.literal(3)
+const footerLogoSize = z$1.enum([
+	"sm",
+	"md",
+	"lg",
+	"xl"
 ]);
-z$1.enum(VARIANT_ROLES);
-const buttonSizeNameSchema = z$1.enum([
+const footerLogoMaxHeight = 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()
+const footerBottomTextLinkStyleSchema = z$1.object({
+	colorToken: themeColorTokenSchema.optional(),
+	hoverColorToken: themeColorTokenSchema.nullable().optional(),
+	decorationColorToken: themeColorTokenSchema.nullable().optional(),
+	underline: z$1.boolean().optional()
 });
-/**
-* `xl` is optional on the wire so themes persisted before the `xl` size was
-* added (e.g. SWTS) continue to parse. When `xl` is missing the schema
-* backfills it from `lg`, keeping `ButtonSizes` a complete `sm/md/lg/xl` map
-* downstream — generators never need to deal with an undefined `xl`.
-*/
-const buttonSizesSchema = z$1.object({
-	sm: buttonSizeConfigSchema,
-	md: buttonSizeConfigSchema,
-	lg: buttonSizeConfigSchema,
-	xl: buttonSizeConfigSchema.optional()
-}).transform(({ sm, md, lg, xl }) => ({
-	sm,
-	md,
-	lg,
-	xl: xl ?? lg
-}));
-const canonicalButtonGlobalSettingsSchema = z$1.object({
-	cornerStyle: cornerStyleSchema,
-	cornerRadius: z$1.number().min(0).max(24).optional(),
-	/**
-	* Family-level shadow inherited by variants that don't set their own.
-	* Optional and flat-by-default: when omitted, buttons carry no drop shadow
-	* (`elevation: 'none'`). A personality opts the whole family into a shadow by
-	* setting this; individual variants still override. There is no system-level
-	* shadow-by-default — shadows only appear when explicitly declared.
-	*/
-	shadow: shadowSizeSchema.optional(),
-	textTransform: textTransformSchema,
-	fontWeight: fontWeightSchema,
+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({
 	/**
-	* @deprecated Set per-variant via `variant.border.widthClass` instead.
-	* Schema field is preserved so existing presets parse; the value is unread
-	* by the current generator and will be removed once the legacy
-	* `primitives/content/components/Button.tsx` slot exports are deleted.
+	* SDK-only footer rendering mode.
+	*
+	* Backwards compatible: missing/undefined behaves as 'default'.
 	*/
-	borderWidth: z$1.union([
-		z$1.literal(1),
-		z$1.literal(2),
-		z$1.literal(3)
-	]),
-	typography: buttonTypographySchema.optional(),
-	fontSize: z$1.string().optional(),
-	letterSpacing: letterSpacingSchema.optional(),
-	italic: z$1.boolean().optional(),
-	paddingPreset: buttonPaddingPresetSchema.optional(),
-	hoverTransform: hoverTransformSchema,
-	hoverColor: hoverColorSchema,
-	hoverColorToken: opaqueButtonColourTokenSchema.optional(),
-	gradientStyle: gradientStyleSchema.optional(),
-	gradientAngle: z$1.number().min(0).max(360).optional(),
-	gradientSharpness: gradientSharpnessSchema.optional()
+	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 buttonGlobalSettingsSchema = z$1.preprocess(normalizeLegacyButtonGlobalInput, canonicalButtonGlobalSettingsSchema);
-const gradientDirectionSchema = z$1.enum([
-	"to-r",
-	"to-l",
-	"to-t",
-	"to-b",
-	"to-tr",
-	"to-tl",
-	"to-br",
-	"to-bl"
+const containerPaddingPresetSchema = z$1.enum([
+	"tight",
+	"compact",
+	"default",
+	"relaxed"
 ]);
-const buttonColourTreatmentSchema = z$1.discriminatedUnion("type", [
-	z$1.object({
-		type: z$1.literal("solid"),
-		colorToken: opaqueButtonColourTokenSchema
-	}),
-	z$1.object({
-		type: z$1.literal("gradient"),
-		stops: z$1.array(opaqueButtonColourTokenSchema).min(2).transform((stops) => {
-			const [first, second, ...rest] = stops;
-			if (first === void 0 || second === void 0) throw new Error("Invariant: gradient stops passed the minimum length schema");
-			return [
-				first,
-				second,
-				...rest
-			];
-		}),
-		direction: gradientDirectionSchema,
-		foregroundToken: opaqueButtonColourTokenSchema
-	}),
-	z$1.object({
-		type: z$1.literal("surface"),
-		role: z$1.literal("link")
-	})
+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 buttonBackgroundSchema = buttonColourTreatmentSchema;
-const effectApplicationSchema = z$1.object({
-	effectId: z$1.string(),
-	options: z$1.record(z$1.string(), z$1.json()).optional()
+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 buttonBorderSchema = z$1.object({ widthClass: z$1.string() });
-const buttonVariantAffordanceSchema = z$1.object({ iconId: z$1.string().min(1) });
-const variantShadowSchema = z$1.object({
-	elevation: z$1.enum([
-		"none",
-		"low",
-		"medium",
-		"high"
-	]),
-	softness: z$1.enum([
-		"crisp",
-		"soft",
-		"hard"
-	]).nullable(),
-	position: z$1.enum(["bottom", "bottom-right"]).default("bottom"),
-	colorToken: themeColorTokenSchema.optional()
+const 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 variantEffectsSchema = z$1.object({
-	base: z$1.array(effectApplicationSchema).optional(),
-	hover: z$1.array(effectApplicationSchema).optional(),
-	active: z$1.array(effectApplicationSchema).optional(),
-	focus: z$1.array(effectApplicationSchema).optional()
+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()
 });
 /**
-* 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.
+* 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 variantSizeOverridesSchema = z$1.object({
-	sm: buttonSizeConfigSchema.optional(),
-	md: buttonSizeConfigSchema.optional(),
-	lg: buttonSizeConfigSchema.optional(),
-	xl: buttonSizeConfigSchema.optional()
+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()
 });
-/**
-* Unified variant schema. Every variant participates in the size system; the
-* optional `sizes` field lets a variant scale differently than the theme
-* default (e.g. link-style variants declaring zero horizontal padding at
-* every size).
-*/
-const canonicalButtonVariantSchema = z$1.object({
-	id: z$1.string(),
-	name: z$1.string().min(1).max(20),
-	enabled: z$1.boolean(),
-	priority: prioritySchema,
-	background: buttonBackgroundSchema,
-	/** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-	borderRadius: z$1.string().optional(),
-	shadow: variantShadowSchema.optional(),
-	border: buttonBorderSchema.optional(),
-	hoverBackgroundToken: opaqueButtonColourTokenSchema.optional(),
-	effects: variantEffectsSchema.optional(),
-	sizes: variantSizeOverridesSchema.optional(),
-	affordance: buttonVariantAffordanceSchema.optional()
+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()
 });
-/**
-* Temporary persisted-theme admission boundary for issue #1206.
-*
-* Production inventory on 2026-07-22 found 22 rows using the old independent
-* `textColorToken`/border colour shape. New source and all downstream code use
-* only the canonical relationship. Delete this preprocessor after the reviewed
-* production rewrite reports zero legacy rows.
-*/
-const buttonVariantSchema = z$1.preprocess(normalizeLegacyButtonVariantInput, canonicalButtonVariantSchema);
-const buttonSystemSchema = z$1.object({
-	global: buttonGlobalSettingsSchema,
-	variants: z$1.array(buttonVariantSchema).min(1).max(6),
-	sizes: buttonSizesSchema.optional()
+z$1.object({
+	message: z$1.string().min(1),
+	themes: z$1.array(themeSchema).length(3)
 });
-function normalizeLegacyButtonVariantInput(input) {
-	if (!isUnknownRecord(input)) return input;
-	const background = input.background;
-	if (!isUnknownRecord(background)) return input;
-	if (!(background.type === "transparent" || Object.prototype.hasOwnProperty.call(input, "textColorToken") || isUnknownRecord(input.border) && Object.prototype.hasOwnProperty.call(input.border, "colorToken") || hasLegacyButtonEffects(input.effects) || hasLegacyAlphaToken(input, background))) return input;
-	const { textColorToken, ...withoutLegacyText } = input;
-	const normalizedBorder = isUnknownRecord(input.border) && typeof input.border.widthClass === "string" ? { widthClass: input.border.widthClass } : input.border;
-	const normalizedAffordance = isUnknownRecord(input.affordance) && typeof input.affordance.iconId === "string" ? { iconId: input.affordance.iconId } : input.affordance;
-	const normalizedEffects = normalizeLegacyButtonEffects(input.effects, background.type);
-	const hoverBackgroundToken = stripLegacyTokenAlpha(input.hoverBackgroundToken);
-	if (background.type === "transparent") return {
-		...withoutLegacyText,
-		background: {
-			type: "surface",
-			role: "link"
-		},
-		border: normalizedBorder,
-		affordance: normalizedAffordance,
-		effects: normalizedEffects,
-		hoverBackgroundToken
-	};
-	if (background.type === "gradient") {
-		const stops = Array.isArray(background.stops) ? background.stops.map(stripLegacyTokenAlpha) : background.stops;
-		return {
-			...withoutLegacyText,
-			background: {
-				...background,
-				stops,
-				foregroundToken: stripLegacyTokenAlpha(background.foregroundToken ?? textColorToken)
-			},
-			border: normalizedBorder,
-			affordance: normalizedAffordance,
-			effects: normalizedEffects,
-			hoverBackgroundToken
-		};
-	}
-	return {
-		...withoutLegacyText,
-		background: background.type === "solid" ? {
-			...background,
-			colorToken: stripLegacyTokenAlpha(background.colorToken)
-		} : background,
-		border: normalizedBorder,
-		affordance: normalizedAffordance,
-		effects: normalizedEffects,
-		hoverBackgroundToken
-	};
-}
-function normalizeLegacyButtonGlobalInput(input) {
-	if (!isUnknownRecord(input)) return input;
-	const hoverColorToken = stripLegacyTokenAlpha(input.hoverColorToken);
-	return hoverColorToken === input.hoverColorToken ? input : {
-		...input,
-		hoverColorToken
-	};
-}
-function hasLegacyAlphaToken(input, background) {
-	const stops = isUnknownArray(background.stops) ? background.stops : [];
-	return [
-		input.hoverBackgroundToken,
-		background.colorToken,
-		background.foregroundToken,
-		...stops
-	].some((token) => stripLegacyTokenAlpha(token) !== token);
-}
-function stripLegacyTokenAlpha(value) {
-	if (typeof value !== "string") return value;
-	const slashIndex = value.indexOf("/");
-	return slashIndex < 0 ? value : value.slice(0, slashIndex);
-}
-function hasLegacyButtonEffects(input) {
-	if (!isUnknownRecord(input)) return false;
-	return [
-		"base",
-		"hover",
-		"active",
-		"focus"
-	].some((state) => {
-		const effects = input[state];
-		return Array.isArray(effects) && effects.some((effect) => {
-			if (!isUnknownRecord(effect) || typeof effect.effectId !== "string") return true;
-			const classification = classifyButtonEffectId(effect.effectId);
-			if (classification !== "colour-transition" && classification !== "non-colour") return true;
-			return effect.effectId === "background-on-hover" && isUnknownRecord(effect.options) && stripLegacyTokenAlpha(effect.options.colorToken) !== effect.options.colorToken;
-		});
-	});
-}
-function normalizeLegacyButtonEffects(input, backgroundType) {
-	if (!isUnknownRecord(input)) return input;
-	const normalized = {};
-	for (const state of [
-		"base",
-		"hover",
-		"active",
-		"focus"
-	]) {
-		const effects = input[state];
-		if (!Array.isArray(effects)) continue;
-		const safeEffects = effects.flatMap((effect) => {
-			if (!isUnknownRecord(effect) || typeof effect.effectId !== "string") return [];
-			const classification = classifyButtonEffectId(effect.effectId);
-			if (classification === "non-colour") return [effect];
-			if (classification !== "colour-transition") return [];
-			if (effect.effectId === "background-on-hover") {
-				const options = isUnknownRecord(effect.options) ? effect.options : null;
-				const colorToken = options === null ? null : parseOpaqueButtonColourToken(stripLegacyTokenAlpha(options.colorToken));
-				return colorToken === null ? [] : [{
-					...effect,
-					options: {
-						...options,
-						colorToken
-					}
-				}];
-			}
-			if (backgroundType !== "solid") return [];
-			const rawAmount = isUnknownRecord(effect.options) ? effect.options.amount : void 0;
-			const amount = typeof rawAmount === "number" && rawAmount > 0 ? Math.max(100, Math.round(rawAmount / 100) * 100) : 100;
-			return [{
-				...effect,
-				options: {
-					...isUnknownRecord(effect.options) ? effect.options : {},
-					amount
-				}
-			}];
-		});
-		if (safeEffects.length > 0) normalized[state] = safeEffects;
-	}
-	return Object.keys(normalized).length === 0 ? void 0 : normalized;
-}
-function isUnknownRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isUnknownArray(value) {
-	return Array.isArray(value);
-}
 //#endregion
 //#region ../theme-core/src/buttons/classNames.ts
 function themeButtonVariantClassNames(variant) {
@@ -8155,7 +9868,6 @@ const quietArrowRecipe = defineButtonStyleRecipe({
 			cornerStyle: "rounded",
 			textTransform: "uppercase",
 			fontWeight: 500,
-			borderWidth: 1,
 			typography: "body",
 			fontSize: "text-sm",
 			letterSpacing: "loose",
@@ -8219,7 +9931,7 @@ const quietArrowRecipe = defineButtonStyleRecipe({
 					affordance: { iconId: "ArrowRight" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surfaceAlt" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
 					}] }
 				}
 			},
@@ -8330,7 +10042,6 @@ const softPillRecipe = defineStaticButtonStyleRecipe({
 			shadow: "low",
 			textTransform: "none",
 			fontWeight: 500,
-			borderWidth: 2,
 			hoverTransform: "lift",
 			hoverColor: "none"
 		},
@@ -8349,10 +10060,7 @@ const softPillRecipe = defineStaticButtonStyleRecipe({
 						position: "bottom"
 					},
 					effects: {
-						hover: [{
-							effectId: "lift",
-							options: { translateY: "-1px" }
-						}],
+						hover: [{ effectId: "lift" }],
 						active: [{
 							effectId: "scale-down",
 							options: { scale: "0.98" }
@@ -8371,7 +10079,7 @@ const softPillRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border-2" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8386,7 +10094,7 @@ const softPillRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8400,7 +10108,7 @@ const softPillRecipe = defineStaticButtonStyleRecipe({
 					borderRadius: "rounded-full",
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8430,7 +10138,6 @@ const earthPillRecipe = defineStaticButtonStyleRecipe({
 			shadow: "low",
 			textTransform: "none",
 			fontWeight: 500,
-			borderWidth: 1,
 			hoverTransform: "lift",
 			hoverColor: "none",
 			typography: "body",
@@ -8466,12 +10173,9 @@ const earthPillRecipe = defineStaticButtonStyleRecipe({
 						position: "bottom"
 					},
 					effects: {
-						hover: [{
-							effectId: "lift",
-							options: { translateY: "-1px" }
-						}, {
+						hover: [{ effectId: "lift" }, {
 							effectId: "background-on-hover",
-							options: { colorToken: "accent" }
+							options: { colorToken: unsafeAsOpaqueButtonColourToken("accent") }
 						}],
 						active: [{
 							effectId: "scale-down",
@@ -8491,7 +10195,7 @@ const earthPillRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "muted" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("muted") }
 					}] }
 				}
 			},
@@ -8506,7 +10210,7 @@ const earthPillRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surfaceAlt" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
 					}] }
 				}
 			},
@@ -8566,7 +10270,6 @@ const confidentChipRecipe = defineStaticButtonStyleRecipe({
 			shadow: "medium",
 			textTransform: "none",
 			fontWeight: 600,
-			borderWidth: 1,
 			hoverTransform: "none",
 			hoverColor: "none"
 		},
@@ -8607,7 +10310,7 @@ const confidentChipRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "background" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("background") }
 					}] }
 				}
 			},
@@ -8622,7 +10325,7 @@ const confidentChipRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8636,7 +10339,7 @@ const confidentChipRecipe = defineStaticButtonStyleRecipe({
 					borderRadius: "rounded-md",
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8671,7 +10374,6 @@ const editorialLinkRecipe = defineStaticButtonStyleRecipe({
 			cornerStyle: "square",
 			textTransform: "none",
 			fontWeight: 500,
-			borderWidth: 1,
 			hoverTransform: "none",
 			hoverColor: "none"
 		},
@@ -8689,7 +10391,6 @@ const editorialLinkRecipe = defineStaticButtonStyleRecipe({
 						effectId: "border-bottom-grow",
 						options: {
 							height: 2,
-							colorToken: "text",
 							origin: "left"
 						}
 					}] }
@@ -8708,7 +10409,6 @@ const editorialLinkRecipe = defineStaticButtonStyleRecipe({
 						effectId: "border-bottom-grow",
 						options: {
 							height: 1,
-							colorToken: "mutedText",
 							origin: "left"
 						}
 					}] }
@@ -8727,7 +10427,6 @@ const editorialLinkRecipe = defineStaticButtonStyleRecipe({
 						effectId: "border-bottom-grow",
 						options: {
 							height: 1,
-							colorToken: "accent",
 							origin: "left"
 						}
 					}] }
@@ -8751,7 +10450,6 @@ const editorialLinkRecipe = defineStaticButtonStyleRecipe({
 					effectId: "border-bottom-grow",
 					options: {
 						height: 2,
-						colorToken: "accent",
 						origin: "left"
 					}
 				}] } }
@@ -8773,7 +10471,6 @@ const pebbleRecipe = defineStaticButtonStyleRecipe({
 			cornerStyle: "pill",
 			textTransform: "none",
 			fontWeight: 500,
-			borderWidth: 2,
 			hoverTransform: "none",
 			hoverColor: "none"
 		},
@@ -8818,7 +10515,7 @@ const pebbleRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border-2" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "accent" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("accent") }
 					}] }
 				}
 			},
@@ -8833,7 +10530,7 @@ const pebbleRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8888,7 +10585,6 @@ const brushedWashRecipe = defineStaticButtonStyleRecipe({
 			shadow: "low",
 			textTransform: "none",
 			fontWeight: 500,
-			borderWidth: 1,
 			hoverTransform: "none",
 			hoverColor: "none"
 		},
@@ -8953,7 +10649,7 @@ const brushedWashRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8967,7 +10663,7 @@ const brushedWashRecipe = defineStaticButtonStyleRecipe({
 					borderRadius: "rounded-lg",
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -8996,7 +10692,6 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 			cornerStyle: "rounded",
 			textTransform: "uppercase",
 			fontWeight: 600,
-			borderWidth: 1,
 			hoverTransform: "none",
 			hoverColor: "none",
 			letterSpacing: "loose"
@@ -9054,7 +10749,7 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border-2" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -9069,7 +10764,7 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border-2" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -9103,7 +10798,6 @@ const inkStampRecipe = defineStaticButtonStyleRecipe({
 						effectId: "border-bottom-grow",
 						options: {
 							height: 1,
-							colorToken: "accent",
 							origin: "left"
 						}
 					}] }
@@ -9134,7 +10828,6 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 			cornerStyle: "rounded",
 			textTransform: "none",
 			fontWeight: 600,
-			borderWidth: 1,
 			typography: "body",
 			letterSpacing: "tight",
 			paddingPreset: "default",
@@ -9166,12 +10859,9 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 					},
 					borderRadius: "rounded-lg",
 					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{
-						effectId: "lift",
-						options: { translateY: "-2px" }
-					}, {
+					effects: { hover: [{ effectId: "lift" }, {
 						effectId: "background-on-hover",
-						options: { colorToken: "secondary" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("secondary") }
 					}] }
 				}
 			},
@@ -9184,12 +10874,9 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 					},
 					borderRadius: "rounded-lg",
 					border: { widthClass: "border" },
-					effects: { hover: [{
-						effectId: "lift",
-						options: { translateY: "-2px" }
-					}, {
+					effects: { hover: [{ effectId: "lift" }, {
 						effectId: "background-on-hover",
-						options: { colorToken: "surfaceAlt" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
 					}] }
 				}
 			},
@@ -9202,12 +10889,9 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 					},
 					borderRadius: "rounded-lg",
 					border: { widthClass: "border" },
-					effects: { hover: [{
-						effectId: "lift",
-						options: { translateY: "-2px" }
-					}, {
+					effects: { hover: [{ effectId: "lift" }, {
 						effectId: "background-on-hover",
-						options: { colorToken: "surfaceAlt" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surfaceAlt") }
 					}] }
 				}
 			},
@@ -9219,10 +10903,7 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 						role: "link"
 					},
 					borderRadius: "rounded-lg",
-					effects: { hover: [{
-						effectId: "lift",
-						options: { translateY: "-2px" }
-					}] }
+					effects: { hover: [{ effectId: "lift" }] }
 				}
 			},
 			accent: {
@@ -9234,10 +10915,7 @@ const flatInkRecipe = defineStaticButtonStyleRecipe({
 					},
 					borderRadius: "rounded-lg",
 					affordance: { iconId: "ArrowRight" },
-					effects: { hover: [{
-						effectId: "lift",
-						options: { translateY: "-2px" }
-					}] }
+					effects: { hover: [{ effectId: "lift" }] }
 				}
 			}
 		}
@@ -9258,9 +10936,8 @@ const showtimePillRecipe = defineStaticButtonStyleRecipe({
 			shadow: "low",
 			textTransform: "uppercase",
 			fontWeight: 700,
-			borderWidth: 2,
 			hoverTransform: "lift",
-			hoverColor: "darken",
+			hoverColor: "none",
 			typography: "body",
 			paddingPreset: "spacious",
 			italic: false
@@ -9318,7 +10995,7 @@ const showtimePillRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border-2" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "background" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("background") }
 					}] }
 				}
 			},
@@ -9332,7 +11009,7 @@ const showtimePillRecipe = defineStaticButtonStyleRecipe({
 					borderRadius: "rounded-full",
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -9367,7 +11044,6 @@ const joyStampRecipe = defineStaticButtonStyleRecipe({
 			typography: "heading",
 			fontWeight: 700,
 			fontSize: "text-lg",
-			borderWidth: 2,
 			hoverTransform: "none",
 			hoverColor: "none"
 		},
@@ -9402,7 +11078,7 @@ const joyStampRecipe = defineStaticButtonStyleRecipe({
 						elevation: "high",
 						softness: "hard",
 						position: "bottom-right",
-						colorToken: "text"
+						colorToken: unsafeAsOpaqueButtonColourToken("text")
 					},
 					effects: { hover: [{ effectId: "press-down" }] }
 				}
@@ -9420,7 +11096,7 @@ const joyStampRecipe = defineStaticButtonStyleRecipe({
 						elevation: "high",
 						softness: "hard",
 						position: "bottom-right",
-						colorToken: "secondary"
+						colorToken: unsafeAsOpaqueButtonColourToken("secondary")
 					},
 					effects: { hover: [{ effectId: "press-down" }] }
 				}
@@ -9465,7 +11141,6 @@ const ornateRitualRecipe = defineStaticButtonStyleRecipe({
 			cornerStyle: "rounded",
 			textTransform: "uppercase",
 			fontWeight: 600,
-			borderWidth: 1,
 			hoverTransform: "none",
 			hoverColor: "none",
 			letterSpacing: "loose"
@@ -9501,7 +11176,7 @@ const ornateRitualRecipe = defineStaticButtonStyleRecipe({
 					effects: {
 						hover: [{
 							effectId: "background-on-hover",
-							options: { colorToken: "primary-100" }
+							options: { colorToken: unsafeAsOpaqueButtonColourToken("primary-100") }
 						}],
 						active: [{
 							effectId: "scale-down",
@@ -9521,7 +11196,7 @@ const ornateRitualRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "surface" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("surface") }
 					}] }
 				}
 			},
@@ -9536,7 +11211,7 @@ const ornateRitualRecipe = defineStaticButtonStyleRecipe({
 					border: { widthClass: "border" },
 					effects: { hover: [{
 						effectId: "background-on-hover",
-						options: { colorToken: "muted" }
+						options: { colorToken: unsafeAsOpaqueButtonColourToken("muted") }
 					}] }
 				}
 			},
@@ -9570,7 +11245,6 @@ const ornateRitualRecipe = defineStaticButtonStyleRecipe({
 						effectId: "border-bottom-grow",
 						options: {
 							height: 1,
-							colorToken: "accent",
 							origin: "left"
 						}
 					}] }
@@ -12561,11 +14235,8 @@ const mediaSchema = z.discriminatedUnion("type", [
 * 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)
@@ -12578,17 +14249,40 @@ const mediaSchema = z.discriminatedUnion("type", [
 * - 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.
 *
@@ -12597,13 +14291,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)
-});
+}).strict();
 //#endregion
 //#region ../blocks/src/system/blocks/courses/shared/schemas.ts
 /**