@riverbankcms/sdk 0.60.16 → 0.62.4

package/dist/server/theme-bridge.mjs

@@ -29,6 +29,24 @@ var MQ_TABLET_ONLY = mqBetween(BREAKPOINT_SM, BREAKPOINT_LG_DOWN);
 var MQ_MAX_640 = mqDown(BREAKPOINT_SM);
 var MQ_MAX_768 = mqDown(BREAKPOINT_MD);
 
+// ../theme-core/src/site-styles/appearancePresetResolution.ts
+function assertValidOptionGroups(preset) {
+  preset.optionGroups?.forEach((group) => {
+    const selectedOption = group.options.find(
+      (option) => option.id === group.selectedOptionId
+    );
+    if (!selectedOption) {
+      throw new Error(
+        `Appearance preset "${preset.id}" option group "${group.id}" selects missing option "${group.selectedOptionId}".`
+      );
+    }
+  });
+}
+function defineBlockAppearancePreset(preset) {
+  assertValidOptionGroups(preset);
+  return preset;
+}
+
 // ../theme-core/src/site-styles/types.ts
 function asDesignBlockId(value) {
   return brandNonEmptyString(value, "DesignBlockId");
@@ -59,6 +77,9 @@ function asBlockOrderIndex(value) {
   }
   return value;
 }
+function asLayoutVariantKey(value) {
+  return brandNonEmptyString(value, "LayoutVariantKey");
+}
 function asAppearancePresetId(value) {
   return brandNonEmptyString(value, "AppearancePresetId");
 }
@@ -104,6 +125,11 @@ function flushPanelFrame(options) {
     bleed: options.bleed
   };
 }
