@riverbankcms/sdk 0.129.1 → 0.130.2

package/dist/server/theme.mjs

@@ -1,4 +1,4 @@
-import z, { z as z$1 } from "zod";
+import { z } from "zod";
 import * as fs from "fs/promises";
 import * as path from "path";
 //#region ../theme-core/src/palette/utils/colorConversion.ts
@@ -312,6 +312,25 @@ const nonShadeablePaletteRoleNames = /* @__PURE__ */ new Set([
 	"warning",
 	"destructive"
 ]);
+/**
+* Status role aliases the persisted palette does not carry itself.
+*
+* Generators reference `--tb-error` (the site-style-owned input error border)
+* and `--tb-info` (`.alert-info`, `.status-info`, the field-note rule), but the
+* palette schema only defines `destructive` and has no `info` role at all.
+* Without these aliases those declarations name variables that are never
+* defined and browsers drop them. The SDK bridge resolves the same pair via
+* TOKEN_ALIASES, so both runtimes agree on what a status token means.
+*
+* Runs after the danger → destructive promotion above, so `destructive` is
+* already the single source of truth for the error colour.
+*/
+function statusAliasTokens(expanded) {
+	const aliases = {};
+	if (expanded.destructive) aliases.error = expanded.destructive;
+	if (expanded.accent) aliases.info = expanded.accent;
+	return aliases;
+}
 function expandPalette(palette) {
 	const base = colorsToMap(palette);
 	const expanded = { ...base };
@@ -330,6 +349,7 @@ function expandPalette(palette) {
 	}
 	if (base.text) expanded.body = base.text;
 	if (base.danger && !base.destructive) expanded.destructive = base.danger;
+	Object.assign(expanded, statusAliasTokens(expanded));
 	const isDark = base.background ? isBackgroundDark(base.background) : false;
 	expanded.mutedText = palette.meta?.mode === "dark" || isDark ? expanded["neutral-600"] ?? "#666" : expanded["neutral-500"] ?? "#888";
 	for (const [token, hex] of Object.entries({ ...expanded })) {
@@ -431,7 +451,7 @@ const PALETTE_TOKEN_NAMES = [
 	"text",
 	"border"
 ];
-const paletteTokenNameSchema = z$1.enum(PALETTE_TOKEN_NAMES);
+const paletteTokenNameSchema = z.enum(PALETTE_TOKEN_NAMES);
 const themeColorBaseTokenNames = [
 	...PALETTE_TOKEN_NAMES,
 	...blockColorTokenNames,
@@ -476,7 +496,7 @@ function parseThemeColorToken(value) {
 	if (!isThemeColorToken(value)) return null;
 	return value.trim();
 }
-const themeColorTokenSchema = z$1.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
+const themeColorTokenSchema = z.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
 //#endregion
 //#region ../theme-core/src/palette/colors.ts
 const HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
@@ -496,11 +516,11 @@ const THEME_PALETTE_COLOR_ORDER = [
 	"primaryForeground",
 	"border"
 ];
-const hexColorSchema = z$1.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
-const paletteModeSchema = z$1.enum(["light", "dark"]);
+const hexColorSchema = z.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+const paletteModeSchema = z.enum(["light", "dark"]);
 const PALETTE_VALUE_KEY_PREFIX = "palette-value:v1|";
-z$1.string().regex(/^[0-9a-f]{64}$/, "Palette hash must be a lowercase SHA-256 value").transform((value) => value);
-const paletteColorsSchema = z$1.object({
+z.string().regex(/^[0-9a-f]{64}$/, "Palette hash must be a lowercase SHA-256 value").transform((value) => value);
+const paletteColorsSchema = z.object({
 	primary: hexColorSchema,
 	primaryForeground: hexColorSchema,
 	secondary: hexColorSchema,
@@ -606,14 +626,14 @@ function parsePaletteValueKey(value) {
 	if (!colors.ok || paletteValueKey(colors.colors, mode.data) !== value) return null;
 	return value;
 }
-z$1.string().transform((value, ctx) => {
+z.string().transform((value, ctx) => {
 	const parsed = parsePaletteValueKey(value);
 	if (parsed) return parsed;
 	ctx.addIssue({
 		code: "custom",
 		message: "Invalid canonical palette value key"
 	});
-	return z$1.NEVER;
+	return z.NEVER;
 });
 //#endregion
 //#region ../theme-core/src/lib/media.ts
@@ -649,15 +669,17 @@ const transformSchema = z.object({
 	hotspot: hotspotSchema.optional(),
 	rotation: rotationSchema.optional()
 });
-const mediaSchema = z.object({
-	type: z.enum([
-		"image",
-		"video",
-		"audio",
-		"document",
-		"spreadsheet",
-		"archive"
-	]),
+const mediaPosterSchema = z.discriminatedUnion("tag", [z.object({
+	tag: z.literal("storage"),
+	assetId: z.string().optional(),
+	storageBucket: z.string().min(1),
+	storagePath: z.string().min(1)
+}), z.object({
+	tag: z.literal("external-src"),
+	assetId: z.string().optional(),
+	src: z.string().url()
+})]);
+const mediaBaseSchema = z.object({
 	purpose: z.string().optional(),
 	placeholder: z.boolean().default(true).optional(),
 	assetId: z.string().optional(),
@@ -670,18 +692,43 @@ const mediaSchema = z.object({
 	height: z.number().optional(),
 	storageBucket: z.string().optional(),
 	storagePath: z.string().optional(),
+	poster: mediaPosterSchema.optional(),
 	transform: transformSchema.optional()
 });
+const mediaIdentifierSchema = z.string().trim().min(1).brand();
+const imageMediaSchema = mediaBaseSchema.extend({ type: z.literal("image") });
+const videoMediaSchema = mediaBaseSchema.extend({ type: z.literal("video") });
+const audioMediaSchema = mediaBaseSchema.extend({ type: z.literal("audio") });
+const documentMediaSchema = mediaBaseSchema.extend({ type: z.literal("document") });
+const spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z.literal("spreadsheet") });
+const archiveMediaSchema = mediaBaseSchema.extend({ type: z.literal("archive") });
+const mediaSchema = z.discriminatedUnion("type", [
+	imageMediaSchema,
+	videoMediaSchema,
+	audioMediaSchema,
+	documentMediaSchema,
+	spreadsheetMediaSchema,
+	archiveMediaSchema
+]);
+const persistableMediaBaseSchema = mediaBaseSchema.extend({ identifier: mediaIdentifierSchema });
+z.discriminatedUnion("type", [
+	persistableMediaBaseSchema.extend({ type: z.literal("image") }),
+	persistableMediaBaseSchema.extend({ type: z.literal("video") }),
+	persistableMediaBaseSchema.extend({ type: z.literal("audio") }),
+	persistableMediaBaseSchema.extend({ type: z.literal("document") }),
+	persistableMediaBaseSchema.extend({ type: z.literal("spreadsheet") }),
+	persistableMediaBaseSchema.extend({ type: z.literal("archive") })
+]);
 //#endregion
 //#region ../theme-core/src/palette/schema.ts
-const colourHexString = z$1.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-const paletteColorSchema = z$1.object({
-	name: z$1.string().min(1),
+const colourHexString = z.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+const paletteColorSchema = z.object({
+	name: z.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),
+const paletteMetaSchema = z.object({ mode: z.enum(["light", "dark"]) });
+const paletteSchema = z.object({
+	colors: z.array(paletteColorSchema),
 	meta: paletteMetaSchema
 }).transform((palette, ctx) => {
 	const colors = paletteColorsFromEntries(palette.colors);
@@ -690,7 +737,7 @@ const paletteSchema = z$1.object({
 			code: "custom",
 			message: `Invalid complete palette: ${colors.error.kind}`
 		});
-		return z$1.NEVER;
+		return z.NEVER;
 	}
 	return {
 		colors: paletteColorEntries(colors.colors).map(({ name, hex }) => ({
@@ -721,7 +768,7 @@ const VARIANT_ROLES = [
 * 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").refine((value) => value !== "link" && value !== "tertiary", { message: "Retired button role IDs are not valid variant IDs" });
+const buttonVariantIdSchema = z.string().min(1).max(50).regex(/^[a-z0-9-]+$/, "Button variant IDs may contain lowercase letters, numbers, and hyphens only").refine((value) => value !== "link" && value !== "tertiary", { message: "Retired button role IDs are not valid variant IDs" });
 function parseOpaqueButtonColourToken(value) {
 	const token = parseThemeColorToken(value);
 	if (token === null) return null;
@@ -736,8 +783,8 @@ 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([
+const buttonShadeAmountSchema = z.number().finite().min(0).max(900).multipleOf(100);
+const buttonShadowIntensitySchema = z.enum([
 	"subtle",
 	"medium",
 	"strong"
@@ -749,153 +796,176 @@ const buttonShadowIntensitySchema = z$1.enum([
 * 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()
+const buttonEffectApplicationSchema = z.discriminatedUnion("effectId", [
+	z.strictObject({
+		effectId: z.literal("darken-background"),
+		options: z.strictObject({ amount: buttonShadeAmountSchema.optional() }).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("lighten-background"),
-		options: z$1.strictObject({ amount: buttonShadeAmountSchema.optional() }).optional()
+	z.strictObject({
+		effectId: z.literal("lighten-background"),
+		options: z.strictObject({ amount: buttonShadeAmountSchema.optional() }).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("background-on-hover"),
-		options: z$1.strictObject({ colorToken: opaqueButtonColourTokenSchema.optional() }).optional()
+	z.strictObject({
+		effectId: z.literal("background-on-hover"),
+		options: z.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.strictObject({
+		effectId: z.literal("animated-gradient"),
+		options: z.strictObject({ direction: z.enum(["horizontal", "vertical"]).optional() }).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("drop-shadow"),
-		options: z$1.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
+	z.strictObject({
+		effectId: z.literal("drop-shadow"),
+		options: z.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("inner-shadow"),
-		options: z$1.strictObject({}).optional()
+	z.strictObject({
+		effectId: z.literal("inner-shadow"),
+		options: z.strictObject({}).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("neumorphic-shadow"),
-		options: z$1.strictObject({
-			mode: z$1.enum(["raised", "pressed"]).optional(),
+	z.strictObject({
+		effectId: z.literal("neumorphic-shadow"),
+		options: z.strictObject({
+			mode: z.enum(["raised", "pressed"]).optional(),
 			intensity: buttonShadowIntensitySchema.optional()
 		}).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("retro-3d-shadow"),
-		options: z$1.strictObject({}).optional()
+	z.strictObject({
+		effectId: z.literal("retro-3d-shadow"),
+		options: z.strictObject({}).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("scale-up"),
-		options: z$1.strictObject({ scale: z$1.enum([
+	z.strictObject({
+		effectId: z.literal("scale-up"),
+		options: z.strictObject({ scale: z.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([
+	z.strictObject({
+		effectId: z.literal("scale-down"),
+		options: z.strictObject({ scale: z.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([
+	z.strictObject({
+		effectId: z.literal("lift"),
+		options: z.strictObject({ amount: z.enum([
 			"0.25",
 			"0.5",
 			"1"
 		]).optional() }).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("press-down"),
-		options: z$1.strictObject({}).optional()
+	z.strictObject({
+		effectId: z.literal("press-down"),
+		options: z.strictObject({}).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("pop"),
-		options: z$1.strictObject({ intensity: z$1.enum([
+	z.strictObject({
+		effectId: z.literal("pop"),
+		options: z.strictObject({ intensity: z.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([
+	z.strictObject({
+		effectId: z.literal("border-bottom-grow"),
+		options: z.strictObject({
+			height: z.union([z.literal(1), z.literal(2)]).optional(),
+			origin: z.enum([
 				"left",
 				"center",
 				"right"
 			]).optional()
 		}).optional()
 	}),
-	z$1.strictObject({
-		effectId: z$1.literal("sketchy-border"),
-		options: z$1.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
+	z.strictObject({
+		effectId: z.literal("sketchy-border"),
+		options: z.strictObject({ intensity: buttonShadowIntensitySchema.optional() }).optional()
 	})
 ]);
-const cornerStyleSchema = z$1.enum([
+const cornerStyleSchema = z.enum([
 	"square",
 	"rounded",
 	"pill"
 ]);
-const shadowSizeSchema = z$1.enum([
+const shadowSizeSchema = z.enum([
 	"none",
 	"low",
 	"medium",
 	"high"
 ]);
-const textTransformSchema = z$1.enum([
+const textTransformSchema = z.enum([
 	"none",
 	"uppercase",
 	"lowercase",
 	"capitalize"
 ]);
-const fontWeightSchema = z$1.union([
-	z$1.literal(500),
-	z$1.literal(600),
-	z$1.literal(700)
+const fontWeightSchema = z.union([
+	z.literal(500),
+	z.literal(600),
+	z.literal(700)
 ]);
-const buttonTypographySchema = z$1.enum(["body", "heading"]);
-const letterSpacingSchema = z$1.enum([
+const buttonTypographySchema = z.enum(["body", "heading"]);
+const letterSpacingSchema = z.enum([
 	"tight",
 	"normal",
 	"loose"
 ]);
-const hoverTransformSchema = z$1.enum([
+const hoverTransformSchema = z.enum([
 	"none",
 	"lift",
 	"scale",
 	"press"
 ]);
-z$1.enum(["none", "token"]);
-const buttonPaddingPresetSchema = z$1.enum([
+z.enum(["none", "token"]);
+const buttonPaddingPresetSchema = z.enum([
 	"compact",
 	"default",
 	"spacious"
 ]);
-const gradientStyleSchema = z$1.enum([
+const gradientStyleSchema = z.enum([
 	"linear",
 	"radial",
 	"conic"
 ]);
-const gradientSharpnessSchema = z$1.enum([
+const gradientSharpnessSchema = z.enum([
 	"smooth",
 	"medium",
 	"hard"
 ]);
-const prioritySchema = z$1.union([
-	z$1.literal(1),
-	z$1.literal(2),
-	z$1.literal(3)
+const prioritySchema = z.union([
+	z.literal(1),
+	z.literal(2),
+	z.literal(3)
 ]);
-z$1.enum(VARIANT_ROLES);
-const buttonSizeNameSchema = z$1.enum([
+const variantRoleSchema = z.enum(VARIANT_ROLES);
+const buttonSurfaceFallbackSchema = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("surface-outline") }), z.strictObject({
+	kind: z.literal("variant"),
+	role: variantRoleSchema
+})]);
+const standardButtonSurfacePolicy = {
+	primary: [{ kind: "surface-outline" }],
+	secondary: [{ kind: "surface-outline" }, {
+		kind: "variant",
+		role: "primary"
+	}],
+	outline: [{ kind: "surface-outline" }],
+	ghost: [{ kind: "surface-outline" }],
+	accent: [{ kind: "surface-outline" }, {
+		kind: "variant",
+		role: "primary"
+	}]
+};
+const STANDARD_BUTTON_SURFACE_POLICY = Object.freeze(Object.fromEntries(VARIANT_ROLES.map((role) => [role, Object.freeze([...standardButtonSurfacePolicy[role]])])));
+function createStandardButtonSurfacePolicy() {
+	return Object.fromEntries(VARIANT_ROLES.map((role) => [role, [...STANDARD_BUTTON_SURFACE_POLICY[role]]]));
+}
+const buttonSurfacePolicyShape = Object.fromEntries(VARIANT_ROLES.map((role) => [role, z.array(buttonSurfaceFallbackSchema).max(VARIANT_ROLES.length)]));
+const buttonSurfacePolicySchema = z.strictObject(buttonSurfacePolicyShape);
+const buttonSizeNameSchema = z.enum([
 	"sm",
 	"md",
 	"lg",
@@ -909,13 +979,13 @@ const buttonSizeNameSchema = z$1.enum([
 * 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 paddingShorthandSchema = z.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({
+const buttonSizeConfigSchema = z.object({
 	padding: paddingShorthandSchema,
-	fontSize: z$1.string().optional()
+	fontSize: z.string().optional()
 });
 /**
 * `xl` is optional on the wire so themes persisted before the `xl` size was
@@ -923,7 +993,7 @@ const buttonSizeConfigSchema = z$1.object({
 * 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({
+const buttonSizesSchema = z.object({
 	sm: buttonSizeConfigSchema,
 	md: buttonSizeConfigSchema,
 	lg: buttonSizeConfigSchema,
@@ -934,9 +1004,9 @@ const buttonSizesSchema = z$1.object({
 	lg,
 	xl: xl ?? lg
 }));
-const buttonGlobalSettingsBaseSchema = z$1.strictObject({
+const buttonGlobalSettingsBaseSchema = z.strictObject({
 	cornerStyle: cornerStyleSchema,
-	cornerRadius: z$1.number().min(0).max(24).optional(),
+	cornerRadius: z.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
@@ -948,23 +1018,23 @@ const buttonGlobalSettingsBaseSchema = z$1.strictObject({
 	textTransform: textTransformSchema,
 	fontWeight: fontWeightSchema,
 	typography: buttonTypographySchema.optional(),
-	fontSize: z$1.string().optional(),
+	fontSize: z.string().optional(),
 	letterSpacing: letterSpacingSchema.optional(),
-	italic: z$1.boolean().optional(),
+	italic: z.boolean().optional(),
 	paddingPreset: buttonPaddingPresetSchema.optional(),
 	hoverTransform: hoverTransformSchema,
 	gradientStyle: gradientStyleSchema.optional(),
-	gradientAngle: z$1.number().min(0).max(360).optional(),
+	gradientAngle: z.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()
+const buttonGlobalSettingsSchema = z.discriminatedUnion("hoverColor", [buttonGlobalSettingsBaseSchema.extend({
+	hoverColor: z.literal("none"),
+	hoverColorToken: z.never().optional()
 }), buttonGlobalSettingsBaseSchema.extend({
-	hoverColor: z$1.literal("token"),
+	hoverColor: z.literal("token"),
 	hoverColorToken: opaqueButtonColourTokenSchema
 })]);
-const gradientDirectionSchema$1 = z$1.enum([
+const gradientDirectionSchema$1 = z.enum([
 	"to-r",
 	"to-l",
 	"to-t",
@@ -974,14 +1044,14 @@ const gradientDirectionSchema$1 = z$1.enum([
 	"to-br",
 	"to-bl"
 ]);
-const buttonColourTreatmentSchema = z$1.discriminatedUnion("type", [
-	z$1.strictObject({
-		type: z$1.literal("solid"),
+const buttonColourTreatmentSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("solid"),
 		colorToken: opaqueButtonColourTokenSchema
 	}),
-	z$1.strictObject({
-		type: z$1.literal("gradient"),
-		stops: z$1.array(opaqueButtonColourTokenSchema).min(2).transform((stops) => {
+	z.strictObject({
+		type: z.literal("gradient"),
+		stops: z.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 [
@@ -993,34 +1063,34 @@ const buttonColourTreatmentSchema = z$1.discriminatedUnion("type", [
 		direction: gradientDirectionSchema$1,
 		foregroundToken: opaqueButtonColourTokenSchema
 	}),
-	z$1.strictObject({
-		type: z$1.literal("surface"),
-		role: z$1.literal("link")
+	z.strictObject({
+		type: z.literal("surface"),
+		role: z.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([
+const buttonBorderSchema = z.strictObject({ widthClass: z.string() });
+const buttonVariantAffordanceSchema = z.strictObject({ iconId: z.string().min(1) });
+const variantShadowSchema = z.strictObject({
+	elevation: z.enum([
 		"none",
 		"low",
 		"medium",
 		"high"
 	]),
-	softness: z$1.enum([
+	softness: z.enum([
 		"crisp",
 		"soft",
 		"hard"
 	]).nullable(),
-	position: z$1.enum(["bottom", "bottom-right"]).default("bottom"),
+	position: z.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()
+const variantEffectsSchema = z.strictObject({
+	base: z.array(buttonEffectApplicationSchema).optional(),
+	hover: z.array(buttonEffectApplicationSchema).optional(),
+	active: z.array(buttonEffectApplicationSchema).optional(),
+	focus: z.array(buttonEffectApplicationSchema).optional()
 });
 /**
 * Per-variant size overrides schema — every entry is optional.
@@ -1029,7 +1099,7 @@ const variantEffectsSchema = z$1.strictObject({
 * for that size on this variant. Missing sizes fall through to theme.sizes,
 * then system defaults.
 */
-const variantSizeOverridesSchema = z$1.object({
+const variantSizeOverridesSchema = z.object({
 	sm: buttonSizeConfigSchema.optional(),
 	md: buttonSizeConfigSchema.optional(),
 	lg: buttonSizeConfigSchema.optional(),
@@ -1041,14 +1111,14 @@ const variantSizeOverridesSchema = z$1.object({
 * default (e.g. link-style variants declaring zero horizontal padding at
 * every size).
 */
-const buttonVariantSchema = z$1.strictObject({
+const buttonVariantSchema = z.strictObject({
 	id: buttonVariantIdSchema,
-	name: z$1.string().min(1).max(20),
-	enabled: z$1.boolean(),
+	name: z.string().min(1).max(20),
+	enabled: z.boolean(),
 	priority: prioritySchema,
 	background: buttonBackgroundSchema,
 	/** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-	borderRadius: z$1.string().optional(),
+	borderRadius: z.string().optional(),
 	shadow: variantShadowSchema.optional(),
 	border: buttonBorderSchema.optional(),
 	hoverBackgroundToken: opaqueButtonColourTokenSchema.optional(),
@@ -1056,10 +1126,11 @@ const buttonVariantSchema = z$1.strictObject({
 	sizes: variantSizeOverridesSchema.optional(),
 	affordance: buttonVariantAffordanceSchema.optional()
 });
-const buttonSystemSchema = z$1.strictObject({
+const buttonSystemSchema = z.strictObject({
 	global: buttonGlobalSettingsSchema,
-	variants: z$1.array(buttonVariantSchema).min(1).max(6),
-	sizes: buttonSizesSchema.optional()
+	variants: z.array(buttonVariantSchema).min(1).max(6),
+	sizes: buttonSizesSchema.optional(),
+	surfacePolicy: buttonSurfacePolicySchema.optional()
 }).superRefine((system, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	system.variants.forEach((variant, index) => {
@@ -1244,7 +1315,7 @@ function getButtonEffectPolicy(effectId) {
 	return Object.prototype.hasOwnProperty.call(BUTTON_EFFECT_POLICIES, effectId) ? BUTTON_EFFECT_POLICIES[effectId] : null;
 }
 //#endregion
-//#region ../theme-core/src/buttons/resolveButtonColourStates.ts
+//#region ../theme-core/src/buttons/buttonColourContract.ts
 const BUTTON_VISUAL_STATES = [
 	"base",
 	"hover",
@@ -1259,6 +1330,38 @@ const BUTTON_CONTRAST_POLICY = {
 	alphaBackgrounds: "reject-without-known-surface",
 	disabled: "retain-full-colour-contract"
 };
+function validateButtonSurfaceContrast(input) {
+	const ratio = contrastRatio(input.buttonPaint, input.surfaceHex);
+	return ratio >= BUTTON_CONTRAST_POLICY.nonTextMinimumRatio ? { ok: true } : {
+		ok: false,
+		error: {
+			tag: "insufficient_surface_contrast",
+			variantId: input.variantId,
+			state: input.state,
+			buttonPaint: input.buttonPaint,
+			surface: input.surfaceHex,
+			ratio,
+			requiredRatio: BUTTON_CONTRAST_POLICY.nonTextMinimumRatio
+		}
+	};
+}
+function validateButtonTextContrast(input) {
+	const ratio = contrastRatio(input.backgroundHex, input.foregroundHex);
+	return ratio >= BUTTON_CONTRAST_POLICY.textMinimumRatio ? { ok: true } : {
+		ok: false,
+		error: {
+			tag: "insufficient_contrast",
+			variantId: input.variantId,
+			state: input.state,
+			background: input.background,
+			foreground: input.foreground,
+			ratio,
+			requiredRatio: BUTTON_CONTRAST_POLICY.textMinimumRatio
+		}
+	};
+}
+//#endregion
+//#region ../theme-core/src/buttons/resolveButtonColourStates.ts
 function compileButtonColourStates(input) {
 	const baseTransition = applyColourEffects({
 		variantId: input.variant.id,
@@ -1298,7 +1401,9 @@ function compileButtonColourStates(input) {
 			variantId: input.variant.id,
 			state,
 			treatment: stateTreatments[state],
-			palette: input.palette
+			palette: input.palette,
+			surface: input.surface,
+			hasBoundary: input.variant.border !== void 0
 		});
 		if (!result.ok) return result;
 		resolved[state] = result.colour;
@@ -1366,22 +1471,42 @@ function applyColourEffects(input) {
 function resolveTreatment(input) {
 	const treatment = input.treatment;
 	switch (treatment.type) {
-		case "surface": return {
-			ok: true,
-			colour: {
-				kind: "surface",
-				role: treatment.role,
-				backgroundCss: "transparent",
-				foregroundCss: surfaceForegroundValue(treatment.role)
+		case "surface":
+			if (input.surface) {
+				const foreground = validateButtonTextContrast({
+					...input,
+					background: "surface",
+					backgroundHex: input.surface.backgroundHex,
+					foreground: "surface-foreground",
+					foregroundHex: input.surface.foregroundHex
+				});
+				if (!foreground.ok) return foreground;
 			}
-		};
+			if (input.surface && input.hasBoundary) {
+				const boundary = validateButtonSurfaceContrast({
+					...input,
+					buttonPaint: input.surface.foregroundHex,
+					surfaceHex: input.surface.backgroundHex
+				});
+				if (!boundary.ok) return boundary;
+			}
+			return {
+				ok: true,
+				colour: {
+					kind: "surface",
+					role: treatment.role,
+					backgroundCss: "transparent",
+					foregroundCss: input.surface?.foregroundCss ?? surfaceForegroundValue(treatment.role)
+				}
+			};
 		case "solid": return resolveSolid(input, treatment.colorToken);
 		case "gradient": return resolveGradient(input, treatment);
 	}
 }
 function resolveFocusIndicator(colour) {
 	switch (colour.kind) {
-		case "solid": return {
+		case "solid":
+		case "known-solid": return {
 			kind: "two-tone",
 			innerCss: colour.foregroundCss,
 			outerCss: colour.backgroundCss,
@@ -1415,7 +1540,7 @@ function resolveSolid(input, backgroundToken) {
 			foregroundToken
 		}
 	};
-	const contrast = validateContrast({
+	const contrast = validateButtonTextContrast({
 		...input,
 		background: backgroundToken,
 		backgroundHex: backgroundHex.hex,
@@ -1423,6 +1548,14 @@ function resolveSolid(input, backgroundToken) {
 		foregroundHex
 	});
 	if (!contrast.ok) return contrast;
+	if (input.surface) {
+		const boundary = validateButtonSurfaceContrast({
+			...input,
+			buttonPaint: backgroundHex.hex,
+			surfaceHex: input.surface.backgroundHex
+		});
+		if (!boundary.ok) return boundary;
+	}
 	return {
 		ok: true,
 		colour: {
@@ -1452,7 +1585,7 @@ function resolveGradient(input, treatment) {
 		for (let sample = 0; sample <= BUTTON_CONTRAST_POLICY.gradientSamplesPerSegment; sample += 1) {
 			const position = sample / BUTTON_CONTRAST_POLICY.gradientSamplesPerSegment;
 			const sampleHex = interpolateHex(start, end, position);
-			const contrast = validateContrast({
+			const contrast = validateButtonTextContrast({
 				...input,
 				background: `${startToken}→${endToken}@${position.toFixed(2)}`,
 				backgroundHex: sampleHex,
@@ -1460,6 +1593,14 @@ function resolveGradient(input, treatment) {
 				foregroundHex: foregroundHex.hex
 			});
 			if (!contrast.ok) return contrast;
+			if (input.surface) {
+				const boundary = validateButtonSurfaceContrast({
+					...input,
+					buttonPaint: sampleHex,
+					surfaceHex: input.surface.backgroundHex
+				});
+				if (!boundary.ok) return boundary;
+			}
 		}
 	}
 	const direction = GRADIENT_DIRECTION_MAP[treatment.direction] ?? "to right";
@@ -1489,21 +1630,6 @@ function paletteHex(input, token) {
 		}
 	};
 }
-function validateContrast(input) {
-	const ratio = contrastRatio(input.backgroundHex, input.foregroundHex);
-	return ratio >= BUTTON_CONTRAST_POLICY.textMinimumRatio ? { ok: true } : {
-		ok: false,
-		error: {
-			tag: "insufficient_contrast",
-			variantId: input.variantId,
-			state: input.state,
-			background: input.background,
-			foreground: input.foreground,
-			ratio,
-			requiredRatio: BUTTON_CONTRAST_POLICY.textMinimumRatio
-		}
-	};
-}
 function tokenCss(token) {
 	return `rgb(var(--tb-${token}))`;
 }
@@ -1610,7 +1736,14 @@ function parseThemeForPersistence(value) {
 			issues: parsed.error.issues
 		}
 	};
-	const theme = parsed.data;
+	const parsedTheme = parsed.data;
+	const theme = parsedTheme.buttons && !parsedTheme.buttons.surfacePolicy ? {
+		...parsedTheme,
+		buttons: {
+			...parsedTheme.buttons,
+			surfacePolicy: createStandardButtonSurfacePolicy()
+		}
+	} : parsedTheme;
 	if (!theme.buttons) return {
 		ok: true,
 		value: theme
@@ -1689,6 +1822,14 @@ function shadeBackgroundEffect(config) {
 		}
 	};
 }
+//#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.string();
 buttonSizeNameSchema.options;
 //#endregion
 //#region ../theme-core/src/buttons/styles/domain.ts
@@ -1732,6 +1873,7 @@ function resolveButtonStyleRecipe(recipe, parameters) {
 	const buttonSystem = {
 		global: definition.global,
 		variants: PUBLIC_BUTTON_ROLES.map((role) => roles[role]),
+		surfacePolicy: definition.surfacePolicy ?? createStandardButtonSurfacePolicy(),
 		...definition.sizes ? { sizes: definition.sizes } : {}
 	};
 	const parsedButtonSystem = buttonSystemSchema.safeParse(buttonSystem);
@@ -1792,15 +1934,15 @@ const BUTTON_STYLE_IDS = [
 	"ornate-ritual",
 	"quiet-arrow"
 ];
-const quietArrowParametersSchema = z$1.object({ secondaryTreatment: z$1.enum(["outlined", "solid-accent"]) }).strict();
-const emptyParametersSchema$1 = z$1.object({}).strict();
+const quietArrowParametersSchema = z.object({ secondaryTreatment: z.enum(["outlined", "solid-accent"]) }).strict();
+const emptyParametersSchema$1 = z.object({}).strict();
 function selectionBranch(styleId, parameters) {
-	return z$1.object({
-		styleId: z$1.literal(styleId),
+	return z.object({
+		styleId: z.literal(styleId),
 		parameters
 	}).strict();
 }
-z$1.discriminatedUnion("styleId", [
+z.discriminatedUnion("styleId", [
 	selectionBranch("soft-pill", emptyParametersSchema$1),
 	selectionBranch("earth-pill", emptyParametersSchema$1),
 	selectionBranch("confident-chip", emptyParametersSchema$1),
@@ -1945,7 +2087,7 @@ const quietArrowRecipe = defineButtonStyleRecipe({
 });
 //#endregion
 //#region ../theme-core/src/buttons/styles/recipes/defineStaticButtonStyleRecipe.ts
-const emptyParametersSchema = z$1.object({}).strict();
+const emptyParametersSchema = z.object({}).strict();
 function defineStaticButtonStyleRecipe(input) {
 	const system = normalizeSystem(input.system);
 	return defineButtonStyleRecipe({
@@ -3311,7 +3453,27 @@ function presetCategory(recipe) {
 //#region ../theme-core/src/cards/types.ts
 const cardVariantRoleValues = ["default", "alternative"];
 const boxlessCardVariantValue = "none";
-const cardSpacingSchema = z$1.enum([
+const openCardRoleValue = "open";
+/**
+* The roles a site style implements with an actual card variant. `none` is
+* deliberately absent: it is a role value only, never a variant.
+*/
+const surfaceCardRoleValues = [...cardVariantRoleValues, openCardRoleValue];
+/**
+* The closed card-role vocabulary Looks and blocks address cards by — this is
+* `BoxStylesCardVariant` widened with `open`, not a parallel enum.
+*
+* - `none`        — no site-style card surface; the block's own composition and
+*                   the author's own card fields govern the item. This is *not*
+*                   a promise of visible boxlessness: a block whose base class
+*                   draws a border still draws one. It says the Look is not
+*                   asking the site style for a card.
+* - `open`        — boxless but marked (a rule or accent edge, no enclosing box)
+* - `default`     — the site's quiet everyday card
+* - `alternative` — the statement card carrying the site's personality
+*/
+const cardRoleValues = [...surfaceCardRoleValues, boxlessCardVariantValue];
+const cardSpacingSchema = z.enum([
 	"none",
 	"compact",
 	"cozy",
@@ -3319,7 +3481,18 @@ const cardSpacingSchema = z$1.enum([
 	"comfortable",
 	"spacious"
 ]);
-const gradientDirectionSchema = z$1.enum([
+/** Per-axis padding, for boxless cards whose inline padding differs from block. */
+const cardSpacingAxesSchema = z.object({
+	block: cardSpacingSchema,
+	inline: cardSpacingSchema
+});
+/**
+* A card's content padding: one value for both axes, or one per axis. Two
+* fields would let a variant say both and leave the reader to guess, so this is
+* a union — the legacy `spacingAxes` key is lifted into it on parse.
+*/
+const cardSpacingValueSchema = z.union([cardSpacingSchema, cardSpacingAxesSchema]);
+const gradientDirectionSchema = z.enum([
 	"to-r",
 	"to-l",
 	"to-t",
@@ -3329,85 +3502,138 @@ const gradientDirectionSchema = z$1.enum([
 	"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"),
+z.enum(cardVariantRoleValues);
+const surfaceCardRoleSchema = z.enum(surfaceCardRoleValues);
+const cardRoleSchema = z.enum(cardRoleValues);
+/**
+* Historical name for the role vocabulary as it reaches box styles. Widened to
+* the full `CardRole` set — old values keep parsing, `open` now parses too.
+*/
+const boxStylesCardVariantSchema = cardRoleSchema;
+const PRIORITY_ROLE_INFERENCE = {
+	1: "default",
+	2: "alternative"
+};
+/**
+* Role inference for legacy card systems authored before variants carried a
+* `role`. Priority 1 is the everyday card, priority 2 the statement card —
+* which is how variants are surfaced today. `open` is never inferred: a site
+* style has to opt into it.
+*/
+function inferCardVariantRoleFromPriority(priority) {
+	return PRIORITY_ROLE_INFERENCE[priority] ?? null;
+}
+const cardBackgroundSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("solid"),
 		colorToken: themeColorTokenSchema
 	}),
-	z$1.object({
-		type: z$1.literal("gradient"),
+	z.object({
+		type: z.literal("gradient"),
 		fromToken: themeColorTokenSchema,
 		toToken: themeColorTokenSchema,
 		direction: gradientDirectionSchema
 	}),
-	z$1.object({ type: z$1.literal("transparent") })
+	z.object({ type: z.literal("transparent") })
 ]);
-const cardBorderSchema = z$1.object({
-	widthClass: z$1.string(),
+const cardBorderSchema = z.object({
+	widthClass: z.string(),
 	colorToken: themeColorTokenSchema
 });
 /** Per-corner radius value. `expressive` is a large block-radius multiple. */
-const cardCornerValueSchema = z$1.enum([
+const cardCornerValueSchema = z.enum([
 	"square",
 	"soft",
 	"rounded",
 	"pill",
 	"expressive"
 ]);
+const cardEdgeSchema = z.enum([
+	"left",
+	"top",
+	"right",
+	"bottom"
+]);
 /**
-* A single accented card edge (e.g. a left accent bar). When set, it replaces
-* the full `border` so the card reads as edge-accented rather than outlined.
+* Legacy single accented card edge (e.g. a left accent bar). Persisted and
+* curated data may still carry it; it lifts into a one-element `decorations`
+* list at the parse boundary and has no representation after that.
 */
-const cardAccentEdgeSchema = z$1.object({
-	edge: z$1.enum([
-		"left",
-		"top",
-		"right",
-		"bottom"
-	]),
+const cardAccentEdgeSchema = z.object({
+	edge: cardEdgeSchema,
 	colorToken: themeColorTokenSchema,
-	width: z$1.enum([
+	width: z.enum([
 		"thin",
 		"medium",
 		"thick",
 		"heavy"
 	])
 });
-const cardCornerRadiiSchema = z$1.object({
+/** `hairline` (1px) is the widening the boxless `open` role needs. */
+const cardEdgeRuleWidthSchema = z.enum([
+	"hairline",
+	"thin",
+	"medium",
+	"thick",
+	"heavy"
+]);
+const cardEdgeRuleLengthSchema = z.enum(["full", "short"]);
+const cardEdgeRuleAlignSchema = z.enum([
+	"start",
+	"center",
+	"end"
+]);
+/**
+* Decorations are edge rules today. The alias exists so the list can grow into
+* a discriminated union without every call site changing.
+*/
+const cardDecorationSchema = z.object({
+	edge: cardEdgeSchema,
+	colorToken: themeColorTokenSchema,
+	width: cardEdgeRuleWidthSchema,
+	/** Defaults to `full`. */
+	length: cardEdgeRuleLengthSchema.optional(),
+	/** Where a `short` rule sits along its edge. Defaults to `start`. */
+	align: cardEdgeRuleAlignSchema.optional(),
+	/** Opacity applied to `colorToken`, 0–1. Scoped here, not on the token. */
+	alpha: z.number().min(0).max(1).optional()
+});
+const cardDecorationsSchema = z.array(cardDecorationSchema).max(2);
+const cardCornerRadiiSchema = z.object({
 	topLeft: cardCornerValueSchema.optional(),
 	topRight: cardCornerValueSchema.optional(),
 	bottomLeft: cardCornerValueSchema.optional(),
 	bottomRight: cardCornerValueSchema.optional()
 });
-const cardVariantSchema = z$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)
+const cardVariantInputSchema = z.object({
+	id: z.string(),
+	name: z.string().min(1).max(20),
+	enabled: z.boolean(),
+	priority: z.union([
+		z.literal(1),
+		z.literal(2),
+		z.literal(3)
 	]),
+	role: surfaceCardRoleSchema.optional(),
 	background: cardBackgroundSchema,
-	spacing: cardSpacingSchema,
+	spacing: cardSpacingValueSchema,
+	spacingAxes: cardSpacingAxesSchema.optional(),
 	foregroundToken: themeColorTokenSchema.optional(),
-	shadow: z$1.object({
-		elevation: z$1.enum([
+	shadow: z.object({
+		elevation: z.enum([
 			"none",
 			"low",
 			"medium",
 			"high"
 		]),
-		softness: z$1.enum([
+		softness: z.enum([
 			"crisp",
 			"soft",
 			"hard"
 		]).nullable(),
-		position: z$1.enum(["bottom", "bottom-right"]).default("bottom")
+		position: z.enum(["bottom", "bottom-right"]).default("bottom")
 	}).optional(),
-	corners: z$1.enum([
+	corners: z.enum([
 		"square",
 		"soft",
 		"rounded",
@@ -3415,15 +3641,97 @@ const cardVariantSchema = z$1.object({
 	]).optional(),
 	cornerRadii: cardCornerRadiiSchema.optional(),
 	border: cardBorderSchema.optional(),
+	decorations: cardDecorationsSchema.optional(),
 	accentEdge: cardAccentEdgeSchema.optional()
 });
-const cardSystemSchema = z$1.object({ variants: z$1.array(cardVariantSchema).min(1).max(3) });
+/**
+* Lift a legacy `accentEdge` into the decoration list. The old emitter reset
+* `border: 0` implicitly whenever an accent edge was present; conversion drops
+* the border instead, so the output is unchanged and the data says so.
+*/
+function normalizeLegacyAccentEdge(variant) {
+	const { accentEdge, ...rest } = normalizeLegacySpacingAxes(variant);
+	if (!accentEdge) return rest;
+	const { border: _droppedByAccentEdgeReset, ...withoutBorder } = rest;
+	return {
+		...withoutBorder,
+		decorations: [{
+			...accentEdge,
+			length: "full"
+		}]
+	};
+}
+/**
+* Lift a legacy `spacingAxes` into `spacing`. It always won over the flat value
+* when both were set, so the lift preserves the emitted padding exactly.
+*/
+function normalizeLegacySpacingAxes(variant) {
+	const { spacingAxes, ...rest } = variant;
+	return spacingAxes ? {
+		...rest,
+		spacing: spacingAxes
+	} : variant;
+}
+function validateSingleDecorationSource(variant, ctx) {
+	if (!variant.accentEdge || !variant.decorations) return;
+	ctx.addIssue({
+		code: "custom",
+		path: ["decorations"],
+		message: "A card variant carries either the legacy `accentEdge` or `decorations`, never both."
+	});
+}
+const cardVariantSchema = cardVariantInputSchema.superRefine(validateSingleDecorationSource).transform(normalizeLegacyAccentEdge);
+/**
+* Fill in roles for legacy systems whose variants declare none. Inference is
+* collision-tolerant on purpose: first claimant wins and a later variant that
+* would infer a taken role simply gets no role. Legacy data is not obliged to
+* be well-formed, and a card system that fails to parse takes the whole theme
+* down with it.
+*/
+function withInferredRoles(variants) {
+	const claimed = new Set(variants.flatMap((variant) => variant.role ? [variant.role] : []));
+	return variants.map((variant) => {
+		if (variant.role) return variant;
+		const inferred = inferCardVariantRoleFromPriority(variant.priority);
+		if (!inferred || claimed.has(inferred)) return variant;
+		claimed.add(inferred);
+		return {
+			...variant,
+			role: inferred
+		};
+	});
+}
+/**
+* Only *declared* roles are validated — a site style saying "these two
+* variants are both the default card" is an authoring error worth rejecting.
+*/
+function validateUniqueDeclaredCardVariantRoles(system, ctx) {
+	const declared = /* @__PURE__ */ new Set();
+	system.variants.forEach((variant, index) => {
+		const role = variant.role;
+		if (!role) return;
+		if (declared.has(role)) {
+			ctx.addIssue({
+				code: "custom",
+				path: [
+					"variants",
+					index,
+					"role"
+				],
+				message: `Card role "${role}" is already implemented by another variant.`
+			});
+			return;
+		}
+		declared.add(role);
+	});
+}
+const cardSystemSchema = z.object({ variants: z.array(cardVariantSchema).min(1).max(3) }).superRefine(validateUniqueDeclaredCardVariantRoles).transform((system) => ({ variants: withInferredRoles(system.variants) }));
 //#endregion
 //#region ../theme-core/src/accordions/types.ts
 /**
 * Accordion icon styles for expand/collapse indicators
 */
-const accordionIconSchema = z$1.enum([
+const accordionIconSchema = z.enum([
 	"plus-minus",
 	"chevron",
 	"caret",
@@ -3434,12 +3742,12 @@ const accordionIconSchema = z$1.enum([
 * 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"),
+const accordionSystemSchema = z.object({
+	background: z.object({
+		type: z.literal("solid"),
 		colorToken: themeColorTokenSchema
 	}).nullable(),
-	spacing: z$1.enum([
+	spacing: z.enum([
 		"none",
 		"compact",
 		"cozy",
@@ -3447,84 +3755,84 @@ const accordionSystemSchema = z$1.object({
 		"comfortable",
 		"spacious"
 	]),
-	corners: z$1.enum([
+	corners: z.enum([
 		"square",
 		"soft",
 		"rounded",
 		"pill"
 	]).nullable(),
-	border: z$1.object({
-		widthClass: z$1.string(),
+	border: z.object({
+		widthClass: z.string(),
 		colorToken: themeColorTokenSchema
 	}).nullable(),
-	shadow: z$1.object({
-		elevation: z$1.enum([
+	shadow: z.object({
+		elevation: z.enum([
 			"none",
 			"low",
 			"medium",
 			"high"
 		]),
-		softness: z$1.enum([
+		softness: z.enum([
 			"soft",
 			"crisp",
 			"hard"
 		]).nullable(),
-		position: z$1.enum(["bottom", "bottom-right"])
+		position: z.enum(["bottom", "bottom-right"])
 	}).nullable(),
-	icon: z$1.object({
+	icon: z.object({
 		style: accordionIconSchema,
-		position: z$1.enum(["left", "right"]),
-		size: z$1.enum([
+		position: z.enum(["left", "right"]),
+		size: z.enum([
 			"sm",
 			"md",
 			"lg"
 		]),
 		colorToken: themeColorTokenSchema.optional()
 	}),
-	trigger: z$1.object({
+	trigger: z.object({
 		textColorToken: themeColorTokenSchema,
-		fontWeight: z$1.enum([
+		fontWeight: z.enum([
 			"regular",
 			"medium",
 			"semibold",
 			"bold"
 		]).nullable(),
-		fontFamily: z$1.enum(["body", "heading"]).optional(),
-		fontScale: z$1.enum([
+		fontFamily: z.enum(["body", "heading"]).optional(),
+		fontScale: z.enum([
 			"body",
 			"md",
 			"lg"
 		]).optional(),
-		letterSpacing: z$1.enum([
+		letterSpacing: z.enum([
 			"normal",
 			"tight",
 			"wide"
 		]).optional(),
-		textTransform: z$1.enum(["none", "uppercase"]).optional()
+		textTransform: z.enum(["none", "uppercase"]).optional()
 	}),
-	hover: z$1.object({
+	hover: z.object({
 		backgroundColorToken: themeColorTokenSchema.optional(),
 		textColorToken: themeColorTokenSchema.optional(),
 		borderColorToken: themeColorTokenSchema.optional()
 	}),
-	openState: z$1.object({
+	openState: z.object({
 		backgroundColorToken: themeColorTokenSchema.optional(),
 		triggerColorToken: themeColorTokenSchema.optional(),
-		accent: z$1.object({
-			edge: z$1.enum([
+		accent: z.object({
+			edge: z.enum([
 				"left",
 				"top",
 				"bottom"
 			]),
 			colorToken: themeColorTokenSchema,
-			thickness: z$1.enum([
+			thickness: z.enum([
 				"thin",
 				"medium",
 				"thick"
 			])
 		}).optional()
 	}).optional(),
-	content: z$1.object({ textColorToken: themeColorTokenSchema })
+	content: z.object({ textColorToken: themeColorTokenSchema })
 });
 //#endregion
 //#region ../theme-core/src/inputs/types.ts
@@ -3538,80 +3846,80 @@ const accordionSystemSchema = z$1.object({
 *
 * 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"),
+const inputSystemSchema = z.object({
+	base: z.object({
+		background: z.union([z.object({
+			type: z.literal("solid"),
 			colorToken: themeColorTokenSchema
-		}), z$1.object({ type: z$1.literal("transparent") })]),
+		}), z.object({ type: z.literal("transparent") })]),
 		textColorToken: themeColorTokenSchema,
-		border: z$1.object({
-			widthClass: z$1.string(),
+		border: z.object({
+			widthClass: z.string(),
 			colorToken: themeColorTokenSchema,
-			style: z$1.enum(["all", "underline"]).optional()
+			style: z.enum(["all", "underline"]).optional()
 		}),
-		corners: z$1.enum([
+		corners: z.enum([
 			"square",
 			"soft",
 			"rounded",
 			"pill"
 		]).nullable(),
-		shadow: z$1.object({
-			elevation: z$1.enum([
+		shadow: z.object({
+			elevation: z.enum([
 				"none",
 				"low",
 				"medium"
 			]),
-			softness: z$1.enum([
+			softness: z.enum([
 				"soft",
 				"crisp",
 				"hard"
 			]).nullable()
 		}).nullable(),
-		spacing: z$1.enum([
+		spacing: z.enum([
 			"compact",
 			"cozy",
 			"medium",
 			"comfortable"
 		]),
-		fontSize: z$1.enum([
+		fontSize: z.enum([
 			"sm",
 			"base",
 			"lg"
 		])
 	}),
-	label: z$1.object({
+	label: z.object({
 		textColorToken: themeColorTokenSchema,
-		fontWeight: z$1.enum([
+		fontWeight: z.enum([
 			"regular",
 			"medium",
 			"semibold",
 			"bold",
 			"black"
 		]),
-		fontSize: z$1.enum([
+		fontSize: z.enum([
 			"2xs",
 			"xs",
 			"sm",
 			"base"
 		]),
-		textTransform: z$1.enum([
+		textTransform: z.enum([
 			"none",
 			"uppercase",
 			"lowercase",
 			"capitalize"
 		]).optional(),
-		letterSpacing: z$1.enum([
+		letterSpacing: z.enum([
 			"normal",
 			"wide",
 			"wider",
 			"widest"
 		]).optional(),
-		opacity: z$1.number().min(.2).max(1).optional()
+		opacity: z.number().min(.2).max(1).optional()
 	}),
-	focus: z$1.object({
+	focus: z.object({
 		ringColorToken: themeColorTokenSchema,
-		ringWidth: z$1.enum([
+		ringWidth: z.enum([
 			"0",
 			"1",
 			"2",
@@ -3619,14 +3927,14 @@ const inputSystemSchema = z$1.object({
 		]),
 		borderColorToken: themeColorTokenSchema.optional()
 	}),
-	error: z$1.object({
+	error: z.object({
 		borderColorToken: themeColorTokenSchema,
 		textColorToken: themeColorTokenSchema
 	}),
-	disabled: z$1.object({
+	disabled: z.object({
 		backgroundColorToken: themeColorTokenSchema,
 		textColorToken: themeColorTokenSchema,
-		opacity: z$1.number().min(.3).max(.7)
+		opacity: z.number().min(.3).max(.7)
 	})
 });
 //#endregion
@@ -3637,9 +3945,9 @@ const inputSystemSchema = z$1.object({
 /**
 * Gradient color stop
 */
-const gradientStopSchema = z$1.object({
+const gradientStopSchema = z.object({
 	color: themeColorTokenSchema,
-	position: z$1.number().min(0).max(100)
+	position: z.number().min(0).max(100)
 });
 /**
 * Radial gradient shape. Optional; defaults to `circle` (the historical shape)
@@ -3648,7 +3956,7 @@ const gradientStopSchema = z$1.object({
 * 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"]);
+const radialGradientShapeSchema = z.enum(["circle", "ellipse"]);
 /**
 * Gradient configuration.
 *
@@ -3659,16 +3967,16 @@ const radialGradientShapeSchema = z$1.enum(["circle", "ellipse"]);
 *   - radial: optional `shape` (circle/ellipse) + `position`
 *   - conic:  optional `angle` (from-angle, degrees) + `position`
 */
-const gradientConfigSchema = z$1.object({
-	type: z$1.enum([
+const gradientConfigSchema = z.object({
+	type: z.enum([
 		"linear",
 		"radial",
 		"conic"
 	]).default("linear"),
-	angle: z$1.number().min(0).max(360).optional(),
+	angle: z.number().min(0).max(360).optional(),
 	shape: radialGradientShapeSchema.optional(),
-	position: z$1.string().optional(),
-	stops: z$1.array(gradientStopSchema).min(2)
+	position: z.string().optional(),
+	stops: z.array(gradientStopSchema).min(2)
 });
 //#endregion
 //#region ../theme-core/src/interactive/baseSchema.ts
@@ -3680,46 +3988,46 @@ const gradientConfigSchema = z$1.object({
 /**
 * Typography settings shared by buttons and nav links
 */
-const interactiveTypographySchema = z$1.object({
+const interactiveTypographySchema = z.object({
 	/** Font family source */
-	typography: z$1.enum(["body", "heading"]).default("body"),
+	typography: z.enum(["body", "heading"]).default("body"),
 	/** Font weight */
-	fontWeight: z$1.enum([
+	fontWeight: z.enum([
 		"regular",
 		"medium",
 		"semibold",
 		"bold"
 	]).default("medium"),
 	/** Text transform */
-	textTransform: z$1.enum([
+	textTransform: z.enum([
 		"none",
 		"uppercase",
 		"capitalize"
 	]).default("none"),
 	/** Italic style */
-	italic: z$1.boolean().default(false)
+	italic: z.boolean().default(false)
 });
 /**
 * Effect application reference (shared between buttons and nav)
 */
-const effectApplicationSchema = z$1.object({
+const effectApplicationSchema = z.object({
 	/** Effect preset ID */
-	effectId: z$1.string(),
+	effectId: z.string(),
 	/** User-provided customization options */
-	options: z$1.record(z$1.string(), z$1.any()).optional()
+	options: z.record(z.string(), z.any()).optional()
 });
 /**
 * Effect composition by state (shared pattern)
 */
-const effectCompositionSchema = z$1.object({
+const effectCompositionSchema = z.object({
 	/** Effects always applied */
-	base: z$1.array(effectApplicationSchema).optional(),
+	base: z.array(effectApplicationSchema).optional(),
 	/** Effects applied on hover */
-	hover: z$1.array(effectApplicationSchema).optional(),
+	hover: z.array(effectApplicationSchema).optional(),
 	/** Effects applied on active/pressed */
-	active: z$1.array(effectApplicationSchema).optional(),
+	active: z.array(effectApplicationSchema).optional(),
 	/** Effects applied on focus */
-	focus: z$1.array(effectApplicationSchema).optional()
+	focus: z.array(effectApplicationSchema).optional()
 });
 //#endregion
 //#region ../theme-core/src/navigation/types.ts
@@ -3731,7 +4039,7 @@ const effectCompositionSchema = z$1.object({
 /**
 * Padding preset options for nav links
 */
-const navLinkPaddingSchema = z$1.enum([
+const navLinkPaddingSchema = z.enum([
 	"none",
 	"compact",
 	"default"
@@ -3740,7 +4048,7 @@ const navLinkPaddingSchema = z$1.enum([
 * Horizontal padding override for nav links.
 * When set, overrides only the horizontal component of the `padding` preset.
 */
-const navLinkPaddingXSchema = z$1.enum([
+const navLinkPaddingXSchema = z.enum([
 	"none",
 	"tight",
 	"compact",
@@ -3751,7 +4059,7 @@ const navLinkPaddingXSchema = z$1.enum([
 /**
 * Border radius options for nav links
 */
-const navLinkBorderRadiusSchema = z$1.enum([
+const navLinkBorderRadiusSchema = z.enum([
 	"none",
 	"sm",
 	"md",
@@ -3760,7 +4068,7 @@ const navLinkBorderRadiusSchema = z$1.enum([
 /**
 * Typography size options for nav links.
 */
-const navLinkTextSizeSchema = z$1.enum([
+const navLinkTextSizeSchema = z.enum([
 	"xs",
 	"sm",
 	"base",
@@ -3770,7 +4078,7 @@ const navLinkTextSizeSchema = z$1.enum([
 /**
 * Letter spacing options for nav links.
 */
-const navLinkLetterSpacingSchema = z$1.enum([
+const navLinkLetterSpacingSchema = z.enum([
 	"normal",
 	"wide",
 	"wider",
@@ -3779,15 +4087,15 @@ const navLinkLetterSpacingSchema = z$1.enum([
 /**
 * Optional legibility aid for nav text that floats over uncertain imagery or color.
 */
-const navLinkContrastTreatmentSchema = z$1.enum(["none", "soft-glow"]);
+const navLinkContrastTreatmentSchema = z.enum(["none", "soft-glow"]);
 /**
 * Nav link style schema
 *
 * Extends interactive typography base with nav-specific settings.
 */
-const navLinkStyleSchema = z$1.object({
+const navLinkStyleSchema = z.object({
 	/** Display name for the style */
-	name: z$1.string().min(1).max(30).optional(),
+	name: z.string().min(1).max(30).optional(),
 	/** Typography settings (inherited from interactive base) */
 	...interactiveTypographySchema.shape,
 	/** Text color token */
@@ -3872,7 +4180,7 @@ function containsForbiddenSelector(selector) {
 /**
 * 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" });
+const selectorSchema = z.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.
 */
@@ -3890,31 +4198,31 @@ function containsJavascriptUrl(value) {
 * 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" });
+const declarationValueSchema = z.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);
+const declarationsSchema = z.record(z.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"),
+const customCssRuleSchema = z.object({
+	id: z.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") });
+const blockCustomCssRuleSchema = customCssRuleSchema.extend({ blockKind: z.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();
+const customCssRulesSchema = z.array(customCssRuleSchema).optional();
 /**
 * Array of block-specific CSS rules.
 */
-const blockCustomCssRulesSchema = z$1.array(blockCustomCssRuleSchema).optional();
+const blockCustomCssRulesSchema = z.array(blockCustomCssRuleSchema).optional();
 //#endregion
 //#region ../theme-core/src/customCss/atRuleValidation.ts
 /**
@@ -3932,9 +4240,9 @@ 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");
+const ruleIdSchema = z.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({
+const nestedRuleSchema = z.object({
 	selector: selectorSchema,
 	declarations: declarationsSchema
 });
@@ -3951,46 +4259,46 @@ function isValidKeyframeOffset(offset) {
 	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%" });
+const keyframeOffsetSchema = z.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)" });
+const animationNameSchema = z.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({
+const keyframeSchema = z.object({
 	offset: keyframeOffsetSchema,
 	declarations: declarationsSchema
 });
 /** @keyframes rule schema */
-const keyframesAtRuleSchema = z$1.object({
+const keyframesAtRuleSchema = z.object({
 	id: ruleIdSchema,
-	type: z$1.literal("keyframes"),
+	type: z.literal("keyframes"),
 	name: animationNameSchema,
-	frames: z$1.array(keyframeSchema).min(1, "At least one keyframe is required")
+	frames: z.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" });
+const fontFaceDeclarationsSchema = z.record(z.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({
+const fontFaceAtRuleSchema = z.object({
 	id: ruleIdSchema,
-	type: z$1.literal("font-face"),
+	type: z.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");
+const mediaQuerySchema = z.string().min(1, "Media query is required").max(200, "Media query too long");
 /** @media rule schema */
-const mediaAtRuleSchema = z$1.object({
+const mediaAtRuleSchema = z.object({
 	id: ruleIdSchema,
-	type: z$1.literal("media"),
+	type: z.literal("media"),
 	query: mediaQuerySchema,
-	rules: z$1.array(nestedRuleSchema).min(1, "At least one rule is required")
+	rules: z.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");
+const supportsConditionSchema = z.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
 /** @supports rule schema */
-const supportsAtRuleSchema = z$1.object({
+const supportsAtRuleSchema = z.object({
 	id: ruleIdSchema,
-	type: z$1.literal("supports"),
+	type: z.literal("supports"),
 	condition: supportsConditionSchema,
-	rules: z$1.array(nestedRuleSchema).min(1, "At least one rule is required")
+	rules: z.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 /**
 * Check if raw CSS contains blocked at-rules.
@@ -3999,17 +4307,17 @@ 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.` });
+const rawCssSchema = z.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({
+const rawAtRuleSchema = z.object({
 	id: ruleIdSchema,
-	type: z$1.literal("raw"),
+	type: z.literal("raw"),
 	css: rawCssSchema
 });
 /**
 * Discriminated union schema for all at-rule types.
 */
-const customCssAtRuleSchema = z$1.discriminatedUnion("type", [
+const customCssAtRuleSchema = z.discriminatedUnion("type", [
 	keyframesAtRuleSchema,
 	fontFaceAtRuleSchema,
 	mediaAtRuleSchema,
@@ -4019,7 +4327,7 @@ const customCssAtRuleSchema = z$1.discriminatedUnion("type", [
 /**
 * Array of at-rules for theme-level styling.
 */
-const customCssAtRulesSchema = z$1.array(customCssAtRuleSchema).optional();
+const customCssAtRulesSchema = z.array(customCssAtRuleSchema).optional();
 //#endregion
 //#region ../theme-core/src/shared/componentStyles.ts
 /**
@@ -4037,22 +4345,22 @@ const customCssAtRulesSchema = z$1.array(customCssAtRuleSchema).optional();
 * 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([
+const componentBorderSchema = z.object({
+	width: z.enum([
 		"none",
 		"hairline",
 		"thin",
 		"medium",
 		"thick"
 	]).default("none"),
-	style: z$1.enum(["solid", "dashed"]).default("solid"),
+	style: z.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([
+const componentShadowSchema = z.object({ elevation: z.enum([
 	"none",
 	"sm",
 	"md",
@@ -4147,43 +4455,43 @@ const logoDensityValues = [
 	"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()
+const logoContainsTextSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("contains-text"),
+		confidence: z.enum(logoTextConfidenceValues),
+		text: z.string().trim().min(1).max(200).optional()
 	}),
-	z$1.object({
-		kind: z$1.literal("no-text"),
-		confidence: z$1.enum(logoTextConfidenceValues)
+	z.object({
+		kind: z.literal("no-text"),
+		confidence: z.enum(logoTextConfidenceValues)
 	}),
-	z$1.object({
-		kind: z$1.literal("unknown"),
-		reason: z$1.enum([
+	z.object({
+		kind: z.literal("unknown"),
+		reason: z.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"])
+const logoAnalysisSourceSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }),
+	z.object({
+		kind: z.literal("deterministic"),
+		reason: z.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.object({
+		kind: z.literal("llm"),
+		model: z.literal("gpt-5.4-mini"),
+		analyzedAt: z.string().trim().min(1).max(80).optional()
 	}),
-	z$1.object({ kind: z$1.literal("manual-override") })
+	z.object({ kind: z.literal("manual-override") })
 ]);
-z$1.object({
-	shape: z$1.enum(logoAssetShapeValues),
+z.object({
+	shape: z.enum(logoAssetShapeValues),
 	containsText: logoContainsTextSchema,
-	kind: z$1.enum(logoKindValues),
-	density: z$1.enum(logoDensityValues),
+	kind: z.enum(logoKindValues),
+	density: z.enum(logoDensityValues),
 	source: logoAnalysisSourceSchema
 });
 const brandDisplayModeValues = [
@@ -4231,13 +4539,57 @@ new Set(themeV2NormalEditorRawStyleFieldNames);
 const pageDesignEditorBackgroundOverrideOwner = "page-design-editor";
 const siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 //#endregion
-//#region ../theme-core/src/utils/tokenOrColor.ts
+//#region ../theme-core/src/header/legacyHeaderVariant.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`.
+* The header variants the system actually renders.
+*
+* Each one has a layout row in the site-header block and a paint target in
+* `paintTargets.ts`. This is the canonical list: the block transform's variant
+* class allowlist and the AI theme generator's enum both derive from it, so
+* they cannot drift.
+*/
+const headerVariantValues = [
+	"classic",
+	"centered",
+	"floating"
+];
+z.enum(headerVariantValues);
+/**
+* Header variant spellings that were once authorable but no longer name a
+* layout of their own, and the variant they read as now.
+*
+* `transparent` was an overlay header with no CSS of its own: everything it
+* did (transparent root background, overlay content flow) is what `floating`
+* already does, and it had zero persisted usage in production or locally when
+* it was retired. It survives here as a one-boundary alias so a theme authored
+* against the old vocabulary still parses.
+*
+* This matters because the theme schema is strict and has no per-field
+* `.catch()`: an out-of-enum variant fails `themeSchema.safeParse` for the
+* *whole* theme, which silently swaps the site's theme for
+* `modernMinimalTheme`. Aliasing here keeps that from happening.
+*/
+const legacyHeaderVariants = { transparent: "floating" };
+const legacyHeaderVariantValues = Object.keys(legacyHeaderVariants);
+/**
+* The header variant boundary for themes that go through `themeSchema`:
+* canonical variants pass through, legacy spellings normalize to the variant
+* they meant, everything else fails the parse.
+*
+* Deliberately an enum plus a transform rather than a `z.preprocess`, so the
+* schema's *input* type stays an accurate union (the legacy spelling is still
+* accepted on the wire) instead of widening to `unknown`. `SdkThemeWire` in
+* `@riverbankcms/api` is `z.input<typeof themeSchema>`, so a widened input here
+* would leak straight into a public type.
+*
+* Not every read of a persisted theme goes through the schema:
+* `resolveRuntimeTheme` in
+* `apps/dashboard/src/server/services/sites/runtimeSiteResponse.ts` returns the
+* raw database JSON asserted as `Theme` with no parse, so a theme still
+* carrying a legacy spelling reaches the theme editor un-aliased. That gap
+* predates this alias and is harmless while persisted usage is zero.
 */
-const tokenOrCssColorValueSchema = z$1.string();
+const headerVariantWithLegacyAliasSchema = z.enum([...headerVariantValues, ...legacyHeaderVariantValues]).transform((value) => value in legacyHeaderVariants ? legacyHeaderVariants[value] : value);
 const BREAKPOINT_LG = 1024;
 const BREAKPOINT_XL = 1280;
 const BREAKPOINT_LG_DOWN = BREAKPOINT_LG - 1;
@@ -4262,14 +4614,14 @@ mqDown(640);
 mqDown(768);
 //#endregion
 //#region ../theme-core/src/header/scrollTreatment.ts
-const headerScrollTreatmentSchema = z$1.discriminatedUnion("kind", [z$1.object({
-	kind: z$1.literal("contrast-glass"),
-	backgroundTone: z$1.enum(["light", "dark"])
+const headerScrollTreatmentSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("contrast-glass"),
+	backgroundTone: z.enum(["light", "dark"])
 })]).optional();
 //#endregion
 //#region ../theme-core/src/header/containerSchema.ts
-const headerContainerSchema = z$1.object({
-	rounded: z$1.enum([
+const headerContainerSchema = z.object({
+	rounded: z.enum([
 		"none",
 		"sm",
 		"md",
@@ -4277,77 +4629,146 @@ const headerContainerSchema = z$1.object({
 		"xl",
 		"2xl"
 	]).default("xl"),
-	border: z$1.boolean().default(true),
-	shadow: z$1.boolean().default(true),
-	padding: z$1.enum([
+	border: z.boolean().default(true),
+	shadow: z.boolean().default(true),
+	padding: z.enum([
 		"sm",
 		"md",
 		"lg"
 	]).default("md"),
-	tint: z$1.string().nullable().optional(),
-	opacity: z$1.number().min(0).max(1).default(.12)
+	tint: z.string().nullable().optional(),
+	opacity: z.number().min(0).max(1).default(.12)
 }).optional();
-const headerInteractionPaletteSchema = z$1.enum([
+const headerInteractionPaletteSchema = z.enum([
 	"primary",
 	"secondary",
 	"accent"
 ]);
 //#endregion
+//#region ../theme-core/src/boxBackgroundSchema.ts
+const boxBackgroundOverlaySchema = z.preprocess(normalizeAuthoringOpacity, z.discriminatedUnion("type", [
+	z.object({ type: z.literal("none") }),
+	z.object({
+		type: z.literal("color"),
+		color: tokenOrCssColorValueSchema.nullable().optional(),
+		opacity: z.number().min(0).max(1).nullable().optional()
+	}),
+	z.object({
+		type: z.literal("gradient"),
+		gradient: z.string().nullable().optional(),
+		opacity: z.number().min(0).max(1).nullable().optional()
+	})
+]));
+const commonSchema = z.object({
+	contentOwner: z.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
+	textColor: tokenOrCssColorValueSchema.nullable().optional(),
+	headingColor: tokenOrCssColorValueSchema.nullable().optional(),
+	linkColor: tokenOrCssColorValueSchema.nullable().optional(),
+	supportingColor: tokenOrCssColorValueSchema.nullable().optional()
+});
+const mediaPresentationSchema = commonSchema.extend({
+	opacity: z.preprocess(normalizeOpacity, z.number().min(0).max(1).nullable()).optional(),
+	objectFit: z.enum([
+		"fill",
+		"fit",
+		"original",
+		"custom"
+	]).nullable().optional(),
+	scale: z.string().nullable().optional(),
+	position: z.string().nullable().optional(),
+	motion: z.enum(["static", "fixed-frame"]).nullable().optional(),
+	overflow: z.boolean().nullable().optional(),
+	overlay: boxBackgroundOverlaySchema.nullable().optional()
+});
+const boxBackgroundSchema = z.discriminatedUnion("type", [
+	commonSchema.extend({
+		type: z.literal("color"),
+		color: tokenOrCssColorValueSchema.nullable().optional()
+	}),
+	commonSchema.extend({
+		type: z.literal("gradient"),
+		gradient: z.string().nullable().optional(),
+		gradientPresetId: z.string().min(1).nullable().optional()
+	}),
+	mediaPresentationSchema.extend({
+		type: z.literal("image"),
+		image: imageMediaSchema.nullable().optional()
+	}),
+	mediaPresentationSchema.extend({
+		type: z.literal("video"),
+		image: videoMediaSchema.nullable().optional(),
+		showVideoOnMobile: z.boolean().nullable().optional()
+	})
+]);
+function normalizeAuthoringOpacity(value) {
+	if (!isRecord(value)) return value;
+	return {
+		...value,
+		opacity: normalizeOpacity(value.opacity)
+	};
+}
+function normalizeOpacity(value) {
+	return typeof value === "number" && value > 1 && value <= 100 ? value / 100 : value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region ../theme-core/src/schema.ts
-const axesSchema = z$1.object({
-	tone: z$1.enum([
+const axesSchema = z.object({
+	tone: z.enum([
 		"minimal",
 		"classic",
 		"bold"
 	]),
-	energy: z$1.enum(["calm", "vibrant"]),
-	density: z$1.enum([
+	energy: z.enum(["calm", "vibrant"]),
+	density: z.enum([
 		"airy",
 		"regular",
 		"compact"
 	]),
-	mediaBias: z$1.enum([
+	mediaBias: z.enum([
 		"text",
 		"media",
 		"mixed"
 	]),
-	conversionBias: z$1.enum([
+	conversionBias: z.enum([
 		"low",
 		"med",
 		"high"
 	]),
-	motion: z$1.enum([
+	motion: z.enum([
 		"subtle",
 		"standard",
 		"expressive"
 	])
 });
-const typographyStyleSchema = z$1.object({
-	family: z$1.string().min(1),
-	weight: z$1.enum([
+const typographyStyleSchema = z.object({
+	family: z.string().min(1),
+	weight: z.enum([
 		"light",
 		"regular",
 		"medium",
 		"semibold",
 		"bold"
 	]),
-	letterSpacing: z$1.enum([
+	letterSpacing: z.enum([
 		"tight",
 		"normal",
 		"loose"
 	]),
-	lineHeight: z$1.enum([
+	lineHeight: z.enum([
 		"normal",
 		"relaxed",
 		"loose"
 	])
 });
-const bodyTypographyStyleSchema = typographyStyleSchema.extend({ size: z$1.enum([
+const bodyTypographyStyleSchema = typographyStyleSchema.extend({ size: z.enum([
 	"md",
 	"lg",
 	"xl"
 ]) });
-const headingSizeSchema = z$1.enum([
+const headingSizeSchema = z.enum([
 	"xs",
 	"sm",
 	"md",
@@ -4355,68 +4776,68 @@ const headingSizeSchema = z$1.enum([
 	"xl",
 	"2xl"
 ]);
-const headingTypographyOverridesSchema = z$1.object({
-	weight: z$1.enum([
+const headingTypographyOverridesSchema = z.object({
+	weight: z.enum([
 		"light",
 		"regular",
 		"medium",
 		"semibold",
 		"bold"
 	]).nullable().optional(),
-	letterSpacing: z$1.enum([
+	letterSpacing: z.enum([
 		"tight",
 		"normal",
 		"loose"
 	]).nullable().optional(),
 	size: headingSizeSchema.nullable().optional(),
-	lineHeight: z$1.enum([
+	lineHeight: z.enum([
 		"tight",
 		"snug",
 		"normal",
 		"relaxed",
 		"loose"
 	]).nullable().optional(),
-	italic: z$1.boolean().nullable().optional(),
+	italic: z.boolean().nullable().optional(),
 	colorToken: themeColorTokenSchema.nullable().optional()
 });
 const headingTypographyStyleSchema = typographyStyleSchema.extend({
-	case: z$1.enum([
+	case: z.enum([
 		"uppercase",
 		"normal",
 		"smallCaps"
 	]).nullable(),
-	italic: z$1.boolean().nullable(),
+	italic: z.boolean().nullable(),
 	colorToken: themeColorTokenSchema.nullable().optional()
 });
-const proseLinkUnderlineStyleSchema = z$1.enum([
+const proseLinkUnderlineStyleSchema = z.enum([
 	"solid",
 	"dotted",
 	"dashed"
 ]);
-const proseLinkUnderlineThicknessSchema = z$1.enum([
+const proseLinkUnderlineThicknessSchema = z.enum([
 	"auto",
 	"fromFont",
 	"thin",
 	"medium",
 	"thick"
 ]);
-const proseLinkUnderlineOffsetSchema = z$1.enum([
+const proseLinkUnderlineOffsetSchema = z.enum([
 	"auto",
 	"tight",
 	"normal",
 	"loose"
 ]);
-const proseLinkStyleSchema = z$1.object({
+const proseLinkStyleSchema = z.object({
 	colorToken: themeColorTokenSchema.optional(),
 	hoverColorToken: themeColorTokenSchema.optional(),
-	underline: z$1.boolean().optional(),
+	underline: z.boolean().optional(),
 	decorationColorToken: themeColorTokenSchema.optional(),
 	hoverDecorationColorToken: themeColorTokenSchema.optional(),
 	underlineStyle: proseLinkUnderlineStyleSchema.optional(),
 	underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
 	underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-const semanticSpacingSchema = z$1.enum([
+const semanticSpacingSchema = z.enum([
 	"none",
 	"compact",
 	"cozy",
@@ -4424,7 +4845,7 @@ const semanticSpacingSchema = z$1.enum([
 	"comfortable",
 	"spacious"
 ]);
-const boxRoundedSchema = z$1.enum([
+const boxRoundedSchema = z.enum([
 	"none",
 	"sm",
 	"md",
@@ -4433,82 +4854,45 @@ const boxRoundedSchema = z$1.enum([
 	"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.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.object({ family: z.literal("none") });
+const visibleHeadingDecorationSchema = z.object({
+	family: z.enum(visibleHeadingDecorationFamilyValues),
+	colorToken: z.enum(headingDecorationColorTokenValues).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.union([noHeadingDecorationSchema, visibleHeadingDecorationSchema]);
+const headingDecorationOverrideSchema = z.union([z.enum(headingDecorationOverrideValues), z.literal("on").transform(() => "site-default")]);
+const accordionIconTreatmentSchema = z.object({
+	iconSet: z.enum(accordionIconSetValues),
+	colorToken: z.enum(accordionIconColorTokenValues),
+	openColorToken: z.enum(accordionIconColorTokenValues).optional(),
+	motion: z.enum(accordionIconMotionValues)
 });
-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({
+const sectionStylesOverrideSchema = z.object({
 	background: boxBackgroundSchema.nullable().optional(),
 	spacing: semanticSpacingSchema.nullable().optional(),
-	minHeight: z$1.enum([
+	minHeight: z.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(),
+	tileTreatment: z.enum(tileTreatmentValues).nullable().optional(),
+	eventListTreatment: z.enum(eventListTreatmentValues).nullable().optional(),
+	eyebrowTreatment: z.enum(eyebrowTreatmentValues).nullable().optional(),
 	headingDecoration: headingDecorationSchema.nullable().optional(),
 	headingDecorationOverride: headingDecorationOverrideSchema.nullable().optional(),
 	accordionIconTreatment: accordionIconTreatmentSchema.nullable().optional()
 });
-const containerStylesOverrideSchema = z$1.object({
+const containerStylesOverrideSchema = z.object({
 	background: boxBackgroundSchema.nullable().optional(),
 	spacing: semanticSpacingSchema.nullable().optional(),
-	raised: z$1.boolean().nullable().optional(),
+	raised: z.boolean().nullable().optional(),
 	rounded: boxRoundedSchema.nullable().optional(),
-	fullWidth: z$1.boolean().nullable().optional()
+	fullWidth: z.boolean().nullable().optional()
 });
-const cardBorderOverrideSchema = z$1.object({
-	enabled: z$1.boolean().nullable().optional(),
-	width: z$1.enum([
+const cardBorderOverrideSchema = z.object({
+	enabled: z.boolean().nullable().optional(),
+	width: z.enum([
 		"none",
 		"1",
 		"2",
@@ -4516,32 +4900,25 @@ const cardBorderOverrideSchema = z$1.object({
 	]).nullable().optional(),
 	colorToken: themeColorTokenSchema.nullable().optional()
 });
-const cardStylesOverrideSchema = z$1.object({
+const cardStylesOverrideSchema = z.object({
 	background: boxBackgroundSchema.nullable().optional(),
 	border: cardBorderOverrideSchema.nullable().optional(),
 	spacing: semanticSpacingSchema.nullable().optional(),
-	raised: z$1.boolean().nullable().optional(),
+	raised: z.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(),
+	role: cardRoleSchema.nullable().optional(),
 	cardVariant: boxStylesCardVariantSchema.nullable().optional()
 });
-const blockStyleOverridesSchema = z$1.object({
+const blockStyleOverridesSchema = z.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(),
+const blockThemeOverrideSchema = z.object({
+	typography: z.object({ proseLinkStyle: proseLinkStyleSchema.optional() }).optional(),
 	styles: blockStyleOverridesSchema.optional()
 });
-const typographyScaleSchema = z$1.enum([
+const typographyScaleSchema = z.enum([
 	"compact",
 	"balanced",
 	"spacious",
@@ -4549,31 +4926,31 @@ const typographyScaleSchema = z$1.enum([
 	"majorThird",
 	"perfectFourth"
 ]);
-const eyebrowTypographyStyleSchema = z$1.object({
-	family: z$1.string().min(1),
-	size: z$1.enum([
+const eyebrowTypographyStyleSchema = z.object({
+	family: z.string().min(1),
+	size: z.enum([
 		"sm",
 		"md",
 		"lg"
 	]).optional(),
-	weight: z$1.enum([
+	weight: z.enum([
 		"light",
 		"regular",
 		"medium",
 		"semibold",
 		"bold"
 	]).optional(),
-	letterSpacing: z$1.enum([
+	letterSpacing: z.enum([
 		"tight",
 		"normal",
 		"loose",
 		"wide"
 	]).optional(),
-	case: z$1.enum(["uppercase", "normal"]).optional()
+	case: z.enum(["uppercase", "normal"]).optional()
 });
-const typographySchema = z$1.object({
+const typographySchema = z.object({
 	body: bodyTypographyStyleSchema,
-	headings: z$1.object({
+	headings: z.object({
 		default: headingTypographyStyleSchema,
 		h1: headingTypographyOverridesSchema,
 		h2: headingTypographyOverridesSchema,
@@ -4586,105 +4963,75 @@ const typographySchema = z$1.object({
 	proseLinkStyle: proseLinkStyleSchema.optional(),
 	eyebrow: eyebrowTypographyStyleSchema.optional()
 });
-const spaceSchema = z$1.enum([
+const spaceSchema = z.enum([
 	"comfortable",
 	"standard",
 	"dense"
 ]);
-const corners = z$1.enum([
+const corners = z.enum([
 	"square",
 	"soft",
 	"rounded",
 	"pill"
 ]);
-const shadow = z$1.object({
-	elevation: z$1.enum([
+const shadow = z.object({
+	elevation: z.enum([
 		"none",
 		"low",
 		"medium",
 		"high"
 	]),
-	softness: z$1.enum([
+	softness: z.enum([
 		"crisp",
 		"soft",
 		"hard"
 	]).nullable(),
-	position: z$1.enum(["bottom", "bottom-right"]).default("bottom"),
+	position: z.enum(["bottom", "bottom-right"]).default("bottom"),
 	colorToken: themeColorTokenSchema.optional()
 });
-const border = z$1.object({
-	width: z$1.enum([
+const border = z.object({
+	width: z.enum([
 		"none",
 		"hairline",
 		"thin",
 		"thick"
 	]),
-	style: z$1.enum(["solid", "dashed"])
+	style: z.enum(["solid", "dashed"])
 });
-const motion = z$1.object({
-	level: z$1.enum([
+const motion = z.object({
+	level: z.enum([
 		"off",
 		"low",
 		"medium",
 		"high"
 	]),
-	easing: z$1.enum([
+	easing: z.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"
-	]),
+z.object({ shape: corners });
+const inputStyle = z.object({
 	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([
+	border: z.enum([
 		"subtle",
 		"defined",
 		"underline"
 	]),
-	focus: z$1.enum([
+	focus: z.enum([
 		"glow",
 		"ring",
 		"underline"
 	]),
-	label: z$1.enum(["inside", "above"])
+	label: z.enum(["inside", "above"])
 });
-const headerVariant = z$1.enum([
-	"classic",
-	"centered",
-	"transparent",
-	"floating"
-]);
-const headerPositioning = z$1.enum([
+const headerPositioning = z.enum([
 	"static",
 	"sticky",
 	"fixed"
 ]);
-const headerNavStyle = z$1.enum([
+const headerNavStyle = z.enum([
 	"minimal",
 	"underline",
 	"underline-grow",
@@ -4693,59 +5040,59 @@ const headerNavStyle = z$1.enum([
 	"frosted",
 	"solid"
 ]);
-const navFontWeight = z$1.enum([
+const navFontWeight = z.enum([
 	"regular",
 	"medium",
 	"semibold",
 	"bold"
 ]);
-const headerMaxWidth = z$1.enum(["container", "full"]);
-const headerBarFrame = z$1.enum(["full-bleed", "inset-shell"]);
-const headerBorderSchema = componentBorderSchema.extend({ position: z$1.enum([
+const headerMaxWidth = z.enum(["container", "full"]);
+const headerBarFrame = z.enum(["full-bleed", "inset-shell"]);
+const headerBorderSchema = componentBorderSchema.extend({ position: z.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([
+const logoStyleSchema = z.object({
+	fontFamily: z.enum(["heading", "body"]).default("heading"),
+	letterSpacing: z.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()
+	gradient: z.boolean().default(false),
+	brandDisplay: z.enum(brandDisplayModeValues).optional(),
+	size: z.enum(logoSizePolicyValues).optional(),
+	accommodation: z.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([
+const headerLogoTextSchema = z.object({
+	mobileWrapLines: z.union([z.literal(1), z.literal(2)]).optional(),
+	mobileMaxWidth: z.enum([
 		"xs",
 		"sm",
 		"md"
 	]).optional(),
-	hideOnShrink: z$1.boolean().optional()
+	hideOnShrink: z.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)
+const navEffectsSchema = z.object({
+	underlineGradient: z.boolean().default(false),
+	glow: z.boolean().default(false),
+	glowColor: z.string().optional(),
+	neumorphic: z.boolean().default(false)
 }).optional();
-const dropdownStyleSchema = z$1.object({
+const dropdownStyleSchema = z.object({
 	background: themeColorTokenSchema.default("surface"),
 	textColor: themeColorTokenSchema.default("text"),
 	borderColor: themeColorTokenSchema.nullable().default("border"),
-	shadow: z$1.enum([
+	shadow: z.enum([
 		"none",
 		"sm",
 		"md",
 		"lg"
 	]).default("md"),
-	borderRadius: z$1.enum([
+	borderRadius: z.enum([
 		"none",
 		"sm",
 		"md",
@@ -4753,23 +5100,23 @@ const dropdownStyleSchema = z$1.object({
 	]).default("md"),
 	hoverBackground: themeColorTokenSchema.nullable().optional(),
 	hoverTextColor: themeColorTokenSchema.nullable().optional(),
-	textTransform: z$1.enum([
+	textTransform: z.enum([
 		"none",
 		"uppercase",
 		"capitalize"
 	]).default("none"),
-	letterSpacing: z$1.enum([
+	letterSpacing: z.enum([
 		"normal",
 		"wide",
 		"wider"
 	]).default("normal"),
-	fontWeight: z$1.enum([
+	fontWeight: z.enum([
 		"regular",
 		"medium",
 		"semibold",
 		"bold"
 	]).optional(),
-	textSize: z$1.enum([
+	textSize: z.enum([
 		"xs",
 		"sm",
 		"base",
@@ -4780,7 +5127,7 @@ const dropdownStyleSchema = z$1.object({
 * CTA button gap (left margin) for desktop header.
 * Controls the spacing between nav links and the CTA button.
 */
-const headerCtaGapSchema = z$1.enum([
+const headerCtaGapSchema = z.enum([
 	"none",
 	"tight",
 	"compact",
@@ -4788,7 +5135,7 @@ const headerCtaGapSchema = z$1.enum([
 	"relaxed",
 	"spacious"
 ]);
-const headerCtaTreatmentSchema = z$1.enum([
+const headerCtaTreatmentSchema = z.enum([
 	"default",
 	"primary",
 	"secondary",
@@ -4796,35 +5143,35 @@ const headerCtaTreatmentSchema = z$1.enum([
 	"outline",
 	"ghost"
 ]);
-const navContainerSchema = z$1.object({
-	type: z$1.enum([
+const navContainerSchema = z.object({
+	type: z.enum([
 		"none",
 		"pill",
 		"glass"
 	]).default("none"),
-	tint: z$1.string().nullable().optional(),
-	opacity: z$1.number().min(0).max(1).default(.15)
+	tint: z.string().nullable().optional(),
+	opacity: z.number().min(0).max(1).default(.15)
 }).default({
 	type: "none",
 	tint: null,
 	opacity: .15
 });
-const headerBackgroundSchema = z$1.object({
-	type: z$1.enum([
+const headerBackgroundSchema = z.object({
+	type: z.enum([
 		"color",
 		"gradient",
 		"image"
 	]),
-	contentOwner: z$1.literal(siteChromeBackgroundOverrideOwner).optional(),
+	contentOwner: z.literal(siteChromeBackgroundOverrideOwner).optional(),
 	color: tokenOrCssColorValueSchema.nullable().optional(),
 	gradient: gradientConfigSchema.nullable().optional(),
 	image: mediaSchema.nullable().optional(),
 	textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-const headerSchema = z$1.object({
-	variant: headerVariant,
+const headerSchema = z.object({
+	variant: headerVariantWithLegacyAliasSchema,
 	positioning: headerPositioning,
-	shrinkOnScroll: z$1.boolean(),
+	shrinkOnScroll: z.boolean(),
 	maxWidth: headerMaxWidth,
 	barFrame: headerBarFrame.optional(),
 	scrollTreatment: headerScrollTreatmentSchema,
@@ -4837,11 +5184,10 @@ const headerSchema = z$1.object({
 	navStyle: headerNavStyle,
 	navColor: themeColorTokenSchema.nullable().optional(),
 	navWeight: navFontWeight.default("medium"),
-	navFontRole: z$1.enum(["body", "heading"]).optional(),
-	navTypography: z$1.enum(["body", "heading"]).optional(),
+	navFontRole: z.enum(["body", "heading"]).optional(),
 	navTextSize: navLinkStyleSchema.shape.textSize,
 	interactionPalette: headerInteractionPaletteSchema.optional(),
-	navPlacement: z$1.enum(["end", "center"]).optional(),
+	navPlacement: z.enum(["end", "center"]).optional(),
 	container: headerContainerSchema,
 	border: headerBorderSchema,
 	shadow: componentShadowSchema.optional(),
@@ -4852,47 +5198,33 @@ const headerSchema = z$1.object({
 	navLinkStyle: navLinkStyleSchema.optional(),
 	ctaGap: headerCtaGapSchema.optional(),
 	ctaTreatment: headerCtaTreatmentSchema.optional(),
-	ctaVariant: z$1.string().min(1).optional(),
+	ctaVariant: z.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([
+});
+const footerVariant = z.enum([
 	"simple",
 	"columns",
 	"split"
 ]);
-const footerMaxWidth = z$1.enum(["container", "full"]);
-const footerMode = z$1.enum([
+const footerMaxWidth = z.enum(["container", "full"]);
+const footerMode = z.enum([
 	"default",
 	"blocks",
 	"default+blocks",
 	"none"
 ]);
-const footerNavLayoutMode = z$1.enum([
+const footerNavLayoutMode = z.enum([
 	"stack",
 	"inline",
 	"inline-wrap"
 ]);
-const footerNavLayoutAlign = z$1.enum([
+const footerNavLayoutAlign = z.enum([
 	"start",
 	"center",
 	"end",
 	"space-between"
 ]);
-const footerSpacing = z$1.enum([
+const footerSpacing = z.enum([
 	"none",
 	"tight",
 	"compact",
@@ -4900,45 +5232,45 @@ const footerSpacing = z$1.enum([
 	"relaxed",
 	"spacious"
 ]);
-const footerLogoPlacement = z$1.enum([
+const footerLogoPlacement = z.enum([
 	"left",
 	"right",
 	"above",
 	"below"
 ]);
-const footerLogoSize = z$1.enum([
+const footerLogoSize = z.enum([
 	"sm",
 	"md",
 	"lg",
 	"xl"
 ]);
-const footerLogoMaxHeight = z$1.enum([
+const footerLogoMaxHeight = z.enum([
 	"sm",
 	"md",
 	"lg",
 	"xl"
 ]);
-const footerBottomTextLinkStyleSchema = z$1.object({
+const footerBottomTextLinkStyleSchema = z.object({
 	colorToken: themeColorTokenSchema.optional(),
 	hoverColorToken: themeColorTokenSchema.nullable().optional(),
 	decorationColorToken: themeColorTokenSchema.nullable().optional(),
-	underline: z$1.boolean().optional()
+	underline: z.boolean().optional()
 });
-const footerBottomBarSchema = z$1.object({
-	enabled: z$1.boolean().optional(),
-	fullBleed: z$1.boolean().optional(),
+const footerBottomBarSchema = z.object({
+	enabled: z.boolean().optional(),
+	fullBleed: z.boolean().optional(),
 	background: headerBackgroundSchema.optional(),
 	textColor: themeColorTokenSchema.nullable().optional(),
-	textAlign: z$1.enum([
+	textAlign: z.enum([
 		"left",
 		"center",
 		"right"
 	]).optional(),
 	paddingY: footerSpacing.optional(),
 	paddingX: footerSpacing.optional(),
-	borderTop: z$1.object({
+	borderTop: z.object({
 		colorToken: themeColorTokenSchema.nullable().optional(),
-		width: z$1.enum([
+		width: z.enum([
 			"none",
 			"thin",
 			"medium",
@@ -4946,26 +5278,26 @@ const footerBottomBarSchema = z$1.object({
 		]).optional()
 	}).optional()
 });
-const footerNavLayoutSchema = z$1.object({
+const footerNavLayoutSchema = z.object({
 	layout: footerNavLayoutMode.optional(),
 	align: footerNavLayoutAlign.optional(),
 	gapX: footerSpacing.optional(),
 	gapY: footerSpacing.optional(),
-	columns: z$1.number().int().min(1).max(6).optional()
+	columns: z.number().int().min(1).max(6).optional()
 });
-const footerLogoSchema = z$1.object({
-	showLogo: z$1.boolean().default(true),
-	showLogoText: z$1.boolean().optional(),
+const footerLogoSchema = z.object({
+	showLogo: z.boolean().default(true),
+	showLogoText: z.boolean().optional(),
 	placement: footerLogoPlacement.optional(),
 	size: footerLogoSize.optional(),
 	maxHeight: footerLogoMaxHeight.optional(),
-	align: z$1.enum([
+	align: z.enum([
 		"start",
 		"center",
 		"end"
 	]).optional()
 });
-const footerSchema = z$1.object({
+const footerSchema = z.object({
 	/**
 	* SDK-only footer rendering mode.
 	*
@@ -4974,7 +5306,7 @@ const footerSchema = z$1.object({
 	mode: footerMode.optional(),
 	variant: footerVariant,
 	maxWidth: footerMaxWidth,
-	showLogoText: z$1.boolean().optional(),
+	showLogoText: z.boolean().optional(),
 	background: headerBackgroundSchema.default({
 		type: "color",
 		color: "surface"
@@ -4988,18 +5320,18 @@ const footerSchema = z$1.object({
 	logo: footerLogoSchema.optional(),
 	bottomBar: footerBottomBarSchema.optional()
 });
-const containerPaddingPresetSchema = z$1.enum([
+const containerPaddingPresetSchema = z.enum([
 	"tight",
 	"compact",
 	"default",
 	"relaxed"
 ]);
-const layoutSchema = z$1.object({ containerPadding: z$1.object({
+const layoutSchema = z.object({ containerPadding: z.object({
 	mobile: containerPaddingPresetSchema.optional(),
 	tablet: containerPaddingPresetSchema.optional(),
 	desktop: containerPaddingPresetSchema.optional()
 }).optional() }).optional();
-const heroTypographySizeSchema = z$1.enum([
+const heroTypographySizeSchema = z.enum([
 	"sm",
 	"base",
 	"lg",
@@ -5011,19 +5343,19 @@ const heroTypographySizeSchema = z$1.enum([
 	"6xl",
 	"editorial"
 ]);
-const heroTypographyLineHeightSchema = z$1.enum([
+const heroTypographyLineHeightSchema = z.enum([
 	"tight",
 	"snug",
 	"normal",
 	"relaxed"
 ]);
-const heroResponsiveTypographySchema = z$1.object({
+const heroResponsiveTypographySchema = z.object({
 	headlineSize: heroTypographySizeSchema.optional(),
 	headlineLineHeight: heroTypographyLineHeightSchema.optional(),
 	subheadlineSize: heroTypographySizeSchema.optional(),
 	subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-const heroTypographySchema = z$1.object({
+const heroTypographySchema = z.object({
 	headlineSize: heroTypographySizeSchema.optional(),
 	headlineLineHeight: heroTypographyLineHeightSchema.optional(),
 	subheadlineSize: heroTypographySizeSchema.optional(),
@@ -5032,21 +5364,21 @@ const heroTypographySchema = z$1.object({
 	microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
 	microSubheadlineSize: heroTypographySizeSchema.optional(),
 	microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-	responsive: z$1.object({
+	responsive: z.object({
 		tablet: heroResponsiveTypographySchema.optional(),
 		mobile: heroResponsiveTypographySchema.optional()
 	}).optional()
 });
-const heroSchema = z$1.object({ typography: heroTypographySchema.optional() }).optional();
-const bodyTextIntroTypographySizeSchema = z$1.enum(["default", "editorial"]);
-const bodyTextSchema = z$1.object({ intro: z$1.object({
+const heroSchema = z.object({ typography: heroTypographySchema.optional() }).optional();
+const bodyTextIntroTypographySizeSchema = z.enum(["default", "editorial"]);
+const bodyTextSchema = z.object({ intro: z.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()
+const gradientsSchema = z.object({
+	button: z.string().min(1).nullable().optional(),
+	hero: z.string().min(1).nullable().optional(),
+	background: z.string().min(1).nullable().optional()
 });
 /**
 * Testimonial quote-mark treatment, owned by the site style (analogous to the
@@ -5054,27 +5386,27 @@ const gradientsSchema = z$1.object({
 * it. `none` hides the mark. The block renders the mark; the site style decides
 * its character; a look may still hide it.
 */
-const testimonialQuoteTreatmentSchema = z$1.object({
-	style: z$1.enum([
+const testimonialQuoteTreatmentSchema = z.object({
+	style: z.enum([
 		"serif-display",
 		"accent-glyph",
 		"none"
 	]),
-	fontFamily: z$1.enum(["heading", "body"]).optional(),
-	scale: z$1.enum([
+	fontFamily: z.enum(["heading", "body"]).optional(),
+	scale: z.enum([
 		"sm",
 		"md",
 		"lg",
 		"xl"
 	]).optional(),
 	colorToken: themeColorTokenSchema.optional(),
-	opacity: z$1.number().min(0).max(1).optional()
+	opacity: z.number().min(0).max(1).optional()
 });
-const themeSchema$1 = 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(),
+const themeSchema$1 = z.object({
+	name: z.string().min(1).max(30),
+	description: z.string().min(1).max(400),
+	rationale: z.string().min(1).max(400),
+	siteStyleId: z.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
 	axes: axesSchema,
 	palette: paletteSchema,
 	typography: typographySchema,
@@ -5095,8 +5427,8 @@ const themeSchema$1 = z$1.object({
 	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(),
+	blockCustomVars: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+	blockOverrides: z.record(z.string(), blockThemeOverrideSchema).optional(),
 	headingDecoration: headingDecorationSchema.optional(),
 	customCssRules: customCssRulesSchema,
 	blockCustomCssRules: blockCustomCssRulesSchema,
@@ -5126,11 +5458,11 @@ const themeSchema$1 = z$1.object({
 	* }
 	* ```
 	*/
-	styleGroups: z$1.record(z$1.string(), z$1.array(z$1.string())).optional()
+	styleGroups: z.record(z.string(), z.array(z.string())).optional()
 });
-z$1.object({
-	message: z$1.string().min(1),
-	themes: z$1.array(themeSchema$1).length(3)
+z.object({
+	message: z.string().min(1),
+	themes: z.array(themeSchema$1).length(3)
 });
 //#endregion
 //#region src/theme/loader.ts