+var tileTreatmentValues = [
+  "default",
+  "quiet",
+  "brand-depth"
+];
 var eyebrowTreatmentValues = [
   "plain",
   "pill",
@@ -112,27 +138,8 @@ var eyebrowTreatmentValues = [
   "accent-pill-bounce"
 ];
 
-// ../theme-core/src/site-styles/appearancePresets.ts
-function assertValidOptionGroups(preset) {
-  preset.optionGroups?.forEach((group) => {
-    const selectedOption = group.options.find(
-      (option) => option.id === group.selectedOptionId
-    );
-    if (!selectedOption) {
-      throw new Error(
-        `Appearance preset "${preset.id}" option group "${group.id}" selects missing option "${group.selectedOptionId}".`
-      );
-    }
-  });
-}
-function defineBlockAppearancePreset(preset) {
-  assertValidOptionGroups(preset);
-  return preset;
-}
-function defineSiteChromeAppearancePreset(preset) {
-  return preset;
-}
-var appearancePresets = [
+// ../theme-core/src/site-styles/blockAppearancePresets.ts
+var blockAppearancePresets = [
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "hero-immersive-image",
@@ -258,6 +265,24 @@ var appearancePresets = [
       eyebrowTreatment: "accent-pill-bounce"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "hero-brand-depth-expressive",
+    target: "hero",
+    label: "Expressive brand-depth hero",
+    blockKinds: ["block.hero"],
+    constraints: {
+      layoutFamilies: ["centered", "compact"]
+    },
+    design: {
+      sectionSurface: "brand-depth-band",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high",
+      eyebrowTreatment: "accent-pill-bounce"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "hero-contained-intro",
@@ -286,6 +311,20 @@ var appearancePresets = [
       emphasis: "high"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "body-text-brand-depth-intro",
+    target: "body-text",
+    label: "Brand-depth intro copy",
+    blockKinds: ["block.body-text"],
+    design: {
+      sectionSurface: "brand-depth-band",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "soft-fade-short",
+      emphasis: "high"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "offerings-calm-list",
@@ -328,6 +367,21 @@ var appearancePresets = [
       emphasis: "medium"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "schedule-details-brand-depth",
+    target: "events",
+    label: "Brand-depth schedule details",
+    blockKinds: ["block.event-details", "block.course-details"],
+    design: {
+      sectionSurface: "brand-depth-band",
+      contentFrame: plainFrame,
+      itemSurface: "none",
+      transitionAfter: "none",
+      emphasis: "medium",
+      tileTreatment: "brand-depth"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "media-text-flush-feature",
@@ -413,6 +467,20 @@ var appearancePresets = [
       testimonialCardTreatment: "accent-quote"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "faq-base-accordion",
+    target: "faq",
+    label: "Base accordion FAQ",
+    blockKinds: ["block.faq"],
+    design: {
+      sectionSurface: "base",
+      contentFrame: plainFrame,
+      itemSurface: "default",
+      transitionAfter: "none",
+      emphasis: "medium"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "faq-contained-help",
@@ -455,6 +523,20 @@ var appearancePresets = [
       emphasis: "high"
     }
   }),
+  defineBlockAppearancePreset({
+    kind: "block-design",
+    id: "contact-form-brand-depth-card",
+    target: "contact-form",
+    label: "Brand-depth form card",
+    blockKinds: ["block.form"],
+    design: {
+      sectionSurface: "brand-depth-band",
+      contentFrame: panelFrame("raised"),
+      itemSurface: "none",
+      transitionAfter: "none",
+      emphasis: "high"
+    }
+  }),
   defineBlockAppearancePreset({
     kind: "block-design",
     id: "cta-accent-band",
@@ -468,74 +550,38 @@ var appearancePresets = [
       transitionAfter: "none",
       emphasis: "high"
     }
-  }),
-  defineSiteChromeAppearancePreset({
-    kind: "site-chrome",
-    id: "header-clean-base",
-    target: "site-header",
-    label: "Clean base header",
-    header: {
-      surface: {
-        kind: "neutral-solid",
-        token: "surface",
-        textColorToken: "text"
-      },
-      navTreatment: "minimal",
-      dropdownTreatment: "surface",
-      ctaTreatment: "default",
-      behavior: "default"
-    }
-  }),
-  defineSiteChromeAppearancePreset({
-    kind: "site-chrome",
-    id: "site-header-brand-solid-inverted-cta",
-    target: "site-header",
-    label: "Brand solid header with inverted CTA",
-    header: {
-      surface: {
-        kind: "brand-solid",
-        token: "primary",
-        textColorToken: "primaryForeground"
-      },
-      navTreatment: "uppercase-underline",
-      dropdownTreatment: "matched-solid",
-      ctaTreatment: "inverted",
-      behavior: "sticky-shrink"
-    }
-  }),
-  defineSiteChromeAppearancePreset({
-    kind: "site-chrome",
-    id: "footer-muted-grounding",
-    target: "site-footer",
-    label: "Muted grounding footer",
-    footer: {
-      kind: "grounding",
-      surface: "muted-band",
-      emphasis: "low"
-    }
-  }),
-  defineSiteChromeAppearancePreset({
-    kind: "site-chrome",
-    id: "site-footer-brand-two-band",
-    target: "site-footer",
-    label: "Two-band brand footer",
-    footer: {
-      kind: "brand-two-band",
-      surface: {
-        token: "primary",
-        shade: "800",
-        textColorToken: "primaryForeground"
-      },
-      bottomBand: {
-        token: "primary",
-        shade: "900",
-        textColorToken: "primaryForeground"
-      },
-      emphasis: "high"
-    }
   })
 ];
 
+// ../theme-core/src/site-styles/appearancePresetCatalog.ts
+var appearancePresets = [
+  ...blockAppearancePresets
+];
+
+// ../theme-core/src/site-styles/headerCtaVariants.ts
+function hasButtonVariant(theme, variantId) {
+  return theme.buttons?.variants.some((variant) => variant.enabled && variant.id === variantId) ?? false;
+}
+function resolveHeaderCtaVariant(theme, treatment) {
+  switch (treatment) {
+    case "default":
+      return void 0;
+    case "primary":
+      return "primary";
+    case "secondary":
+      return hasButtonVariant(theme, "secondary") ? "secondary" : "primary";
+    case "inverted":
+      if (hasButtonVariant(theme, "header")) return "header";
+      if (hasButtonVariant(theme, "secondary")) return "secondary";
+      if (hasButtonVariant(theme, "outline")) return "outline";
+      return "primary";
+    case "outline":
+      return hasButtonVariant(theme, "outline") ? "outline" : "secondary";
+    case "ghost":
+      return hasButtonVariant(theme, "ghost") ? "ghost" : "secondary";
+  }
+}
+
 // ../theme-core/src/site-styles/pageDesignIntent.ts
 import { z } from "zod";
 var pageDesignIntentSchemaVersion = 1;
@@ -612,10 +658,141 @@ function boundaryKey(previousBlockId, nextBlockId) {
 }
 
 // ../theme-core/src/buttons/personalities/types.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../theme-core/src/buttons/types.ts
+import { z as z3 } from "zod";
+
+// ../theme-core/src/tokens/themeColorTokens.ts
 import { z as z2 } from "zod";
+
+// ../theme-core/src/tokens/colorTokenParts.ts
+function parseOpacityPercent(source) {
+  const trimmed = source.trim();
+  if (!trimmed) return null;
+  if (!/^\d{1,3}(?:\.\d+)?$/.test(trimmed)) return null;
+  const value = Number(trimmed);
+  if (!Number.isFinite(value)) return null;
+  if (value < 0 || value > 100) return null;
+  return value;
+}
+function parseColorTokenParts(source) {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("raw:")) {
+    return { kind: "raw", value: trimmed.slice(4) };
+  }
+  const [token, opacityRaw, extra] = trimmed.split("/");
+  if (!token || extra !== void 0) {
+    return { kind: "invalid", token: trimmed };
+  }
+  if (opacityRaw === void 0) {
+    return { kind: "token", token, opacityPercent: null };
+  }
+  const opacityPercent = parseOpacityPercent(opacityRaw);
+  if (opacityPercent === null) {
+    return { kind: "invalid", token: trimmed };
+  }
+  return { kind: "token", token, opacityPercent };
+}
+
+// ../theme-core/src/tokens/blockColorTokens.ts
+var blockColorTokenNames = [
+  "text",
+  "heading",
+  "mutedText",
+  "surface",
+  "background",
+  "foreground",
+  "border",
+  "primary",
+  "secondary",
+  "accent",
+  "success",
+  "warning",
+  "info",
+  "error",
+  "destructive",
+  "scrim",
+  "shadow",
+  // Common "on*" tokens used when rendering colored chips/badges.
+  "onPrimary",
+  "onSecondary",
+  "onAccent",
+  "onSuccess",
+  "onWarning",
+  "onInfo",
+  "onError",
+  "onDestructive",
+  "onSurface"
+];
+var blockColorTokenNameSet = new Set(
+  blockColorTokenNames
+);
+
+// ../theme-core/src/tokens/themeColorTokens.ts
+var PALETTE_TOKEN_NAMES = [
+  "primary",
+  "primaryForeground",
+  "secondary",
+  "accent",
+  "success",
+  "warning",
+  "destructive",
+  "background",
+  "surface",
+  "surfaceAlt",
+  "muted",
+  "text",
+  "border"
+];
+var paletteTokenNameSchema = z2.enum(PALETTE_TOKEN_NAMES);
+var themeColorBaseTokenNames = [
+  ...PALETTE_TOKEN_NAMES,
+  ...blockColorTokenNames,
+  // Existing generated themes can carry palette-local "white" tokens in
+  // token-only component fields. Keep it explicit until those rows are
+  // migrated to canonical foreground/background roles.
+  "white",
+  "neutral",
+  "primaryText",
+  "secondaryForeground",
+  "accentForeground"
+];
+var themeColorBaseTokenSet = new Set(themeColorBaseTokenNames);
+var SHADE_STEPS = [
+  "50",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "700",
+  "800",
+  "900",
+  "950"
+];
+var shadeStepSet = new Set(SHADE_STEPS);
+function isKnownBaseToken(value) {
+  return themeColorBaseTokenSet.has(value);
+}
+function isKnownShadeToken(value) {
+  const match = value.match(/^([a-zA-Z][a-zA-Z0-9]*)(?:-([0-9]{2,3}))$/);
+  if (!match) return false;
+  const [, base, shade] = match;
+  return Boolean(base && shade && isKnownBaseToken(base) && shadeStepSet.has(shade));
+}
+function isThemeColorTokenBase(value) {
+  return isKnownBaseToken(value) || isKnownShadeToken(value);
+}
+function isThemeColorToken(value) {
+  if (typeof value !== "string") return false;
+  const parts = parseColorTokenParts(value);
+  return parts.kind === "token" && isThemeColorTokenBase(parts.token);
+}
+var themeColorTokenSchema = z2.string().min(1).refine((value) => Boolean(isThemeColorToken(value)), "Expected a known Theme V2 color token");
+
+// ../theme-core/src/buttons/types.ts
 var VARIANT_ROLES = [
   "primary",
   "secondary",
@@ -625,22 +802,22 @@ var VARIANT_ROLES = [
   "tertiary",
   "accent"
 ];
-var cornerStyleSchema = z2.enum(["square", "rounded", "pill"]);
-var shadowSizeSchema = z2.enum(["none", "low", "medium", "high"]);
-var textTransformSchema = z2.enum(["none", "uppercase", "lowercase", "capitalize"]);
-var fontWeightSchema = z2.union([z2.literal(500), z2.literal(600), z2.literal(700)]);
-var buttonTypographySchema = z2.enum(["body", "heading"]);
-var letterSpacingSchema = z2.enum(["tight", "normal", "loose"]);
-var hoverTransformSchema = z2.enum(["none", "lift", "scale", "press"]);
-var hoverColorSchema = z2.enum(["none", "brighten", "darken", "saturate", "token"]);
-var buttonPaddingPresetSchema = z2.enum(["compact", "default", "spacious"]);
-var gradientStyleSchema = z2.enum(["linear", "radial", "conic"]);
-var gradientSharpnessSchema = z2.enum(["smooth", "medium", "hard"]);
-var prioritySchema = z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]);
-var variantRoleSchema = z2.enum(VARIANT_ROLES);
-var buttonSizeNameSchema = z2.enum(["sm", "md", "lg", "xl"]);
+var cornerStyleSchema = z3.enum(["square", "rounded", "pill"]);
+var shadowSizeSchema = z3.enum(["none", "low", "medium", "high"]);
+var textTransformSchema = z3.enum(["none", "uppercase", "lowercase", "capitalize"]);
+var fontWeightSchema = z3.union([z3.literal(500), z3.literal(600), z3.literal(700)]);
+var buttonTypographySchema = z3.enum(["body", "heading"]);
+var letterSpacingSchema = z3.enum(["tight", "normal", "loose"]);
+var hoverTransformSchema = z3.enum(["none", "lift", "scale", "press"]);
+var hoverColorSchema = z3.enum(["none", "brighten", "darken", "saturate", "token"]);
+var buttonPaddingPresetSchema = z3.enum(["compact", "default", "spacious"]);
+var gradientStyleSchema = z3.enum(["linear", "radial", "conic"]);
+var gradientSharpnessSchema = z3.enum(["smooth", "medium", "hard"]);
+var prioritySchema = z3.union([z3.literal(1), z3.literal(2), z3.literal(3)]);
+var variantRoleSchema = z3.enum(VARIANT_ROLES);
+var buttonSizeNameSchema = z3.enum(["sm", "md", "lg", "xl"]);
 var PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
-var paddingShorthandSchema = z2.string().refine(
+var paddingShorthandSchema = z3.string().refine(
   (value) => {
     const parts = value.split(/\s+/).filter(Boolean);
     return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
@@ -649,11 +826,11 @@ var paddingShorthandSchema = z2.string().refine(
     message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
   }
 );
-var buttonSizeConfigSchema = z2.object({
+var buttonSizeConfigSchema = z3.object({
   padding: paddingShorthandSchema,
-  fontSize: z2.string().optional()
+  fontSize: z3.string().optional()
 });
-var buttonSizesSchema = z2.object({
+var buttonSizesSchema = z3.object({
   sm: buttonSizeConfigSchema,
   md: buttonSizeConfigSchema,
   lg: buttonSizeConfigSchema,
@@ -664,9 +841,9 @@ var buttonSizesSchema = z2.object({
   lg,
   xl: xl ?? lg
 }));
-var buttonGlobalSettingsSchema = z2.object({
+var buttonGlobalSettingsSchema = z3.object({
   cornerStyle: cornerStyleSchema,
-  cornerRadius: z2.number().min(0).max(24).optional(),
+  cornerRadius: z3.number().min(0).max(24).optional(),
   shadow: shadowSizeSchema,
   textTransform: textTransformSchema,
   fontWeight: fontWeightSchema,
@@ -676,104 +853,104 @@ var buttonGlobalSettingsSchema = z2.object({
    * by the current generator and will be removed once the legacy
    * `primitives/content/components/Button.tsx` slot exports are deleted.
    */
-  borderWidth: z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]),
+  borderWidth: z3.union([z3.literal(1), z3.literal(2), z3.literal(3)]),
   // === Family-level typography ===
   // Typography source (body or heading) — selects which theme typography pool to inherit
   typography: buttonTypographySchema.optional(),
   // Font size for all variants in the family (Tailwind token, e.g. "text-xs", "text-sm")
   // Sized variants get this as default; fixed variants inherit unless they override.
   // Size class CSS may still override at run time for sized variants.
-  fontSize: z2.string().optional(),
+  fontSize: z3.string().optional(),
   // Letter spacing applied to all variants
   letterSpacing: letterSpacingSchema.optional(),
   // Italic style
-  italic: z2.boolean().optional(),
+  italic: z3.boolean().optional(),
   // Padding preset (applies to sized variants without a sizes config)
   paddingPreset: buttonPaddingPresetSchema.optional(),
   hoverTransform: hoverTransformSchema,
   hoverColor: hoverColorSchema,
   // When hoverColor is 'token', this specifies which token to use
-  hoverColorToken: z2.string().optional(),
+  hoverColorToken: themeColorTokenSchema.optional(),
   // Gradient settings (if any variant uses gradients)
   gradientStyle: gradientStyleSchema.optional(),
-  gradientAngle: z2.number().min(0).max(360).optional(),
+  gradientAngle: z3.number().min(0).max(360).optional(),
   gradientSharpness: gradientSharpnessSchema.optional()
 });
-var gradientDirectionSchema = z2.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var buttonBackgroundSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("solid"), colorToken: z2.string() }),
-  z2.object({
-    type: z2.literal("gradient"),
-    stops: z2.array(z2.string()).min(2),
+var gradientDirectionSchema = z3.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var buttonBackgroundSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("solid"), colorToken: themeColorTokenSchema }),
+  z3.object({
+    type: z3.literal("gradient"),
+    stops: z3.array(themeColorTokenSchema).min(2),
     direction: gradientDirectionSchema
   }),
-  z2.object({ type: z2.literal("transparent") })
+  z3.object({ type: z3.literal("transparent") })
 ]);
-var effectApplicationSchema = z2.object({
-  effectId: z2.string(),
-  options: z2.record(z2.string(), z2.any()).optional()
+var effectApplicationSchema = z3.object({
+  effectId: z3.string(),
+  options: z3.record(z3.string(), z3.any()).optional()
 });
-var buttonBorderSchema = z2.object({
-  widthClass: z2.string(),
-  colorToken: z2.string()
+var buttonBorderSchema = z3.object({
+  widthClass: z3.string(),
+  colorToken: themeColorTokenSchema
 });
-var variantShadowSchema = z2.object({
-  elevation: z2.enum(["none", "low", "medium", "high"]),
-  softness: z2.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z2.enum(["bottom", "bottom-right"]).default("bottom")
+var variantShadowSchema = z3.object({
+  elevation: z3.enum(["none", "low", "medium", "high"]),
+  softness: z3.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z3.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var variantEffectsSchema = z2.object({
-  base: z2.array(effectApplicationSchema).optional(),
-  hover: z2.array(effectApplicationSchema).optional(),
-  active: z2.array(effectApplicationSchema).optional(),
-  focus: z2.array(effectApplicationSchema).optional()
+var variantEffectsSchema = z3.object({
+  base: z3.array(effectApplicationSchema).optional(),
+  hover: z3.array(effectApplicationSchema).optional(),
+  active: z3.array(effectApplicationSchema).optional(),
+  focus: z3.array(effectApplicationSchema).optional()
 });
-var variantSizeOverridesSchema = z2.object({
+var variantSizeOverridesSchema = z3.object({
   sm: buttonSizeConfigSchema.optional(),
   md: buttonSizeConfigSchema.optional(),
   lg: buttonSizeConfigSchema.optional(),
   xl: buttonSizeConfigSchema.optional()
 });
-var buttonVariantSchema = z2.object({
-  id: z2.string(),
-  name: z2.string().min(1).max(20),
-  enabled: z2.boolean(),
+var buttonVariantSchema = z3.object({
+  id: z3.string(),
+  name: z3.string().min(1).max(20),
+  enabled: z3.boolean(),
   priority: prioritySchema,
   // Base appearance (token-based)
   background: buttonBackgroundSchema,
-  textColorToken: z2.string(),
+  textColorToken: themeColorTokenSchema,
   /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-  borderRadius: z2.string().optional(),
+  borderRadius: z3.string().optional(),
   // Optional shadow override (uses theme.shadow if not specified)
   shadow: variantShadowSchema.optional(),
   // Border (optional)
   border: buttonBorderSchema.optional(),
   // Hover background token (per-variant override, takes precedence over global hoverColorToken)
-  hoverBackgroundToken: z2.string().optional(),
+  hoverBackgroundToken: z3.string().optional(),
   // Effect composition
   effects: variantEffectsSchema.optional(),
   // Per-variant size overrides — see VariantSizeOverrides
   sizes: variantSizeOverridesSchema.optional()
 });
-var buttonSystemSchema = z2.object({
+var buttonSystemSchema = z3.object({
   global: buttonGlobalSettingsSchema,
-  variants: z2.array(buttonVariantSchema).min(1).max(6),
+  variants: z3.array(buttonVariantSchema).min(1).max(6),
   sizes: buttonSizesSchema.optional()
 });
 
 // ../theme-core/src/site-styles/styleTags.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var STYLE_AXIS_VALUES = {
   tone: ["minimal", "classic", "bold"],
   energy: ["calm", "vibrant"],
   motion: ["subtle", "standard", "expressive"],
   era: ["editorial", "modern", "organic", "technical", "retro"]
 };
-var styleTagsSchema = z3.object({
-  tone: z3.enum(STYLE_AXIS_VALUES.tone).optional(),
-  energy: z3.enum(STYLE_AXIS_VALUES.energy).optional(),
-  motion: z3.enum(STYLE_AXIS_VALUES.motion).optional(),
-  era: z3.enum(STYLE_AXIS_VALUES.era).optional()
+var styleTagsSchema = z4.object({
+  tone: z4.enum(STYLE_AXIS_VALUES.tone).optional(),
+  energy: z4.enum(STYLE_AXIS_VALUES.energy).optional(),
+  motion: z4.enum(STYLE_AXIS_VALUES.motion).optional(),
+  era: z4.enum(STYLE_AXIS_VALUES.era).optional()
 });
 
 // ../theme-core/src/buttons/personalities/types.ts
@@ -783,11 +960,11 @@ function asButtonPersonalityId(value) {
   }
   return value;
 }
-var buttonPersonalityIdSchema = z4.string().min(1).transform((value) => asButtonPersonalityId(value));
-var buttonPersonalitySchema = z4.object({
+var buttonPersonalityIdSchema = z5.string().min(1).transform((value) => asButtonPersonalityId(value));
+var buttonPersonalitySchema = z5.object({
   id: buttonPersonalityIdSchema,
-  name: z4.string().min(1),
-  description: z4.string().min(1),
+  name: z5.string().min(1),
+  description: z5.string().min(1),
   tags: styleTagsSchema,
   buttonSystem: buttonSystemSchema
 });
@@ -1432,51 +1609,51 @@ var personalitiesById = new Map(
 );
 
 // ../theme-core/src/palette/variants/types.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // ../theme-core/src/schema.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // ../theme-core/src/lib/media.ts
-import z5 from "zod";
-var hotspotSchema = z5.object({
-  x: z5.number().min(0).max(1),
-  y: z5.number().min(0).max(1),
-  radius: z5.number().optional()
+import z6 from "zod";
+var hotspotSchema = z6.object({
+  x: z6.number().min(0).max(1),
+  y: z6.number().min(0).max(1),
+  radius: z6.number().optional()
 });
-var rotationSchema = z5.union([z5.literal(0), z5.literal(90), z5.literal(180), z5.literal(270)]);
-var rectSchema = z5.tuple([z5.number(), z5.number(), z5.number(), z5.number()]);
-var aspectCropSchema = z5.object({
-  aspect: z5.preprocess((value) => value == null ? void 0 : value, z5.string().optional()),
-  rect: z5.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-  hotspot: z5.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-  rotation: z5.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+var rotationSchema = z6.union([z6.literal(0), z6.literal(90), z6.literal(180), z6.literal(270)]);
+var rectSchema = z6.tuple([z6.number(), z6.number(), z6.number(), z6.number()]);
+var aspectCropSchema = z6.object({
+  aspect: z6.preprocess((value) => value == null ? void 0 : value, z6.string().optional()),
+  rect: z6.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+  hotspot: z6.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+  rotation: z6.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
 });
-var transformSchema = z5.object({
-  aspectCrops: z5.preprocess((value) => {
+var transformSchema = z6.object({
+  aspectCrops: z6.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z5.record(z5.string(), aspectCropSchema.catch({}))).optional(),
+  }, z6.record(z6.string(), aspectCropSchema.catch({}))).optional(),
   rect: rectSchema.optional(),
   hotspot: hotspotSchema.optional(),
   rotation: rotationSchema.optional()
 });
-var mediaSchema = z5.object({
-  type: z5.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z5.string().optional(),
-  placeholder: z5.boolean().default(true).optional(),
-  assetId: z5.string().optional(),
-  identifier: z5.string().optional(),
-  src: z5.string().optional(),
-  alt: z5.string().optional(),
-  filename: z5.string().optional(),
-  mimeType: z5.string().optional(),
-  width: z5.number().optional(),
-  height: z5.number().optional(),
-  storageBucket: z5.string().optional(),
-  storagePath: z5.string().optional(),
+var mediaSchema = z6.object({
+  type: z6.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+  purpose: z6.string().optional(),
+  placeholder: z6.boolean().default(true).optional(),
+  assetId: z6.string().optional(),
+  identifier: z6.string().optional(),
+  src: z6.string().optional(),
+  alt: z6.string().optional(),
+  filename: z6.string().optional(),
+  mimeType: z6.string().optional(),
+  width: z6.number().optional(),
+  height: z6.number().optional(),
+  storageBucket: z6.string().optional(),
+  storagePath: z6.string().optional(),
   transform: transformSchema.optional()
 });
 
@@ -1610,43 +1787,43 @@ function getDefaultButtonVariants() {
 }
 
 // ../theme-core/src/cards/types.ts
-import { z as z6 } from "zod";
-var cardSpacingSchema = z6.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z6.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardBackgroundSchema = z6.discriminatedUnion("type", [
-  z6.object({ type: z6.literal("solid"), colorToken: z6.string() }),
-  z6.object({
-    type: z6.literal("gradient"),
-    fromToken: z6.string(),
-    toToken: z6.string(),
+import { z as z7 } from "zod";
+var cardSpacingSchema = z7.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z7.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardBackgroundSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("solid"), colorToken: themeColorTokenSchema }),
+  z7.object({
+    type: z7.literal("gradient"),
+    fromToken: themeColorTokenSchema,
+    toToken: themeColorTokenSchema,
     direction: gradientDirectionSchema2
   }),
-  z6.object({ type: z6.literal("transparent") })
+  z7.object({ type: z7.literal("transparent") })
 ]);
-var cardBorderSchema = z6.object({
-  widthClass: z6.string(),
-  colorToken: z6.string()
+var cardBorderSchema = z7.object({
+  widthClass: z7.string(),
+  colorToken: themeColorTokenSchema
 });
-var cardVariantSchema = z6.object({
-  id: z6.string(),
-  name: z6.string().min(1).max(20),
-  enabled: z6.boolean(),
-  priority: z6.union([z6.literal(1), z6.literal(2), z6.literal(3)]),
+var cardVariantSchema = z7.object({
+  id: z7.string(),
+  name: z7.string().min(1).max(20),
+  enabled: z7.boolean(),
+  priority: z7.union([z7.literal(1), z7.literal(2), z7.literal(3)]),
   // Appearance (token-based)
   background: cardBackgroundSchema,
   spacing: cardSpacingSchema,
   // Optional overrides (uses theme defaults if not specified)
-  shadow: z6.object({
-    elevation: z6.enum(["none", "low", "medium", "high"]),
-    softness: z6.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z6.enum(["bottom", "bottom-right"]).default("bottom")
+  shadow: z7.object({
+    elevation: z7.enum(["none", "low", "medium", "high"]),
+    softness: z7.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z7.enum(["bottom", "bottom-right"]).default("bottom")
   }).optional(),
-  corners: z6.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z7.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Border (optional)
   border: cardBorderSchema.optional()
 });
-var cardSystemSchema = z6.object({
-  variants: z6.array(cardVariantSchema).min(1).max(3)
+var cardSystemSchema = z7.object({
+  variants: z7.array(cardVariantSchema).min(1).max(3)
 });
 
 // ../theme-core/src/cards/core.ts
@@ -1768,8 +1945,8 @@ function getDefaultCardVariants() {
 }
 
 // ../theme-core/src/accordions/types.ts
-import { z as z7 } from "zod";
-var accordionIconSchema = z7.enum([
+import { z as z8 } from "zod";
+var accordionIconSchema = z8.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -1781,180 +1958,179 @@ var accordionIconSchema = z7.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z7.object({
+var accordionSystemSchema = z8.object({
   // Visual styling (solid color only - gradients can be added later if needed)
-  background: z7.object({
-    type: z7.literal("solid"),
-    colorToken: z7.string()
+  background: z8.object({
+    type: z8.literal("solid"),
+    colorToken: themeColorTokenSchema
   }),
   // Spacing (padding inside items)
-  spacing: z7.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z8.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z7.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z8.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z7.object({
-    widthClass: z7.string(),
+  border: z8.object({
+    widthClass: z8.string(),
     // e.g., 'border', 'border-2', 'border-0'
-    colorToken: z7.string()
+    colorToken: themeColorTokenSchema
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z7.object({
-    elevation: z7.enum(["none", "low", "medium", "high"]),
-    softness: z7.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z7.enum(["bottom", "bottom-right"])
+  shadow: z8.object({
+    elevation: z8.enum(["none", "low", "medium", "high"]),
+    softness: z8.enum(["soft", "crisp", "hard"]).nullable(),
+    position: z8.enum(["bottom", "bottom-right"])
   }).nullable(),
   // Icon style and animation
-  icon: z7.object({
+  icon: z8.object({
     style: accordionIconSchema,
-    position: z7.enum(["left", "right"]),
-    size: z7.enum(["sm", "md", "lg"])
+    position: z8.enum(["left", "right"]),
+    size: z8.enum(["sm", "md", "lg"])
   }),
   // Trigger (question) styling
-  trigger: z7.object({
-    textColorToken: z7.string(),
-    fontWeight: z7.enum(["regular", "medium", "semibold", "bold"]).nullable()
+  trigger: z8.object({
+    textColorToken: themeColorTokenSchema,
+    fontWeight: z8.enum(["regular", "medium", "semibold", "bold"]).nullable()
     // null = inherit from theme
   }),
   // Hover state styling
-  hover: z7.object({
-    backgroundColorToken: z7.string().optional(),
-    textColorToken: z7.string().optional(),
-    borderColorToken: z7.string().optional()
+  hover: z8.object({
+    backgroundColorToken: themeColorTokenSchema.optional(),
+    textColorToken: themeColorTokenSchema.optional(),
+    borderColorToken: themeColorTokenSchema.optional()
   }),
   // Content (answer) styling
-  content: z7.object({
-    textColorToken: z7.string()
+  content: z8.object({
+    textColorToken: themeColorTokenSchema
   })
 });
 
 // ../theme-core/src/inputs/types.ts
-import { z as z8 } from "zod";
-var inputSystemSchema = z8.object({
+import { z as z9 } from "zod";
+var inputSystemSchema = z9.object({
   // Base styling (applied to all inputs)
-  base: z8.object({
-    background: z8.union([
-      z8.object({
-        type: z8.literal("solid"),
-        colorToken: z8.string()
+  base: z9.object({
+    background: z9.union([
+      z9.object({
+        type: z9.literal("solid"),
+        colorToken: themeColorTokenSchema
       }),
-      z8.object({
-        type: z8.literal("transparent")
+      z9.object({
+        type: z9.literal("transparent")
       })
     ]),
-    textColorToken: z8.string(),
-    border: z8.object({
-      widthClass: z8.string(),
+    textColorToken: themeColorTokenSchema,
+    border: z9.object({
+      widthClass: z9.string(),
       // e.g., 'border', 'border-2'
-      colorToken: z8.string(),
-      style: z8.enum(["all", "underline"]).optional()
+      colorToken: themeColorTokenSchema,
+      style: z9.enum(["all", "underline"]).optional()
     }),
-    corners: z8.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z9.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z8.object({
-      elevation: z8.enum(["none", "low", "medium"]),
-      softness: z8.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z9.object({
+      elevation: z9.enum(["none", "low", "medium"]),
+      softness: z9.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z8.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z9.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z8.enum(["sm", "base", "lg"])
+    fontSize: z9.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z8.object({
-    textColorToken: z8.string(),
-    fontWeight: z8.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z8.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z8.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z8.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z8.number().min(0.2).max(1).optional()
+  label: z9.object({
+    textColorToken: themeColorTokenSchema,
+    fontWeight: z9.enum(["regular", "medium", "semibold", "bold", "black"]),
+    fontSize: z9.enum(["2xs", "xs", "sm", "base"]),
+    textTransform: z9.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+    letterSpacing: z9.enum(["normal", "wide", "wider", "widest"]).optional(),
+    opacity: z9.number().min(0.2).max(1).optional()
   }),
   // Focus state
-  focus: z8.object({
-    ringColorToken: z8.string(),
-    ringWidth: z8.enum(["0", "1", "2", "3"]),
-    borderColorToken: z8.string().optional()
+  focus: z9.object({
+    ringColorToken: themeColorTokenSchema,
+    ringWidth: z9.enum(["0", "1", "2", "3"]),
+    borderColorToken: themeColorTokenSchema.optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z8.object({
-    borderColorToken: z8.string(),
-    textColorToken: z8.string()
+  error: z9.object({
+    borderColorToken: themeColorTokenSchema,
+    textColorToken: themeColorTokenSchema
   }),
   // Disabled state
-  disabled: z8.object({
-    backgroundColorToken: z8.string(),
-    textColorToken: z8.string(),
-    opacity: z8.number().min(0.3).max(0.7)
+  disabled: z9.object({
+    backgroundColorToken: themeColorTokenSchema,
+    textColorToken: themeColorTokenSchema,
+    opacity: z9.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/gradients/types.ts
-import { z as z9 } from "zod";
-var gradientStopSchema = z9.object({
-  color: z9.string(),
-  // Theme color token name (e.g., 'primary-500')
-  position: z9.number().min(0).max(100)
+import { z as z10 } from "zod";
+var gradientStopSchema = z10.object({
+  color: themeColorTokenSchema,
+  position: z10.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z9.object({
-  type: z9.enum(["linear", "radial"]),
-  angle: z9.number().min(0).max(360).optional(),
+var gradientConfigSchema = z10.object({
+  type: z10.enum(["linear", "radial"]),
+  angle: z10.number().min(0).max(360).optional(),
   // For linear gradients (degrees)
-  position: z9.string().optional(),
+  position: z10.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z9.array(gradientStopSchema).min(2)
+  stops: z10.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z10 } from "zod";
-var interactiveTypographySchema = z10.object({
+import { z as z11 } from "zod";
+var interactiveTypographySchema = z11.object({
   /** Font family source */
-  typography: z10.enum(["body", "heading"]).default("body"),
+  typography: z11.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z10.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z11.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z10.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z11.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z10.boolean().default(false)
+  italic: z11.boolean().default(false)
 });
-var effectApplicationSchema2 = z10.object({
+var effectApplicationSchema2 = z11.object({
   /** Effect preset ID */
-  effectId: z10.string(),
+  effectId: z11.string(),
   /** User-provided customization options */
-  options: z10.record(z10.string(), z10.any()).optional()
+  options: z11.record(z11.string(), z11.any()).optional()
 });
-var effectCompositionSchema = z10.object({
+var effectCompositionSchema = z11.object({
   /** Effects always applied */
-  base: z10.array(effectApplicationSchema2).optional(),
+  base: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z10.array(effectApplicationSchema2).optional(),
+  hover: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z10.array(effectApplicationSchema2).optional(),
+  active: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z10.array(effectApplicationSchema2).optional()
+  focus: z11.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z11.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z11.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z11.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z11.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z11.enum(["normal", "wide", "wider", "widest"]);
-var navLinkStyleSchema = z11.object({
+var navLinkPaddingSchema = z12.enum(["none", "compact", "default"]);
+var navLinkPaddingXSchema = z12.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navLinkBorderRadiusSchema = z12.enum(["none", "sm", "md", "full"]);
+var navLinkTextSizeSchema = z12.enum(["xs", "sm", "base", "lg"]);
+var navLinkLetterSpacingSchema = z12.enum(["normal", "wide", "wider", "widest"]);
+var navLinkStyleSchema = z12.object({
   /** Display name for the style */
-  name: z11.string().min(1).max(30).optional(),
+  name: z12.string().min(1).max(30).optional(),
   /** Typography settings (inherited from interactive base) */
   ...interactiveTypographySchema.shape,
   /** Text color token */
-  colorToken: z11.string().default("text"),
+  colorToken: themeColorTokenSchema.default("text"),
   /** Optional text size override */
   textSize: navLinkTextSizeSchema.optional(),
   /** Optional letter spacing override */
   letterSpacing: navLinkLetterSpacingSchema.optional(),
   /** Hover/active color token (for color-change effects) */
-  hoverColorToken: z11.string().nullable().optional(),
+  hoverColorToken: themeColorTokenSchema.nullable().optional(),
   /** Padding preset */
   padding: navLinkPaddingSchema.default("compact"),
   /** Horizontal padding override (overrides horizontal component of padding preset) */
@@ -1966,7 +2142,7 @@ var navLinkStyleSchema = z11.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var FORBIDDEN_SELECTORS = [":root", "html", "body"];
 var UNIVERSAL_SELECTOR = "*";
 var REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
@@ -2008,7 +2184,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z12.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
+var selectorSchema = z13.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" }
 );
@@ -2018,38 +2194,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z12.string().max(500, "Declaration value too long (max 500 characters)").refine(
+var declarationValueSchema = z13.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" }
 );
-var declarationsSchema = z12.record(
-  z12.string().min(1).max(100),
+var declarationsSchema = z13.record(
+  z13.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z12.object({
-  id: z12.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+var customCssRuleSchema = z13.object({
+  id: z13.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
   selector: selectorSchema,
   declarations: declarationsSchema
 });
 var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z12.string().min(1, "Block kind is required").max(50, "Block kind too long")
+  blockKind: z13.string().min(1, "Block kind is required").max(50, "Block kind too long")
 });
-var customCssRulesSchema = z12.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z12.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z13.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z13.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var KEYFRAME_OFFSET_PATTERN = /^(from|to|\d{1,3}%)$/i;
 var ANIMATION_NAME_PATTERN = /^[a-zA-Z_-][a-zA-Z0-9_-]*$/;
 var BLOCKED_AT_RULES = ["@import", "@charset"];
 var BLOCKED_AT_RULE_PATTERN = /@(?:import|charset)\b/i;
-var ruleIdSchema = z13.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z13.object({
+var ruleIdSchema = z14.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z14.object({
   selector: selectorSchema,
   declarations: declarationsSchema
 });
@@ -2061,205 +2237,208 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z13.string().transform((offset) => offset.trim()).refine(
+var keyframeOffsetSchema = z14.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%" }
 );
-var animationNameSchema = z13.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
+var animationNameSchema = z14.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)" }
 );
-var keyframeSchema = z13.object({
+var keyframeSchema = z14.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z13.object({
+var keyframesAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z13.literal("keyframes"),
+  type: z14.literal("keyframes"),
   name: animationNameSchema,
-  frames: z13.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z14.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z13.record(z13.string().min(1).max(100), declarationValueSchema).refine(
+var fontFaceDeclarationsSchema = z14.record(z14.string().min(1).max(100), declarationValueSchema).refine(
   (decls) => "fontFamily" in decls || "font-family" in decls,
   { message: "font-family is required in @font-face" }
 );
-var fontFaceAtRuleSchema = z13.object({
+var fontFaceAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z13.literal("font-face"),
+  type: z14.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z13.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z13.object({
+var mediaQuerySchema = z14.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z13.literal("media"),
+  type: z14.literal("media"),
   query: mediaQuerySchema,
-  rules: z13.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z13.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z13.object({
+var supportsConditionSchema = z14.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z13.literal("supports"),
+  type: z14.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z13.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 function containsBlockedAtRule(css) {
   return BLOCKED_AT_RULE_PATTERN.test(css);
 }
-var rawCssSchema = z13.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
+var rawCssSchema = z14.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.` }
 );
-var rawAtRuleSchema = z13.object({
+var rawAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z13.literal("raw"),
+  type: z14.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z13.discriminatedUnion("type", [
+var customCssAtRuleSchema = z14.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z13.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z14.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z14 } from "zod";
-var componentBorderSchema = z14.object({
-  width: z14.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z14.enum(["solid", "dashed"]).default("solid"),
-  colorToken: z14.string().optional()
+import { z as z15 } from "zod";
+var componentBorderSchema = z15.object({
+  width: z15.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z15.enum(["solid", "dashed"]).default("solid"),
+  colorToken: themeColorTokenSchema.optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z14.object({
-  elevation: z14.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+var componentShadowSchema = z15.object({
+  elevation: z15.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
 });
 
+// ../theme-core/src/utils/tokenOrColor.ts
+import { z as z16 } from "zod";
+var tokenOrCssColorValueSchema = z16.string();
+
 // ../theme-core/src/schema.ts
-var axesSchema = z15.object({
-  tone: z15.enum(["minimal", "classic", "bold"]),
-  energy: z15.enum(["calm", "vibrant"]),
-  density: z15.enum(["airy", "regular", "compact"]),
-  mediaBias: z15.enum(["text", "media", "mixed"]),
-  conversionBias: z15.enum(["low", "med", "high"]),
-  motion: z15.enum(["subtle", "standard", "expressive"])
+var axesSchema = z17.object({
+  tone: z17.enum(["minimal", "classic", "bold"]),
+  energy: z17.enum(["calm", "vibrant"]),
+  density: z17.enum(["airy", "regular", "compact"]),
+  mediaBias: z17.enum(["text", "media", "mixed"]),
+  conversionBias: z17.enum(["low", "med", "high"]),
+  motion: z17.enum(["subtle", "standard", "expressive"])
 });
-var colourHexString = z15.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z15.object({
-  name: z15.string().min(1),
+var colourHexString = z17.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z17.object({
+  name: z17.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z15.object({
-  mode: z15.enum(["light", "dark"])
+var paletteMetaSchema = z17.object({
+  mode: z17.enum(["light", "dark"])
 });
-var paletteSchema = z15.object({
-  colors: z15.array(paletteColorSchema),
+var paletteSchema = z17.object({
+  colors: z17.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z15.object({
-  family: z15.string().min(1),
-  weight: z15.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z15.enum(["tight", "normal", "loose"]),
-  lineHeight: z15.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z17.object({
+  family: z17.string().min(1),
+  weight: z17.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z17.enum(["tight", "normal", "loose"]),
+  lineHeight: z17.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z15.enum(["md", "lg", "xl"])
+  size: z17.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z15.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z15.object({
-  weight: z15.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z15.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z17.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z17.object({
+  weight: z17.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z17.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z15.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z15.boolean().nullable().optional(),
-  colorToken: z15.string().min(1).nullable().optional()
-  // Palette token name for heading color
+  lineHeight: z17.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z17.boolean().nullable().optional(),
+  colorToken: themeColorTokenSchema.nullable().optional()
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z15.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z15.boolean().nullable(),
-  colorToken: z15.string().min(1).nullable().optional()
-  // Palette token name for heading color
+  case: z17.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z17.boolean().nullable(),
+  colorToken: themeColorTokenSchema.nullable().optional()
 });
-var proseLinkUnderlineStyleSchema = z15.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z15.enum(["auto", "fromFont", "thin", "medium", "thick"]);
-var proseLinkUnderlineOffsetSchema = z15.enum(["auto", "tight", "normal", "loose"]);
-var proseLinkStyleSchema = z15.object({
-  colorToken: z15.string().min(1).optional(),
-  hoverColorToken: z15.string().min(1).optional(),
-  underline: z15.boolean().optional(),
-  decorationColorToken: z15.string().min(1).optional(),
-  hoverDecorationColorToken: z15.string().min(1).optional(),
+var proseLinkUnderlineStyleSchema = z17.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z17.enum(["auto", "fromFont", "thin", "medium", "thick"]);
+var proseLinkUnderlineOffsetSchema = z17.enum(["auto", "tight", "normal", "loose"]);
+var proseLinkStyleSchema = z17.object({
+  colorToken: themeColorTokenSchema.optional(),
+  hoverColorToken: themeColorTokenSchema.optional(),
+  underline: z17.boolean().optional(),
+  decorationColorToken: themeColorTokenSchema.optional(),
+  hoverDecorationColorToken: themeColorTokenSchema.optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z15.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var boxRoundedSchema = z15.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z15.object({
-  type: z15.enum(["none", "color", "gradient"]).nullable().optional(),
-  color: z15.string().nullable().optional(),
-  gradient: z15.string().nullable().optional(),
-  opacity: z15.number().min(0).max(1).nullable().optional()
+var semanticSpacingSchema = z17.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var boxRoundedSchema = z17.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z17.object({
+  type: z17.enum(["none", "color", "gradient"]).nullable().optional(),
+  color: tokenOrCssColorValueSchema.nullable().optional(),
+  gradient: z17.string().nullable().optional(),
+  opacity: z17.number().min(0).max(1).nullable().optional()
 });
-var boxBackgroundSchema = z15.object({
-  type: z15.enum(["color", "gradient", "image"]).optional(),
-  color: z15.string().nullable().optional(),
-  gradient: z15.string().nullable().optional(),
+var boxBackgroundSchema = z17.object({
+  type: z17.enum(["color", "gradient", "image"]).optional(),
+  color: tokenOrCssColorValueSchema.nullable().optional(),
+  gradient: z17.string().nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  objectFit: z15.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z15.string().nullable().optional(),
-  position: z15.string().nullable().optional(),
-  opacity: z15.number().min(0).max(1).nullable().optional(),
-  motion: z15.enum(["static", "fixed-frame"]).nullable().optional(),
+  objectFit: z17.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z17.string().nullable().optional(),
+  position: z17.string().nullable().optional(),
+  opacity: z17.number().min(0).max(1).nullable().optional(),
+  motion: z17.enum(["static", "fixed-frame"]).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
-  textColor: z15.string().nullable().optional(),
-  headingColor: z15.string().nullable().optional()
+  textColor: tokenOrCssColorValueSchema.nullable().optional(),
+  headingColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var sectionStylesOverrideSchema = z15.object({
+var sectionStylesOverrideSchema = z17.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z15.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
-  eyebrowTreatment: z15.enum(eyebrowTreatmentValues).nullable().optional()
+  minHeight: z17.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
+  tileTreatment: z17.enum(tileTreatmentValues).nullable().optional(),
+  eyebrowTreatment: z17.enum(eyebrowTreatmentValues).nullable().optional()
 });
-var containerStylesOverrideSchema = z15.object({
+var containerStylesOverrideSchema = z17.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z15.boolean().nullable().optional(),
+  raised: z17.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z15.boolean().nullable().optional()
+  fullWidth: z17.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z15.object({
-  enabled: z15.boolean().nullable().optional(),
-  width: z15.enum(["none", "1", "2", "3"]).nullable().optional(),
-  colorToken: z15.string().nullable().optional()
+var cardBorderOverrideSchema = z17.object({
+  enabled: z17.boolean().nullable().optional(),
+  width: z17.enum(["none", "1", "2", "3"]).nullable().optional(),
+  colorToken: themeColorTokenSchema.nullable().optional()
 });
-var cardStylesOverrideSchema = z15.object({
+var cardStylesOverrideSchema = z17.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z15.boolean().nullable().optional(),
+  raised: z17.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  treatment: z15.enum(["accent-quote"]).nullable().optional()
+  treatment: z17.enum(["accent-quote"]).nullable().optional()
 });
-var blockStyleOverridesSchema = z15.object({
+var blockStyleOverridesSchema = z17.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z15.object({
-  typography: z15.object({
+var blockThemeOverrideSchema = z17.object({
+  typography: z17.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z15.enum([
+var typographyScaleSchema = z17.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -2272,9 +2451,9 @@ var typographyScaleSchema = z15.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z15.object({
+var typographySchema = z17.object({
   body: bodyTypographyStyleSchema,
-  headings: z15.object({
+  headings: z17.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -2287,122 +2466,115 @@ var typographySchema = z15.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z15.enum(["comfortable", "standard", "dense"]);
-var corners = z15.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z15.object({
-  elevation: z15.enum(["none", "low", "medium", "high"]),
-  softness: z15.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z15.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z17.enum(["comfortable", "standard", "dense"]);
+var corners = z17.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z17.object({
+  elevation: z17.enum(["none", "low", "medium", "high"]),
+  softness: z17.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z17.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z15.object({
-  width: z15.enum(["none", "hairline", "thin", "thick"]),
-  style: z15.enum(["solid", "dashed"])
+var border = z17.object({
+  width: z17.enum(["none", "hairline", "thin", "thick"]),
+  style: z17.enum(["solid", "dashed"])
 });
-var motion = z15.object({
-  level: z15.enum(["off", "low", "medium", "high"]),
-  easing: z15.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z17.object({
+  level: z17.enum(["off", "low", "medium", "high"]),
+  easing: z17.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z15.object({
+var buttonStyle = z17.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z15.object({
-  elevation: z15.enum(["none", "low", "medium", "high"]),
-  border: z15.enum(["none", "subtle", "defined"]),
+var cardStyle = z17.object({
+  elevation: z17.enum(["none", "low", "medium", "high"]),
+  border: z17.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z15.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z15.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z17.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z17.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z15.object({
+var inputStyle = z17.object({
   shape: corners,
-  border: z15.enum(["subtle", "defined", "underline"]),
-  focus: z15.enum(["glow", "ring", "underline"]),
-  label: z15.enum(["inside", "above"])
+  border: z17.enum(["subtle", "defined", "underline"]),
+  focus: z17.enum(["glow", "ring", "underline"]),
+  label: z17.enum(["inside", "above"])
 });
-var headerVariant = z15.enum(["classic", "centered", "transparent", "floating", "editorial"]);
-var headerPositioning = z15.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z15.enum(["minimal", "underline", "underline-grow", "capsule", "scale", "frosted", "solid"]);
-var navFontWeight = z15.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z15.enum(["container", "full"]);
-var headerContainerSchema = z15.object({
-  rounded: z15.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z15.boolean().default(true),
-  shadow: z15.boolean().default(true),
-  padding: z15.enum(["sm", "md", "lg"]).default("md"),
-  tint: z15.string().nullable().optional(),
-  opacity: z15.number().min(0).max(1).default(0.12)
+var headerVariant = z17.enum(["classic", "centered", "transparent", "floating", "editorial"]);
+var headerPositioning = z17.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z17.enum(["minimal", "underline", "underline-grow", "capsule", "scale", "frosted", "solid"]);
+var navFontWeight = z17.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z17.enum(["container", "full"]);
+var headerContainerSchema = z17.object({
+  rounded: z17.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z17.boolean().default(true),
+  shadow: z17.boolean().default(true),
+  padding: z17.enum(["sm", "md", "lg"]).default("md"),
+  tint: z17.string().nullable().optional(),
+  opacity: z17.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z15.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z17.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z15.object({
-  fontFamily: z15.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z15.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z15.boolean().default(false)
+var logoStyleSchema = z17.object({
+  fontFamily: z17.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z17.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z17.boolean().default(false)
 }).optional();
-var headerLogoTextSchema = z15.object({
-  mobileWrapLines: z15.union([z15.literal(1), z15.literal(2)]).optional(),
-  mobileMaxWidth: z15.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z15.boolean().optional()
+var headerLogoTextSchema = z17.object({
+  mobileWrapLines: z17.union([z17.literal(1), z17.literal(2)]).optional(),
+  mobileMaxWidth: z17.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z17.boolean().optional()
 }).optional();
-var navEffectsSchema = z15.object({
-  underlineGradient: z15.boolean().default(false),
-  glow: z15.boolean().default(false),
-  glowColor: z15.string().optional(),
-  neumorphic: z15.boolean().default(false)
+var navEffectsSchema = z17.object({
+  underlineGradient: z17.boolean().default(false),
+  glow: z17.boolean().default(false),
+  glowColor: z17.string().optional(),
+  neumorphic: z17.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z15.object({
+var dropdownStyleSchema = z17.object({
   // Container styling
-  background: z15.string().default("surface"),
-  // color token
-  textColor: z15.string().default("text"),
-  // color token
-  borderColor: z15.string().nullable().default("border"),
-  // null = no border
-  shadow: z15.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z15.enum(["none", "sm", "md", "lg"]).default("md"),
+  background: themeColorTokenSchema.default("surface"),
+  textColor: themeColorTokenSchema.default("text"),
+  borderColor: themeColorTokenSchema.nullable().default("border"),
+  shadow: z17.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z17.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
-  hoverBackground: z15.string().nullable().optional(),
-  // color token, null = transparent
-  hoverTextColor: z15.string().nullable().optional(),
-  // color token, null = inherit
+  hoverBackground: themeColorTokenSchema.nullable().optional(),
+  hoverTextColor: themeColorTokenSchema.nullable().optional(),
   // Typography
-  textTransform: z15.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z15.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z15.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z17.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z17.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z17.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z15.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z17.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z15.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var headerCtaTreatmentSchema = z15.enum(["default", "primary", "secondary", "inverted", "outline", "ghost"]);
-var navContainerSchema = z15.object({
-  type: z15.enum(["none", "pill", "glass"]).default("none"),
-  tint: z15.string().nullable().optional(),
-  opacity: z15.number().min(0).max(1).default(0.15)
+var headerCtaGapSchema = z17.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var headerCtaTreatmentSchema = z17.enum(["default", "primary", "secondary", "inverted", "outline", "ghost"]);
+var navContainerSchema = z17.object({
+  type: z17.enum(["none", "pill", "glass"]).default("none"),
+  tint: z17.string().nullable().optional(),
+  opacity: z17.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z15.object({
-  type: z15.enum(["color", "gradient", "image"]),
-  color: z15.string().nullable().optional(),
+var headerBackgroundSchema = z17.object({
+  type: z17.enum(["color", "gradient", "image"]),
+  color: tokenOrCssColorValueSchema.nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  textColor: z15.string().nullable().optional()
+  textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var headerSchema = z15.object({
+var headerSchema = z17.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z15.boolean(),
+  shrinkOnScroll: z17.boolean(),
   maxWidth: headerMaxWidth,
   logoOverride: mediaSchema.nullable().optional(),
   background: headerBackgroundSchema.default({
     type: "color",
     color: "surface"
   }),
-  textColor: z15.string().nullable().optional(),
-  // Site title and general header text
+  textColor: themeColorTokenSchema.nullable().optional(),
   navStyle: headerNavStyle,
-  navColor: z15.string().nullable().optional(),
-  // Nav links (inherits textColor if not set)
+  navColor: themeColorTokenSchema.nullable().optional(),
   navWeight: navFontWeight.default("medium"),
   // New fields for header system enhancement
   container: headerContainerSchema,
@@ -2423,54 +2595,54 @@ var headerSchema = z15.object({
   // Optional theme-level CTA variant for header/nav CTA buttons.
   // Internal runtime bridge for the block renderer; prefer ctaTreatment in
   // authored Theme V2 concepts.
-  ctaVariant: z15.string().min(1).optional(),
+  ctaVariant: z17.string().min(1).optional(),
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z15.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z15.enum(["container", "full"]);
-var footerMode = z15.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z15.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z15.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z15.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var footerLogoPlacement = z15.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z15.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z15.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z15.object({
-  colorToken: z15.string().optional(),
-  hoverColorToken: z15.string().nullable().optional(),
-  decorationColorToken: z15.string().nullable().optional(),
-  underline: z15.boolean().optional()
+var footerVariant = z17.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z17.enum(["container", "full"]);
+var footerMode = z17.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z17.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z17.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z17.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var footerLogoPlacement = z17.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z17.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z17.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z17.object({
+  colorToken: themeColorTokenSchema.optional(),
+  hoverColorToken: themeColorTokenSchema.nullable().optional(),
+  decorationColorToken: themeColorTokenSchema.nullable().optional(),
+  underline: z17.boolean().optional()
 });
-var footerBottomBarSchema = z15.object({
-  enabled: z15.boolean().optional(),
-  fullBleed: z15.boolean().optional(),
+var footerBottomBarSchema = z17.object({
+  enabled: z17.boolean().optional(),
+  fullBleed: z17.boolean().optional(),
   background: headerBackgroundSchema.optional(),
-  textColor: z15.string().nullable().optional(),
-  textAlign: z15.enum(["left", "center", "right"]).optional(),
+  textColor: themeColorTokenSchema.nullable().optional(),
+  textAlign: z17.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z15.object({
-    colorToken: z15.string().nullable().optional(),
-    width: z15.enum(["none", "thin", "medium", "thick"]).optional()
+  borderTop: z17.object({
+    colorToken: themeColorTokenSchema.nullable().optional(),
+    width: z17.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z15.object({
+var footerNavLayoutSchema = z17.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z15.number().int().min(1).max(6).optional()
+  columns: z17.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z15.object({
-  showLogo: z15.boolean().default(true),
-  showLogoText: z15.boolean().optional(),
+var footerLogoSchema = z17.object({
+  showLogo: z17.boolean().default(true),
+  showLogoText: z17.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z15.enum(["start", "center", "end"]).optional()
+  align: z17.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z15.object({
+var footerSchema = z17.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -2479,14 +2651,14 @@ var footerSchema = z15.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z15.boolean().optional(),
+  showLogoText: z17.boolean().optional(),
   background: headerBackgroundSchema.default({
     type: "color",
     color: "surface"
   }),
   // Footer nav styling (independent from header)
   navStyle: headerNavStyle.default("minimal"),
-  navColor: z15.string().nullable().optional(),
+  navColor: themeColorTokenSchema.nullable().optional(),
   navWeight: navFontWeight.default("medium"),
   // Full nav link customization (overrides navStyle if set)
   navLinkStyle: navLinkStyleSchema.optional(),
@@ -2497,23 +2669,23 @@ var footerSchema = z15.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z15.enum(["tight", "compact", "default", "relaxed"]);
-var layoutSchema = z15.object({
-  containerPadding: z15.object({
+var containerPaddingPresetSchema = z17.enum(["tight", "compact", "default", "relaxed"]);
+var layoutSchema = z17.object({
+  containerPadding: z17.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z15.enum(["sm", "base", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "editorial"]);
-var heroTypographyLineHeightSchema = z15.enum(["tight", "snug", "normal", "relaxed"]);
-var heroResponsiveTypographySchema = z15.object({
+var heroTypographySizeSchema = z17.enum(["sm", "base", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "editorial"]);
+var heroTypographyLineHeightSchema = z17.enum(["tight", "snug", "normal", "relaxed"]);
+var heroResponsiveTypographySchema = z17.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z15.object({
+var heroTypographySchema = z17.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -2522,31 +2694,31 @@ var heroTypographySchema = z15.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z15.object({
+  responsive: z17.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z15.object({
+var heroSchema = z17.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var bodyTextIntroTypographySizeSchema = z15.enum(["default", "editorial"]);
-var bodyTextSchema = z15.object({
-  intro: z15.object({
+var bodyTextIntroTypographySizeSchema = z17.enum(["default", "editorial"]);
+var bodyTextSchema = z17.object({
+  intro: z17.object({
     paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
     headingSize: bodyTextIntroTypographySizeSchema.optional()
   }).optional()
 }).optional();
-var gradientsSchema = z15.object({
-  button: z15.string().min(1).nullable().optional(),
-  hero: z15.string().min(1).nullable().optional(),
-  background: z15.string().min(1).nullable().optional()
+var gradientsSchema = z17.object({
+  button: z17.string().min(1).nullable().optional(),
+  hero: z17.string().min(1).nullable().optional(),
+  background: z17.string().min(1).nullable().optional()
 });
-var themeSchema = z15.object({
-  name: z15.string().min(1).max(30),
-  description: z15.string().min(1).max(400),
-  rationale: z15.string().min(1).max(400),
-  siteStyleId: z15.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var themeSchema = z17.object({
+  name: z17.string().min(1).max(30),
+  description: z17.string().min(1).max(400),
+  rationale: z17.string().min(1).max(400),
+  siteStyleId: z17.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -2574,15 +2746,15 @@ var themeSchema = z15.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z15.record(
-    z15.string(),
+  blockCustomVars: z17.record(
+    z17.string(),
     // block kind (matches data-block attribute)
-    z15.record(z15.string(), z15.string())
+    z17.record(z17.string(), z17.string())
     // { '--var-name': 'value' }
   ).optional(),
   // Structured block-kind theme overrides (v1: typography prose-link style only)
   // Keyed by block kind (usually data-block value like "hero"; "block.hero" also accepted)
-  blockOverrides: z15.record(z15.string(), blockThemeOverrideSchema).optional(),
+  blockOverrides: z17.record(z17.string(), blockThemeOverrideSchema).optional(),
   // Structured custom CSS rules
   // Validated, scoped, and safe by construction - no @import, remote url(), or global selectors
   customCssRules: customCssRulesSchema,
@@ -2616,11 +2788,11 @@ var themeSchema = z15.object({
    * }
    * ```
    */
-  styleGroups: z15.record(z15.string(), z15.array(z15.string())).optional()
+  styleGroups: z17.record(z17.string(), z17.array(z17.string())).optional()
 });
-var themesTurnSchema = z15.object({
-  message: z15.string().min(1),
-  themes: z15.array(themeSchema).length(3)
+var themesTurnSchema = z17.object({
+  message: z17.string().min(1),
+  themes: z17.array(themeSchema).length(3)
 });
 
 // ../theme-core/src/palette/variants/types.ts
@@ -2630,35 +2802,19 @@ function asPaletteVariantId(value) {
   }
   return value;
 }
-var paletteVariantIdSchema = z16.string().min(1).transform((value) => asPaletteVariantId(value));
-var PALETTE_TOKEN_NAMES = [
-  "primary",
-  "primaryForeground",
-  "secondary",
-  "accent",
-  "success",
-  "warning",
-  "destructive",
-  "background",
-  "surface",
-  "surfaceAlt",
-  "muted",
-  "text",
-  "border"
-];
-var paletteTokenNameSchema = z16.enum(PALETTE_TOKEN_NAMES);
+var paletteVariantIdSchema = z18.string().min(1).transform((value) => asPaletteVariantId(value));
 var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z16.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var hexColorSchema = z18.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
 var variantPaletteColorSchema = paletteColorSchema.extend({
   name: paletteTokenNameSchema
 });
-var paletteVariantSchema = z16.object({
+var paletteVariantSchema = z18.object({
   id: paletteVariantIdSchema,
-  name: z16.string().min(1),
-  description: z16.string().min(1),
+  name: z18.string().min(1),
+  description: z18.string().min(1),
   tags: styleTagsSchema,
-  mode: z16.enum(["light", "dark"]),
-  colors: z16.array(variantPaletteColorSchema).min(1)
+  mode: z18.enum(["light", "dark"]),
+  colors: z18.array(variantPaletteColorSchema).min(1)
 });
 function definePaletteVariant(input) {
   return {
@@ -2670,7 +2826,7 @@ function definePaletteVariant(input) {
     colors: input.colors
   };
 }
-var paletteOverridesSchema = z16.object({
+var paletteOverridesSchema = z18.object({
   primary: hexColorSchema.optional(),
   primaryForeground: hexColorSchema.optional(),
   secondary: hexColorSchema.optional(),
@@ -3004,6 +3160,409 @@ var paletteVariantsById = new Map(
   paletteVariants.map((v) => [v.id, v])
 );
 
+// ../theme-core/src/site-styles/headerLooks.ts
+function asHeaderLookId(value) {
+  return value;
+}
+function baseHeader(theme) {
+  return {
+    ...theme.header,
+    navLinkStyle: void 0,
+    dropdownStyle: void 0,
+    ctaVariant: void 0
+  };
+}
+function solidBrandHeader(theme) {
+  const ctaVariant = resolveHeaderCtaVariant(theme, "inverted");
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "primary"
+    },
+    textColor: "primaryForeground",
+    navColor: "primaryForeground",
+    navStyle: "underline-grow",
+    navWeight: "bold",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "bold",
+      textTransform: "uppercase",
+      italic: false,
+      colorToken: "primaryForeground",
+      hoverColorToken: "secondary",
+      textSize: "sm",
+      letterSpacing: "wider",
+      padding: "compact",
+      paddingX: "compact",
+      borderRadius: "none",
+      effects: {
+        hover: [
+          { effectId: "text-color-change", options: { hoverColorToken: "secondary" } },
+          { effectId: "nav-underline", options: { style: "grow", colorToken: "secondary" } }
+        ]
+      }
+    },
+    dropdownStyle: {
+      background: "primary-700",
+      textColor: "primaryForeground",
+      borderColor: null,
+      shadow: "md",
+      borderRadius: "md",
+      hoverBackground: "primary-900",
+      hoverTextColor: "secondary",
+      textTransform: "uppercase",
+      letterSpacing: "wider",
+      fontWeight: "bold",
+      textSize: "sm"
+    },
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    logoText: {
+      hideOnShrink: true,
+      mobileMaxWidth: "sm",
+      mobileWrapLines: 2
+    },
+    ctaGap: "compact",
+    ctaTreatment: "inverted",
+    ...ctaVariant ? { ctaVariant } : {}
+  };
+}
+function cleanBaseHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "minimal",
+    navWeight: "medium",
+    border: {
+      style: "solid",
+      width: "thin",
+      position: "bottom",
+      colorToken: "border"
+    },
+    ctaTreatment: "default",
+    ctaGap: "default"
+  };
+}
+function editorialLineHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "editorial",
+    positioning: "sticky",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "background"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "underline-grow",
+    navWeight: "medium",
+    logo: {
+      fontFamily: "heading",
+      letterSpacing: "wide",
+      gradient: false
+    },
+    ctaTreatment: "outline",
+    ctaVariant: resolveHeaderCtaVariant(theme, "outline"),
+    ctaGap: "relaxed"
+  };
+}
+function centeredCalmHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "centered",
+    positioning: "static",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "minimal",
+    navWeight: "medium",
+    ctaTreatment: "ghost",
+    ctaVariant: resolveHeaderCtaVariant(theme, "ghost"),
+    ctaGap: "none"
+  };
+}
+function practicalUtilityHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "solid",
+    navWeight: "semibold",
+    shadow: {
+      elevation: "sm"
+    },
+    border: {
+      style: "solid",
+      width: "thin",
+      position: "bottom",
+      colorToken: "border"
+    },
+    ctaTreatment: "primary",
+    ctaVariant: resolveHeaderCtaVariant(theme, "primary"),
+    ctaGap: "compact",
+    logoText: {
+      mobileMaxWidth: "sm",
+      mobileWrapLines: 1,
+      hideOnShrink: false
+    }
+  };
+}
+function minimalTransparentHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "static",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "transparent"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "underline",
+    navWeight: "medium",
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    ctaTreatment: "outline",
+    ctaVariant: resolveHeaderCtaVariant(theme, "outline"),
+    ctaGap: "default"
+  };
+}
+function transparentOverlayHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "transparent",
+    positioning: "fixed",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "transparent"
+    },
+    textColor: "background",
+    navColor: "background",
+    navStyle: "frosted",
+    navWeight: "semibold",
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    ctaTreatment: "inverted",
+    ctaVariant: resolveHeaderCtaVariant(theme, "inverted"),
+    ctaGap: "compact"
+  };
+}
+function floatingGlassHeader(theme) {
+  return {
+    ...transparentOverlayHeader(theme),
+    variant: "floating",
+    navStyle: "frosted",
+    navContainer: {
+      type: "glass",
+      tint: "text",
+      opacity: 0.16
+    },
+    container: {
+      rounded: "2xl",
+      border: true,
+      shadow: true,
+      padding: "sm",
+      tint: "background",
+      opacity: 0.12
+    }
+  };
+}
+var headerLookCatalog = [
+  {
+    id: asHeaderLookId("clean-base"),
+    label: "Clean base",
+    visualTreatment: "solid-neutral",
+    layoutBehavior: "sticky",
+    openingRequirement: "none",
+    compile: cleanBaseHeader
+  },
+  {
+    id: asHeaderLookId("brand-solid"),
+    label: "Brand solid",
+    visualTreatment: "solid-brand",
+    layoutBehavior: "sticky-shrink",
+    openingRequirement: "none",
+    compile: solidBrandHeader
+  },
+  {
+    id: asHeaderLookId("editorial-line"),
+    label: "Editorial line",
+    visualTreatment: "light-editorial",
+    layoutBehavior: "sticky",
+    openingRequirement: "none",
+    maxRecommendedNavItems: 6,
+    compile: editorialLineHeader
+  },
+  {
+    id: asHeaderLookId("centered-calm"),
+    label: "Centered calm",
+    visualTreatment: "light-editorial",
+    layoutBehavior: "normal-flow",
+    openingRequirement: "none",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal", "square"],
+    compile: centeredCalmHeader
+  },
+  {
+    id: asHeaderLookId("practical-utility"),
+    label: "Practical utility",
+    visualTreatment: "solid-neutral",
+    layoutBehavior: "sticky-shrink",
+    openingRequirement: "none",
+    requiresProminentCta: true,
+    compile: practicalUtilityHeader
+  },
+  {
+    id: asHeaderLookId("minimal-transparent"),
+    label: "Minimal transparent",
+    visualTreatment: "minimal-transparent",
+    layoutBehavior: "normal-flow",
+    openingRequirement: "reserved-space-ok",
+    compile: minimalTransparentHeader
+  },
+  {
+    id: asHeaderLookId("transparent-overlay"),
+    label: "Transparent overlay",
+    visualTreatment: "transparent-overlay",
+    layoutBehavior: "fixed-overlay",
+    openingRequirement: "requires-image-hero-with-contrast-overlay",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal"],
+    compile: transparentOverlayHeader
+  },
+  {
+    id: asHeaderLookId("floating-glass"),
+    label: "Floating glass",
+    visualTreatment: "floating-glass",
+    layoutBehavior: "fixed-floating",
+    openingRequirement: "requires-image-hero-with-contrast-overlay",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal"],
+    compile: floatingGlassHeader
+  }
+];
+var guaranteedFallbackHeaderLookId = asHeaderLookId("clean-base");
+var headerLooksById = new Map(
+  headerLookCatalog.map((look) => [look.id, look])
+);
+
+// ../theme-core/src/site-styles/footerLooks.ts
+function asFooterLookId(value) {
+  return value;
+}
+var guaranteedFallbackFooterLookId = asFooterLookId("footer-muted-grounding");
+function mutedGroundingFooter(theme) {
+  return theme.footer;
+}
+function brandTwoBandFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "split",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "primary-800"
+    },
+    navStyle: "minimal",
+    navWeight: "medium",
+    navColor: "primaryForeground",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "medium",
+      textTransform: "none",
+      italic: false,
+      colorToken: "primaryForeground",
+      hoverColorToken: "secondary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    bottomTextLinkStyle: {
+      colorToken: "secondary",
+      decorationColorToken: "secondary"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "default",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: false,
+      placement: "left",
+      size: "sm",
+      align: "start"
+    },
+    bottomBar: {
+      enabled: true,
+      fullBleed: true,
+      background: {
+        type: "color",
+        color: "primary-900"
+      },
+      textColor: "primaryForeground",
+      textAlign: "center",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "none"
+      }
+    }
+  };
+}
+var footerLookCatalog = [
+  {
+    id: asFooterLookId("footer-muted-grounding"),
+    label: "Muted grounding footer",
+    compile: mutedGroundingFooter
+  },
+  {
+    id: asFooterLookId("site-footer-brand-two-band"),
+    label: "Two-band brand footer",
+    maxRecommendedNavDensity: "balanced",
+    allowedContentPresence: ["default-footer", "default-and-blocks"],
+    compile: brandTwoBandFooter
+  }
+];
+var footerLooksById = new Map(
+  footerLookCatalog.map((look) => [look.id, look])
+);
+
 // ../theme-core/src/site-styles/sourceCatalogs.ts
 var generatedContentFrames = [
   plainFrame,
@@ -3019,7 +3578,7 @@ var userContentFrames = [
 ];
 var generatedDesignOptionCatalog = {
   source: "generated",
-  sectionSurfaces: ["base", "muted-band", "accent-band", "hero-image"],
+  sectionSurfaces: ["base", "muted-band", "accent-band", "brand-depth-band", "hero-image"],
   contentFrames: generatedContentFrames,
   itemSurfaces: ["none", "default", "flat", "outlined", "raised"],
   transitions: ["none", "soft-fade-short", "soft-fade-long"],
@@ -3089,6 +3648,43 @@ var expressiveBudget = {
   mediaDensity: "high",
   decorativeRepetition: "medium"
 };
+var expressiveUnderlineInputs = {
+  base: {
+    background: { type: "transparent" },
+    textColorToken: "text",
+    border: {
+      widthClass: "border-2",
+      colorToken: "border",
+      style: "underline"
+    },
+    corners: "square",
+    shadow: null,
+    spacing: "compact",
+    fontSize: "base"
+  },
+  label: {
+    textColorToken: "primary",
+    fontWeight: "black",
+    fontSize: "xs",
+    textTransform: "uppercase",
+    letterSpacing: "widest",
+    opacity: 1
+  },
+  focus: {
+    ringColorToken: "secondary",
+    ringWidth: "0",
+    borderColorToken: "secondary"
+  },
+  error: {
+    borderColorToken: "destructive",
+    textColorToken: "destructive"
+  },
+  disabled: {
+    backgroundColorToken: "surface",
+    textColorToken: "text",
+    opacity: 0.6
+  }
+};
 function uniqueContentFrameKinds() {
   const kinds = [...new Set(
     generatedDesignOptionCatalog.contentFrames.map((frame) => frame.kind)
@@ -3120,6 +3716,9 @@ function defineCuratedSiteStyle(input) {
     },
     ...input.themeOverrides ? { themeOverrides: input.themeOverrides } : {},
     recommendedAppearancePresetIds: (input.recommendedAppearancePresetIds ?? []).map(asAppearancePresetId),
+    recommendedHeaderLookIds: (input.recommendedHeaderLookIds ?? ["clean-base"]).map(asHeaderLookId),
+    // Empty is intentional: resolveFooterLook always appends its guaranteed fallback.
+    recommendedFooterLookIds: (input.recommendedFooterLookIds ?? []).map(asFooterLookId),
     buttonPersonalityChoices: input.buttonPersonalityChoices,
     paletteVariantChoices: input.paletteVariantChoices
   };
@@ -3146,6 +3745,7 @@ var curatedSiteStyles = [
       motion: "subtle"
     },
     compositionBudget: quietBudget,
+    recommendedHeaderLookIds: ["centered-calm", "minimal-transparent", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("soft-pill"),
       buttonChoice("pebble"),
@@ -3174,6 +3774,7 @@ var curatedSiteStyles = [
       motion: "subtle"
     },
     compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: ["practical-utility", "brand-solid", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("confident-chip"),
       buttonChoice("soft-pill"),
@@ -3200,6 +3801,7 @@ var curatedSiteStyles = [
       motion: "subtle"
     },
     compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: ["editorial-line", "minimal-transparent", "centered-calm"],
     buttonPersonalityChoices: [
       buttonChoice("editorial-link"),
       buttonChoice("soft-pill"),
@@ -3227,6 +3829,7 @@ var curatedSiteStyles = [
       motion: "expressive"
     },
     compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: ["brand-solid", "practical-utility", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("pebble"),
       buttonChoice("brushed-wash"),
@@ -3260,6 +3863,7 @@ var curatedSiteStyles = [
       motion: "none"
     },
     compositionBudget: quietBudget,
+    recommendedHeaderLookIds: ["minimal-transparent", "editorial-line", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("editorial-link"),
       buttonChoice("confident-chip"),
@@ -3294,6 +3898,7 @@ var curatedSiteStyles = [
       motion: "none"
     },
     compositionBudget: quietBudget,
+    recommendedHeaderLookIds: ["practical-utility", "brand-solid", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("confident-chip"),
       buttonChoice("pebble"),
@@ -3320,6 +3925,7 @@ var curatedSiteStyles = [
       motion: "subtle"
     },
     compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: ["centered-calm", "minimal-transparent", "clean-base"],
     buttonPersonalityChoices: [
       buttonChoice("soft-pill"),
       buttonChoice("pebble"),
@@ -3354,6 +3960,7 @@ var curatedSiteStyles = [
       motion: "expressive"
     },
     compositionBudget: expressiveBudget,
+    recommendedHeaderLookIds: ["transparent-overlay", "floating-glass", "brand-solid"],
     buttonPersonalityChoices: [
       buttonChoice("ink-stamp"),
       buttonChoice("confident-chip"),
@@ -3439,16 +4046,18 @@ var curatedSiteStyles = [
           paragraphSize: "editorial",
           headingSize: "editorial"
         }
-      }
+      },
+      inputs: expressiveUnderlineInputs
     },
     recommendedAppearancePresetIds: [
-      "site-header-brand-solid-inverted-cta",
-      "site-footer-brand-two-band",
       "hero-brand-scrim-fixed-frame",
       "body-text-editorial-intro",
+      "schedule-details-brand-depth",
       "testimonials-accent-quote-proof",
-      "contact-form-dark-card"
+      "contact-form-brand-depth-card"
     ],
+    recommendedHeaderLookIds: ["brand-solid", "transparent-overlay", "practical-utility"],
+    recommendedFooterLookIds: ["site-footer-brand-two-band", "footer-muted-grounding"],
     buttonPersonalityChoices: [
       buttonChoice("showtime-pill"),
       buttonChoice("confident-chip"),
@@ -3467,6 +4076,14 @@ var curatedSiteStylesById = new Map(
   curatedSiteStyles.map((style) => [style.id, style])
 );
 
+// ../theme-core/src/site-styles/siteStyleBlockPolicies.ts
+var defaultPolicyPageFlowPresetId = asPageFlowPresetId("generated-default");
+var southWestTwerkSchoolSiteStyleId = asSiteStyleId("site-style:south-west-twerk-school");
+var heroBrandScrimFixedFrameLookId = asAppearancePresetId("hero-brand-scrim-fixed-frame");
+var classicHeroLayoutVariantKey = asLayoutVariantKey("classic");
+var microHeroLayoutVariantKey = asLayoutVariantKey("micro");
+var waveBoundaryOptionId = asBoundaryOptionId("break:wave");
+
 // ../theme-core/src/site-styles/pageDesignEditorModel.ts
 var noneBoundaryOption = {
   id: asBoundaryOptionId("break:none"),
@@ -3510,7 +4127,7 @@ var pageFlowPresets = [
 ];
 
 // ../theme-core/src/site-styles/designState.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // ../theme-core/src/site-styles/rawStyleFields.ts
 var themeV2RuntimeStyleFieldNames = [
@@ -3536,52 +4153,53 @@ var themeV2NormalEditorRawStyleFieldNameSet = new Set(
 
 // ../theme-core/src/site-styles/designState.ts
 var themeV2DesignStateSchemaVersion = 1;
-var designResolutionPolicySchema = z17.enum(["generated", "user", "admin", "sdk"]);
-var runtimeStyleFieldNameSchema = z17.enum(themeV2RuntimeStyleFieldNames);
-var nonEmptyRuntimeStyleFieldNamesSchema = z17.array(runtimeStyleFieldNameSchema).min(1).transform((fields) => [
+var designResolutionPolicySchema = z19.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z19.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z19.array(runtimeStyleFieldNameSchema).min(1).transform((fields) => [
   fields[0],
   ...fields.slice(1)
 ]);
-var heroLegibilityStrategySchema = z17.enum([
+var heroLegibilityStrategySchema = z19.enum([
   "none",
   "scrim-gradient",
   "solid-panel"
 ]);
-var sectionHeightIntentSchema = z17.enum([
+var sectionHeightIntentSchema = z19.enum([
   "default",
   "banner",
   "hero",
   "immersive"
 ]);
-var imageSurfaceTreatmentIntensitySchema = z17.enum(["soft", "balanced", "strong"]);
-var imageSurfaceMotionSchema = z17.enum(["static", "fixed-frame"]);
-var imageSurfaceTreatmentSchema = z17.discriminatedUnion("kind", [
-  z17.object({ kind: z17.literal("none") }).strict(),
-  z17.object({
-    kind: z17.literal("brand-scrim"),
-    token: z17.enum(["primary", "secondary", "accent"]),
+var imageSurfaceTreatmentIntensitySchema = z19.enum(["soft", "balanced", "strong"]);
+var imageSurfaceMotionSchema = z19.enum(["static", "fixed-frame"]);
+var imageSurfaceTreatmentSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("none") }).strict(),
+  z19.object({
+    kind: z19.literal("brand-scrim"),
+    token: z19.enum(["primary", "secondary", "accent"]),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("brand-wash"),
-    token: z17.enum(["primary", "secondary", "accent"]),
+  z19.object({
+    kind: z19.literal("brand-wash"),
+    token: z19.enum(["primary", "secondary", "accent"]),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("neutral-scrim"),
+  z19.object({
+    kind: z19.literal("neutral-scrim"),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("neutral-wash"),
+  z19.object({
+    kind: z19.literal("neutral-wash"),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("solid-panel"),
+  z19.object({
+    kind: z19.literal("solid-panel"),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict()
 ]);
-var testimonialCardTreatmentSchema = z17.enum(["default", "accent-quote"]);
-var eyebrowTreatmentSchema = z17.enum(eyebrowTreatmentValues);
+var testimonialCardTreatmentSchema = z19.enum(["default", "accent-quote"]);
+var tileTreatmentSchema = z19.enum(tileTreatmentValues);
+var eyebrowTreatmentSchema = z19.enum(eyebrowTreatmentValues);
 function uniqueNonEmpty(values) {
   const uniqueValues = [...new Set(values)];
   const firstValue = uniqueValues[0];
@@ -3599,67 +4217,68 @@ var userFlushTreatments = uniqueNonEmpty(
 var userFlushBleeds = uniqueNonEmpty(
   userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var contentFrameIntentSchema = z17.discriminatedUnion("kind", [
-  z17.object({ kind: z17.literal("plain") }).strict(),
-  z17.object({
-    kind: z17.literal("panel"),
-    treatment: z17.enum(userPanelTreatments)
+var contentFrameIntentSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("plain") }).strict(),
+  z19.object({
+    kind: z19.literal("panel"),
+    treatment: z19.enum(userPanelTreatments)
   }).strict(),
-  z17.object({
-    kind: z17.literal("flush-panel"),
-    treatment: z17.enum(userFlushTreatments),
-    bleed: z17.enum(userFlushBleeds)
+  z19.object({
+    kind: z19.literal("flush-panel"),
+    treatment: z19.enum(userFlushTreatments),
+    bleed: z19.enum(userFlushBleeds)
   }).strict()
 ]);
-var blockDesignPlanSchema = z17.object({
-  blockId: z17.string().min(1).transform(asDesignBlockId),
-  blockKind: z17.string().min(1),
-  purpose: z17.string().min(1),
-  sectionSurface: z17.enum(userDesignOptionCatalog.sectionSurfaces),
+var blockDesignPlanSchema = z19.object({
+  blockId: z19.string().min(1).transform(asDesignBlockId),
+  blockKind: z19.string().min(1),
+  purpose: z19.string().min(1),
+  sectionSurface: z19.enum(userDesignOptionCatalog.sectionSurfaces),
   contentFrame: contentFrameIntentSchema,
-  itemSurface: z17.enum(userDesignOptionCatalog.itemSurfaces),
-  transitionAfter: z17.enum(userDesignOptionCatalog.transitions),
-  emphasis: z17.enum(userDesignOptionCatalog.emphases),
+  itemSurface: z19.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z19.enum(userDesignOptionCatalog.transitions),
+  emphasis: z19.enum(userDesignOptionCatalog.emphases),
   sectionHeight: sectionHeightIntentSchema.optional(),
   heroLegibility: heroLegibilityStrategySchema.optional(),
   imageSurfaceTreatment: imageSurfaceTreatmentSchema.optional(),
   imageSurfaceMotion: imageSurfaceMotionSchema.optional(),
   testimonialCardTreatment: testimonialCardTreatmentSchema.optional(),
+  tileTreatment: tileTreatmentSchema.optional(),
   eyebrowTreatment: eyebrowTreatmentSchema.optional()
 }).strict();
-var styleAuthoritySchema = z17.discriminatedUnion("kind", [
-  z17.object({
-    kind: z17.literal("theme-v2"),
+var styleAuthoritySchema = z19.discriminatedUnion("kind", [
+  z19.object({
+    kind: z19.literal("theme-v2"),
     source: designResolutionPolicySchema,
-    siteStyleId: z17.string().min(1).transform(asSiteStyleId),
-    templateId: z17.string().min(1).transform(asDesignSystemTemplateId),
-    templateVersion: z17.number().int().nonnegative(),
-    resolverVersion: z17.number().int().nonnegative()
+    siteStyleId: z19.string().min(1).transform(asSiteStyleId),
+    templateId: z19.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z19.number().int().nonnegative(),
+    resolverVersion: z19.number().int().nonnegative()
   }).strict(),
-  z17.object({
-    kind: z17.literal("legacy-raw"),
-    reason: z17.enum(["pre-theme-v2", "manual-runtime-fields"])
+  z19.object({
+    kind: z19.literal("legacy-raw"),
+    reason: z19.enum(["pre-theme-v2", "manual-runtime-fields"])
   }).strict(),
-  z17.object({
-    kind: z17.literal("advanced-detached"),
-    reason: z17.literal("detached-custom-runtime-fields")
+  z19.object({
+    kind: z19.literal("advanced-detached"),
+    reason: z19.literal("detached-custom-runtime-fields")
   }).strict()
 ]);
-var blockRuntimeStyleAuthoritySchema = z17.object({
-  unit: z17.literal("block-runtime-fields"),
-  blockId: z17.string().min(1).transform(asDesignBlockId),
+var blockRuntimeStyleAuthoritySchema = z19.object({
+  unit: z19.literal("block-runtime-fields"),
+  blockId: z19.string().min(1).transform(asDesignBlockId),
   fields: nonEmptyRuntimeStyleFieldNamesSchema,
   authority: styleAuthoritySchema
 }).strict();
-var persistedPageDesignStateV1Schema = z17.object({
-  schemaVersion: z17.literal(themeV2DesignStateSchemaVersion),
-  siteStyleId: z17.string().min(1).transform(asSiteStyleId),
-  templateId: z17.string().min(1).transform(asDesignSystemTemplateId),
-  templateVersion: z17.number().int().nonnegative(),
-  resolverVersion: z17.number().int().nonnegative(),
-  rhythmPresetId: z17.string().min(1),
-  blocks: z17.array(blockDesignPlanSchema),
-  styleAuthorities: z17.array(blockRuntimeStyleAuthoritySchema)
+var persistedPageDesignStateV1Schema = z19.object({
+  schemaVersion: z19.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z19.string().min(1).transform(asSiteStyleId),
+  templateId: z19.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z19.number().int().nonnegative(),
+  resolverVersion: z19.number().int().nonnegative(),
+  rhythmPresetId: z19.string().min(1),
+  blocks: z19.array(blockDesignPlanSchema),
+  styleAuthorities: z19.array(blockRuntimeStyleAuthoritySchema)
 }).strict();
 
 // ../theme-core/src/site-styles/runtimeCompiler.ts
@@ -3688,6 +4307,14 @@ var defaultDesignRuntimeRules = defineDesignRuntimeRules({
         headingColor: "primaryForeground"
       }
     },
+    "brand-depth-band": {
+      background: {
+        type: "color",
+        color: "primary-800",
+        textColor: "primaryForeground",
+        headingColor: "primaryForeground"
+      }
+    },
     "hero-image": {
       background: {
         type: "image",
@@ -3804,7 +4431,7 @@ var defaultComponentRuntimeRules = defineComponentRuntimeRules({
 });
 
 // ../theme-core/src/site-styles/generatedSchemas.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 function uniqueNonEmpty2(values) {
   const uniqueValues = [...new Set(values)];
   const firstValue = uniqueValues[0];
@@ -3822,155 +4449,155 @@ var generatedFlushTreatments = uniqueNonEmpty2(
 var generatedFlushBleeds = uniqueNonEmpty2(
   generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var generatedPanelFrameSchema = z18.object({
-  kind: z18.literal("panel"),
-  treatment: z18.enum(generatedPanelTreatments)
+var generatedPanelFrameSchema = z20.object({
+  kind: z20.literal("panel"),
+  treatment: z20.enum(generatedPanelTreatments)
 }).strict();
-var generatedFlushPanelFrameSchema = z18.object({
-  kind: z18.literal("flush-panel"),
-  treatment: z18.enum(generatedFlushTreatments),
-  bleed: z18.enum(generatedFlushBleeds)
+var generatedFlushPanelFrameSchema = z20.object({
+  kind: z20.literal("flush-panel"),
+  treatment: z20.enum(generatedFlushTreatments),
+  bleed: z20.enum(generatedFlushBleeds)
 }).strict();
-var generatedContentFrameIntentSchema = z18.discriminatedUnion("kind", [
-  z18.object({ kind: z18.literal("plain") }).strict(),
+var generatedContentFrameIntentSchema = z20.discriminatedUnion("kind", [
+  z20.object({ kind: z20.literal("plain") }).strict(),
   generatedPanelFrameSchema,
   generatedFlushPanelFrameSchema
 ]);
-var generatedSiteStyleIdSchema = z18.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
+var generatedSiteStyleIdSchema = z20.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
 function generatedChoiceSchema(valueSchema) {
-  return z18.discriminatedUnion("kind", [
-    z18.object({
-      source: z18.literal("generated"),
-      kind: z18.literal("auto")
+  return z20.discriminatedUnion("kind", [
+    z20.object({
+      source: z20.literal("generated"),
+      kind: z20.literal("auto")
     }).strict(),
-    z18.object({
-      source: z18.literal("generated"),
-      kind: z18.literal("explicit"),
+    z20.object({
+      source: z20.literal("generated"),
+      kind: z20.literal("explicit"),
       value: valueSchema
     }).strict()
   ]);
 }
-var generatedBlockDesignIntentSchema = z18.object({
+var generatedBlockDesignIntentSchema = z20.object({
   sectionSurface: generatedChoiceSchema(
-    z18.enum(generatedDesignOptionCatalog.sectionSurfaces)
+    z20.enum(generatedDesignOptionCatalog.sectionSurfaces)
   ),
   contentFrame: generatedChoiceSchema(generatedContentFrameIntentSchema),
   itemSurface: generatedChoiceSchema(
-    z18.enum(generatedDesignOptionCatalog.itemSurfaces)
+    z20.enum(generatedDesignOptionCatalog.itemSurfaces)
   ),
   transitionAfter: generatedChoiceSchema(
-    z18.enum(generatedDesignOptionCatalog.transitions)
+    z20.enum(generatedDesignOptionCatalog.transitions)
   ),
   emphasis: generatedChoiceSchema(
-    z18.enum(generatedDesignOptionCatalog.emphases)
+    z20.enum(generatedDesignOptionCatalog.emphases)
   )
 }).strict();
-var generatedMediaCompositionIntentSchema = z18.enum([
+var generatedMediaCompositionIntentSchema = z20.enum([
   "none",
   "supporting",
   "dominant"
 ]);
-var generatedDecorativeCompositionIntentSchema = z18.enum([
+var generatedDecorativeCompositionIntentSchema = z20.enum([
   "none",
   "supporting"
 ]);
-var generatedHeroLegibilityStrategySchema = z18.enum([
+var generatedHeroLegibilityStrategySchema = z20.enum([
   "none",
   "scrim-gradient"
 ]);
-var generatedBlockMediaIntentSchema = z18.object({
+var generatedBlockMediaIntentSchema = z20.object({
   media: generatedMediaCompositionIntentSchema,
   decorative: generatedDecorativeCompositionIntentSchema,
   heroLegibility: generatedChoiceSchema(generatedHeroLegibilityStrategySchema)
 }).strict();
-var generatedBoundaryIntentSchema = z18.object({
+var generatedBoundaryIntentSchema = z20.object({
   transitionAfter: generatedChoiceSchema(
-    z18.enum(generatedDesignOptionCatalog.transitions)
+    z20.enum(generatedDesignOptionCatalog.transitions)
   )
 }).strict();
-var generatedPageDesignBlockIntentSchema = z18.object({
-  blockId: z18.string().min(1),
-  blockKind: z18.string().min(1),
-  purpose: z18.string().min(1),
+var generatedPageDesignBlockIntentSchema = z20.object({
+  blockId: z20.string().min(1),
+  blockKind: z20.string().min(1),
+  purpose: z20.string().min(1),
   design: generatedBlockDesignIntentSchema,
   mediaIntent: generatedBlockMediaIntentSchema,
   boundaryIntent: generatedBoundaryIntentSchema
 }).strict();
-var generatedPageDesignIntentSchema = z18.object({
+var generatedPageDesignIntentSchema = z20.object({
   siteStyleId: generatedSiteStyleIdSchema,
-  blocks: z18.array(generatedPageDesignBlockIntentSchema)
+  blocks: z20.array(generatedPageDesignBlockIntentSchema)
 }).strict();
 
 // ../theme-core/src/site-styles/pageDesignAuthority.ts
-import { z as z19 } from "zod";
-var nonEmptyStringSchema = z19.string().min(1);
+import { z as z21 } from "zod";
+var nonEmptyStringSchema = z21.string().min(1);
 var blockContentVersionIdSchema = nonEmptyStringSchema.transform(asBlockContentVersionId);
 var designBlockIdSchema = nonEmptyStringSchema.transform(asDesignBlockId);
 var designPageIdSchema = nonEmptyStringSchema.transform(asDesignPageId);
 var designEntryIdSchema = nonEmptyStringSchema.transform(asDesignEntryId);
-var blockOrderIndexSchema = z19.number().int().nonnegative().transform(asBlockOrderIndex);
-var publishedPageBlockSnapshotSchema = z19.object({
-  kind: z19.literal("published-block-content"),
+var blockOrderIndexSchema = z21.number().int().nonnegative().transform(asBlockOrderIndex);
+var publishedPageBlockSnapshotSchema = z21.object({
+  kind: z21.literal("published-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema,
-  identifier: z19.string().nullable(),
+  identifier: z21.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var draftPageBlockSnapshotSchema = z19.object({
-  kind: z19.literal("draft-block-content"),
+var draftPageBlockSnapshotSchema = z21.object({
+  kind: z21.literal("draft-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema.nullable(),
-  identifier: z19.string().nullable(),
+  identifier: z21.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var missingPageBlockSnapshotSchema = z19.object({
-  kind: z19.literal("missing-block-content"),
+var missingPageBlockSnapshotSchema = z21.object({
+  kind: z21.literal("missing-block-content"),
   blockId: designBlockIdSchema,
-  identifier: z19.string().nullable(),
+  identifier: z21.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema,
-  reason: z19.enum([
+  reason: z21.enum([
     "new-block",
     "deleted-content-version",
     "unpublished-block"
   ])
 }).strict();
-var pageBlockSnapshotSchema = z19.discriminatedUnion("kind", [
+var pageBlockSnapshotSchema = z21.discriminatedUnion("kind", [
   publishedPageBlockSnapshotSchema,
   draftPageBlockSnapshotSchema,
   missingPageBlockSnapshotSchema
 ]);
-var publishedPageBlockSequenceSchema = z19.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var draftPageBlockSequenceSchema = z19.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var publishedPageDesignVersionDataV1Schema = z19.object({
-  schemaVersion: z19.literal(1),
-  stage: z19.literal("published"),
+var publishedPageBlockSequenceSchema = z21.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var draftPageBlockSequenceSchema = z21.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var publishedPageDesignVersionDataV1Schema = z21.object({
+  schemaVersion: z21.literal(1),
+  stage: z21.literal("published"),
   pageId: designPageIdSchema,
   blockSequence: publishedPageBlockSequenceSchema
 }).strict();
-var draftPageDesignVersionDataV1Schema = z19.object({
-  schemaVersion: z19.literal(1),
-  stage: z19.literal("draft"),
+var draftPageDesignVersionDataV1Schema = z21.object({
+  schemaVersion: z21.literal(1),
+  stage: z21.literal("draft"),
   pageId: designPageIdSchema,
   blockSequence: draftPageBlockSequenceSchema
 }).strict();
-var pageDesignVersionDataV1Schema = z19.discriminatedUnion("stage", [
+var pageDesignVersionDataV1Schema = z21.discriminatedUnion("stage", [
   publishedPageDesignVersionDataV1Schema,
   draftPageDesignVersionDataV1Schema
 ]);
-var contentVersionOwnerSchema = z19.discriminatedUnion("kind", [
-  z19.object({
-    kind: z19.literal("block"),
+var contentVersionOwnerSchema = z21.discriminatedUnion("kind", [
+  z21.object({
+    kind: z21.literal("block"),
     blockId: designBlockIdSchema
   }).strict(),
-  z19.object({
-    kind: z19.literal("entry"),
+  z21.object({
+    kind: z21.literal("entry"),
     entryId: designEntryIdSchema
   }).strict(),
-  z19.object({
-    kind: z19.literal("page"),
+  z21.object({
+    kind: z21.literal("page"),
     pageId: designPageIdSchema
   }).strict()
 ]);
@@ -3987,7 +4614,7 @@ function collectBlockSequenceIssues(snapshots) {
   snapshots.forEach((snapshot, index) => {
     if (seenBlockIds.has(snapshot.blockId)) {
       issues.push({
-        code: z19.ZodIssueCode.custom,
+        code: z21.ZodIssueCode.custom,
         message: `Duplicate blockId in page design blockSequence: ${snapshot.blockId}`,
         path: [index, "blockId"]
       });
@@ -3996,7 +4623,7 @@ function collectBlockSequenceIssues(snapshots) {
     const orderIndex = snapshot.orderIndex;
     if (seenOrderIndexes.has(orderIndex)) {
       issues.push({
-        code: z19.ZodIssueCode.custom,
+        code: z21.ZodIssueCode.custom,
         message: `Duplicate orderIndex in page design blockSequence: ${String(orderIndex)}`,
         path: [index, "orderIndex"]
       });
@@ -4004,7 +4631,7 @@ function collectBlockSequenceIssues(snapshots) {
     seenOrderIndexes.add(orderIndex);
     if (previousOrderIndex !== null && orderIndex <= previousOrderIndex) {
       issues.push({
-        code: z19.ZodIssueCode.custom,
+        code: z21.ZodIssueCode.custom,
         message: `Expected orderIndex greater than ${String(previousOrderIndex)} for blockSequence position ${String(index)}; received ${String(orderIndex)}.`,
         path: [index, "orderIndex"]
       });
@@ -4015,7 +4642,7 @@ function collectBlockSequenceIssues(snapshots) {
 }
 
 // ../theme-core/src/site-styles/tokenRecipes.ts
-import { z as z20 } from "zod";
+import { z as z22 } from "zod";
 var themeTokenRecipeOptions = {
   palette: ["brand-led", "warm-neutral", "high-contrast", "soft-natural"],
   contrast: ["standard", "strong", "maximum"],
@@ -4030,50 +4657,16 @@ var themeTokenRecipeOptions = {
   spacing: ["compact", "regular", "airy"],
   motion: ["none", "subtle", "expressive"]
 };
-var themeTokenRecipesSchema = z20.object({
-  palette: z20.enum(themeTokenRecipeOptions.palette),
-  contrast: z20.enum(themeTokenRecipeOptions.contrast),
-  radius: z20.enum(themeTokenRecipeOptions.radius),
-  shadow: z20.enum(themeTokenRecipeOptions.shadow),
-  typography: z20.enum(themeTokenRecipeOptions.typography),
-  spacing: z20.enum(themeTokenRecipeOptions.spacing),
-  motion: z20.enum(themeTokenRecipeOptions.motion)
+var themeTokenRecipesSchema = z22.object({
+  palette: z22.enum(themeTokenRecipeOptions.palette),
+  contrast: z22.enum(themeTokenRecipeOptions.contrast),
+  radius: z22.enum(themeTokenRecipeOptions.radius),
+  shadow: z22.enum(themeTokenRecipeOptions.shadow),
+  typography: z22.enum(themeTokenRecipeOptions.typography),
+  spacing: z22.enum(themeTokenRecipeOptions.spacing),
+  motion: z22.enum(themeTokenRecipeOptions.motion)
 });
 
-// ../theme-core/src/tokens/blockColorTokens.ts
-var blockColorTokenNames = [
-  "text",
-  "heading",
-  "mutedText",
-  "surface",
-  "background",
-  "foreground",
-  "border",
-  "primary",
-  "secondary",
-  "accent",
-  "success",
-  "warning",
-  "info",
-  "error",
-  "destructive",
-  "scrim",
-  "shadow",
-  // Common "on*" tokens used when rendering colored chips/badges.
-  "onPrimary",
-  "onSecondary",
-  "onAccent",
-  "onSuccess",
-  "onWarning",
-  "onInfo",
-  "onError",
-  "onDestructive",
-  "onSurface"
-];
-var blockColorTokenNameSet = new Set(
-  blockColorTokenNames
-);
-
 // ../theme-core/src/palette/utils/colorConversion.ts
 function hexToRgb(hex) {
   const h = hex.replace(/^#/, "");
@@ -9374,6 +9967,12 @@ var containerResponsiveThemeCss = `/*
   padding: 2rem;
 }
 
+:where(.theme-scope) :where([data-block="event-registration"]) .er-icon {
+  display: flex;
+  justify-content: center;
+  margin-bottom: 1rem;
+}
+
 :where(.theme-scope) :where([data-block="event-registration"]) .er-actions {
   display: flex;
   justify-content: space-between;
@@ -13623,15 +14222,15 @@ var containerResponsiveThemeCss = `/*
   text-align: left;
   padding: 1rem;
   border-radius: var(--rb-event-tile-radius, calc(var(--rb-block-radius) * 0.75));
-  border-style: var(--rb-event-tile-border-style, var(--rb-border-style, solid));
-  border-width: var(--rb-event-tile-border-width, var(--rb-border-width, 1px));
-  border-color: var(--rb-event-tile-border, rgb(var(--tb-border)));
-  background: var(--rb-event-tile-bg, transparent);
+  border-style: var(--rb-tile-border-style, var(--rb-event-tile-border-style, var(--rb-border-style, solid)));
+  border-width: var(--rb-tile-border-width, var(--rb-event-tile-border-width, var(--rb-border-width, 1px)));
+  border-color: var(--rb-tile-border, var(--rb-event-tile-border, rgb(var(--tb-border))));
+  background: var(--rb-tile-bg, var(--rb-event-tile-bg, transparent));
   transition: border-color var(--rb-block-transition) ease,
               background-color var(--rb-block-transition) ease,
               opacity var(--rb-block-transition) ease;
   display: block;
-  opacity: var(--rb-event-tile-opacity, 1);
+  opacity: var(--rb-tile-opacity, var(--rb-event-tile-opacity, 1));
   color: inherit;
   text-decoration: none;
 }
@@ -13642,6 +14241,25 @@ var containerResponsiveThemeCss = `/*
   gap: var(--rb-event-tiles-grid-gap, 0.5rem);
 }
 
+:where(.theme-scope) .rb-tile-treatment-quiet {
+  --rb-tile-bg: color-mix(in oklab, rgb(var(--tb-surface)), rgb(var(--tb-muted)) 48%);
+  --rb-tile-border: color-mix(in oklab, rgb(var(--tb-border)), transparent 35%);
+  --rb-tile-border-hover: color-mix(in oklab, rgb(var(--tb-primary)), transparent 40%);
+}
+
+:where(.theme-scope) .rb-tile-treatment-brand-depth {
+  --rb-brand-depth-surface: rgb(var(--tb-primary-800));
+  --rb-brand-depth-tile-surface: rgb(var(--tb-primary-900));
+  --rb-brand-depth-tile-surface-selected: rgb(var(--tb-primary-950));
+  --rb-tile-bg: var(--rb-brand-depth-tile-surface);
+  --rb-tile-bg-selected: var(--rb-brand-depth-tile-surface-selected);
+  --rb-tile-border: transparent;
+  --rb-tile-border-hover: transparent;
+  --rb-tile-border-selected: transparent;
+  --rb-tile-border-width: 0;
+  --rb-event-tile-radius: var(--rb-block-radius);
+}
+
 @container rb-site (min-width: 768px) {
 @scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
 :where(.theme-scope) .rb-tiles-grid {
@@ -13660,13 +14278,13 @@ var containerResponsiveThemeCss = `/*
 }
 
 :where(.theme-scope) :where(.rb-tile--interactive, .er-event-card):hover:not(:disabled) {
-  border-color: var(--rb-event-tile-border-hover, rgba(var(--tb-primary), 0.5));
-  opacity: var(--rb-event-tile-hover-opacity, var(--rb-event-tile-opacity, 1));
+  border-color: var(--rb-tile-border-hover, var(--rb-event-tile-border-hover, rgba(var(--tb-primary), 0.5)));
+  opacity: var(--rb-tile-hover-opacity, var(--rb-event-tile-hover-opacity, var(--rb-tile-opacity, var(--rb-event-tile-opacity, 1))));
 }
 
 :where(.theme-scope) :where(.rb-tile--selected, .er-event-card--selected) {
-  border-color: var(--rb-event-tile-border-selected, rgb(var(--tb-primary)));
-  background: var(--rb-event-tile-bg-selected, rgba(var(--tb-primary), 0.1));
+  border-color: var(--rb-tile-border-selected, var(--rb-event-tile-border-selected, rgb(var(--tb-primary))));
+  background: var(--rb-tile-bg-selected, var(--rb-event-tile-bg-selected, rgba(var(--tb-primary), 0.1)));
 }
 
 :where(.theme-scope) :where(.rb-tile--disabled, .er-event-card--disabled) {
@@ -15042,6 +15660,32 @@ var containerResponsiveThemeCss = `/*
   :where(.theme-scope) :where([data-rb-background-video="true"]) {
     display: none !important;
   }
+}
+
+:where(.theme-scope) [data-block="gifting"] .gifting-feedback {
+  border: 1px solid rgb(var(--tb-text, 17 24 39) / 0.12);
+  border-radius: 1rem;
+  padding: 0.875rem 1rem;
+  background: rgb(var(--tb-surface, 255 255 255) / 0.92);
+  color: rgb(var(--tb-text, 17 24 39));
+}
+
+:where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="success"] {
+  border-color: rgba(var(--tb-success, 34 197 94), 0.3);
+  background: rgba(var(--tb-success, 34 197 94), 0.1);
+  color: rgb(var(--tb-success, 34 197 94));
+}
+
+:where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="warning"] {
+  border-color: rgba(var(--tb-warning, 245 158 11), 0.35);
+  background: rgba(var(--tb-warning, 245 158 11), 0.12);
+  color: rgb(var(--tb-warning, 245 158 11));
+}
+
+:where(.theme-scope) [data-block="gifting"] .gifting-feedback[data-feedback-tone="error"] {
+  border-color: rgba(var(--tb-destructive, 239 68 68), 0.3);
+  background: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  color: rgb(var(--tb-destructive, 239 68 68));
 }`;
 
 // ../theme-core/src/ThemeScopeCore.tsx
@@ -15312,6 +15956,9 @@ function buildThemeRuntimeFromBridge(config) {
   return cssVars;
 }
 
+// ../theme-core/src/siteChrome.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+
 // src/theme-bridge/generateCssVars.ts
 var SCOPE_ID = "sdk";
 var SYSTEM_FONT_STACK2 = 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji"';
@@ -15496,7 +16143,7 @@ function generateOverrideCss(overrides) {
 }
 
 // src/theme-bridge/ThemeBridgeProvider.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 function ThemeBridgeProvider({
   config,
   children,
@@ -15517,7 +16164,7 @@ function ThemeBridgeProvider({
     }
     return style;
   }, [cssVars]);
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx7(
     ThemeScopeCore,
     {
       cssVars: cssVarsStyle,