@riverbankcms/sdk 0.60.3 → 0.60.7

package/dist/server/page-converter.mjs

@@ -1210,1016 +1210,372 @@ function assertUniqueLayoutProfileKeys(profiles) {
   }
 }
 
-// ../theme-core/src/site-styles/compatibility.ts
+// ../theme-core/src/buttons/personalities/types.ts
+import { z as z5 } from "zod";
+
+// ../theme-core/src/buttons/types.ts
 import { z as z3 } from "zod";
+var VARIANT_ROLES = [
+  "primary",
+  "secondary",
+  "outline",
+  "ghost",
+  "link",
+  "tertiary",
+  "accent"
+];
+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 = z3.string().refine(
+  (value) => {
+    const parts = value.split(/\s+/).filter(Boolean);
+    return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
+  },
+  {
+    message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
+  }
+);
+var buttonSizeConfigSchema = z3.object({
+  padding: paddingShorthandSchema,
+  fontSize: z3.string().optional()
+});
+var buttonSizesSchema = z3.object({
+  sm: buttonSizeConfigSchema,
+  md: buttonSizeConfigSchema,
+  lg: buttonSizeConfigSchema,
+  xl: buttonSizeConfigSchema.optional()
+}).transform(({ sm, md, lg, xl }) => ({
+  sm,
+  md,
+  lg,
+  xl: xl ?? lg
+}));
+var buttonGlobalSettingsSchema = z3.object({
+  cornerStyle: cornerStyleSchema,
+  cornerRadius: z3.number().min(0).max(24).optional(),
+  shadow: shadowSizeSchema,
+  textTransform: textTransformSchema,
+  fontWeight: fontWeightSchema,
+  /**
+   * @deprecated Set per-variant via `variant.border.widthClass` instead.
+   * Schema field is preserved so existing presets parse; the value is unread
+   * by the current generator and will be removed once the legacy
+   * `primitives/content/components/Button.tsx` slot exports are deleted.
+   */
+  borderWidth: 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: z3.string().optional(),
+  // Letter spacing applied to all variants
+  letterSpacing: letterSpacingSchema.optional(),
+  // Italic style
+  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: z3.string().optional(),
+  // Gradient settings (if any variant uses gradients)
+  gradientStyle: gradientStyleSchema.optional(),
+  gradientAngle: z3.number().min(0).max(360).optional(),
+  gradientSharpness: gradientSharpnessSchema.optional()
+});
+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: z3.string() }),
+  z3.object({
+    type: z3.literal("gradient"),
+    stops: z3.array(z3.string()).min(2),
+    direction: gradientDirectionSchema
+  }),
+  z3.object({ type: z3.literal("transparent") })
+]);
+var effectApplicationSchema = z3.object({
+  effectId: z3.string(),
+  options: z3.record(z3.string(), z3.any()).optional()
+});
+var buttonBorderSchema = z3.object({
+  widthClass: z3.string(),
+  colorToken: z3.string()
+});
+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 = z3.object({
+  base: z3.array(effectApplicationSchema).optional(),
+  hover: z3.array(effectApplicationSchema).optional(),
+  active: z3.array(effectApplicationSchema).optional(),
+  focus: z3.array(effectApplicationSchema).optional()
+});
+var variantSizeOverridesSchema = z3.object({
+  sm: buttonSizeConfigSchema.optional(),
+  md: buttonSizeConfigSchema.optional(),
+  lg: buttonSizeConfigSchema.optional(),
+  xl: buttonSizeConfigSchema.optional()
+});
+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: z3.string(),
+  /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
+  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: z3.string().optional(),
+  // Effect composition
+  effects: variantEffectsSchema.optional(),
+  // Per-variant size overrides — see VariantSizeOverrides
+  sizes: variantSizeOverridesSchema.optional()
+});
+var buttonSystemSchema = z3.object({
+  global: buttonGlobalSettingsSchema,
+  variants: z3.array(buttonVariantSchema).min(1).max(6),
+  sizes: buttonSizesSchema.optional()
+});
+
+// ../theme-core/src/site-styles/styleTags.ts
+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/site-styles/sourceCatalogs.ts
-var generatedContentFrames = [
-  plainFrame,
-  panelFrame("inset"),
-  panelFrame("raised"),
-  flushPanelFrame({ bleed: "start" })
-];
-var userContentFrames = [
-  ...generatedContentFrames,
-  panelFrame("editorial"),
-  flushPanelFrame({ bleed: "end" }),
-  flushPanelFrame({ bleed: "both" })
-];
-var generatedDesignOptionCatalog = {
-  source: "generated",
-  sectionSurfaces: ["base", "muted-band", "accent-band", "hero-image"],
-  contentFrames: generatedContentFrames,
-  itemSurfaces: ["none", "default", "flat", "outlined", "raised"],
-  transitions: ["none", "soft-fade-short", "soft-fade-long"],
-  emphases: ["low", "medium", "high"],
-  detachedCustom: false
-};
-var userDesignOptionCatalog = {
-  source: "user",
-  sectionSurfaces: generatedDesignOptionCatalog.sectionSurfaces,
-  contentFrames: userContentFrames,
-  itemSurfaces: [
-    ...generatedDesignOptionCatalog.itemSurfaces,
-    "inset",
-    "editorial"
-  ],
-  transitions: [
-    ...generatedDesignOptionCatalog.transitions,
-    "wave-edge",
-    "angle-edge"
-  ],
-  emphases: generatedDesignOptionCatalog.emphases,
-  detachedCustom: false
-};
-var advancedDesignOptionCatalog = {
-  source: "advanced",
-  sectionSurfaces: userDesignOptionCatalog.sectionSurfaces,
-  contentFrames: userDesignOptionCatalog.contentFrames,
-  itemSurfaces: userDesignOptionCatalog.itemSurfaces,
-  transitions: userDesignOptionCatalog.transitions,
-  emphases: userDesignOptionCatalog.emphases,
-  detachedCustom: true
-};
-
-// ../theme-core/src/site-styles/curatedSiteStyles.ts
-var curatedSiteStyleIdValues = [
-  "site-style:calm-studio",
-  "site-style:clear-professional",
-  "site-style:warm-editorial",
-  "site-style:bright-community",
-  "site-style:quiet-luxury",
-  "site-style:practical-services",
-  "site-style:modern-wellness",
-  "site-style:bold-launch"
-];
-var quietBudget = {
-  accentDensity: "low",
-  panelDensity: "medium",
-  transitionMix: "quiet",
-  primaryCtaLimit: 2,
-  mediaDensity: "medium",
-  decorativeRepetition: "low"
-};
-var balancedBudget = {
-  accentDensity: "medium",
-  panelDensity: "medium",
-  transitionMix: "balanced",
-  primaryCtaLimit: 3,
-  mediaDensity: "medium",
-  decorativeRepetition: "medium"
-};
-var expressiveBudget = {
-  accentDensity: "high",
-  panelDensity: "high",
-  transitionMix: "expressive",
-  primaryCtaLimit: 3,
-  mediaDensity: "high",
-  decorativeRepetition: "medium"
-};
-function uniqueContentFrameKinds() {
-  const kinds = [...new Set(
-    generatedDesignOptionCatalog.contentFrames.map((frame) => frame.kind)
-  )];
-  const firstKind = kinds[0];
-  if (!firstKind) {
-    throw new Error("Expected generated design option catalog to expose at least one content frame kind.");
+// ../theme-core/src/buttons/personalities/types.ts
+function asButtonPersonalityId(value) {
+  if (value.length === 0) {
+    throw new Error("ButtonPersonalityId must be a non-empty string");
   }
-  return [firstKind, ...kinds.slice(1)];
+  return value;
 }
-var generatedContentFrameKinds = uniqueContentFrameKinds();
-function defineCuratedSiteStyle(input) {
+var buttonPersonalityIdSchema = z5.string().min(1).transform((value) => asButtonPersonalityId(value));
+var buttonPersonalitySchema = z5.object({
+  id: buttonPersonalityIdSchema,
+  name: z5.string().min(1),
+  description: z5.string().min(1),
+  tags: styleTagsSchema,
+  buttonSystem: buttonSystemSchema
+});
+function defineButtonPersonality(input) {
   return {
-    id: asSiteStyleId(input.id),
+    id: asButtonPersonalityId(input.id),
     name: input.name,
     description: input.description,
-    generationBrief: input.generationBrief,
-    selectionKeywords: input.selectionKeywords ?? [],
-    template: {
-      id: asDesignSystemTemplateId(`template:${input.id.replace("site-style:", "")}`),
-      name: input.name,
-      version: 1,
-      tokenRecipes: input.tokenRecipes,
-      compositionBudget: input.compositionBudget,
-      supportedSectionSurfaces: generatedDesignOptionCatalog.sectionSurfaces,
-      supportedContentFrames: generatedContentFrameKinds,
-      supportedItemSurfaces: generatedDesignOptionCatalog.itemSurfaces,
-      supportedTransitions: generatedDesignOptionCatalog.transitions
-    },
-    // The library IDs are already branded at construction (`asButtonPersonalityId`
-    // / `asPaletteVariantId`); the closed-union input type guarantees only
-    // shipped IDs reach this branch.
-    defaultButtonPersonalityId: input.defaultButtonPersonalityId,
-    acceptedButtons: input.acceptedButtons,
-    defaultPaletteVariantId: input.defaultPaletteVariantId,
-    acceptedPalettes: input.acceptedPalettes
+    tags: input.tags,
+    buttonSystem: input.buttonSystem
   };
 }
-var curatedSiteStyles = [
-  defineCuratedSiteStyle({
-    id: "site-style:calm-studio",
-    name: "Calm Studio",
-    description: "Soft, measured, and spacious for intimate appointment or class businesses.",
-    generationBrief: "Use calm pacing, concise copy, generous breathing room, and natural imagery. Keep calls to action steady rather than urgent.",
-    tokenRecipes: {
-      palette: "soft-natural",
-      contrast: "standard",
-      radius: "soft",
-      shadow: "subtle",
-      typography: "friendly-sans",
-      spacing: "airy",
-      motion: "subtle"
-    },
-    compositionBudget: quietBudget,
-    defaultButtonPersonalityId: "soft-pill",
-    acceptedButtons: { tone: ["minimal", "classic"], era: ["organic", "editorial"] },
-    defaultPaletteVariantId: "soft-natural-sage",
-    acceptedPalettes: { tone: ["minimal", "classic"], era: ["organic"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:clear-professional",
-    name: "Clear Professional",
-    description: "Crisp, trustworthy, and direct for local services and consultancies.",
-    generationBrief: "Prioritize clarity, proof, service detail, and easy next steps. Keep visuals polished and specific, with restrained decorative treatment.",
-    tokenRecipes: {
-      palette: "brand-led",
-      contrast: "strong",
-      radius: "soft",
-      shadow: "subtle",
-      typography: "clean-sans",
-      spacing: "regular",
-      motion: "subtle"
+
+// ../theme-core/src/buttons/personalities/brushed-wash.ts
+var brushedWash = defineButtonPersonality({
+  id: "brushed-wash",
+  name: "Brushed Wash",
+  description: "Watercolour-gradient buttons with soft shadows and generous padding.",
+  tags: { tone: "classic", energy: "vibrant", motion: "standard", era: "organic" },
+  buttonSystem: {
+    global: {
+      cornerStyle: "rounded",
+      shadow: "low",
+      textTransform: "none",
+      fontWeight: 500,
+      borderWidth: 1,
+      hoverTransform: "none",
+      hoverColor: "none"
     },
-    compositionBudget: balancedBudget,
-    defaultButtonPersonalityId: "confident-chip",
-    acceptedButtons: { tone: ["minimal", "classic"], era: ["modern", "editorial"] },
-    defaultPaletteVariantId: "brand-led-cool",
-    acceptedPalettes: { tone: ["minimal", "classic"], era: ["modern", "editorial"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:warm-editorial",
-    name: "Warm Editorial",
-    description: "Story-led and textured for educators, makers, venues, and retreats.",
-    generationBrief: "Let the copy feel thoughtful and grounded. Favor narrative sections, supporting media, and a small number of editorial panels.",
-    tokenRecipes: {
-      palette: "warm-neutral",
-      contrast: "standard",
-      radius: "square",
-      shadow: "none",
-      typography: "serif-editorial",
-      spacing: "airy",
-      motion: "subtle"
+    sizes: {
+      sm: { padding: "0.75rem 2rem", fontSize: "text-sm" },
+      md: { padding: "1rem 2.5rem" },
+      lg: { padding: "1.25rem 3rem", fontSize: "text-lg" },
+      xl: { padding: "1.625rem 3.75rem", fontSize: "text-xl" }
     },
-    compositionBudget: balancedBudget,
-    defaultButtonPersonalityId: "editorial-link",
-    acceptedButtons: { tone: ["minimal", "classic"], era: ["editorial", "organic"] },
-    defaultPaletteVariantId: "warm-neutral-cream",
-    acceptedPalettes: { tone: ["minimal", "classic"], era: ["editorial", "organic"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:bright-community",
-    name: "Bright Community",
-    description: "Friendly, welcoming, and active for groups, classes, and neighborhood offers.",
-    generationBrief: "Use welcoming language, clear event or booking routes, and optimistic imagery. Let accents appear, but avoid noisy decoration.",
-    tokenRecipes: {
-      palette: "brand-led",
-      contrast: "standard",
-      radius: "rounded",
-      shadow: "subtle",
-      typography: "friendly-sans",
-      spacing: "regular",
-      motion: "expressive"
+    variants: [
+      {
+        id: "primary",
+        name: "Primary",
+        enabled: true,
+        priority: 1,
+        background: {
+          type: "gradient",
+          stops: ["primary", "accent"],
+          direction: "to-r"
+        },
+        textColorToken: "primaryForeground",
+        borderRadius: "rounded-lg",
+        shadow: { elevation: "low", softness: "soft", position: "bottom" },
+        effects: {
+          hover: [{ effectId: "opacity-reduce", options: { reduction: -15 } }]
+        }
+      },
+      {
+        id: "secondary",
+        name: "Secondary",
+        enabled: true,
+        priority: 2,
+        background: {
+          type: "gradient",
+          stops: ["secondary", "accent"],
+          direction: "to-br"
+        },
+        textColorToken: "primaryForeground",
+        borderRadius: "rounded-lg",
+        shadow: { elevation: "low", softness: "soft", position: "bottom" },
+        effects: {
+          hover: [{ effectId: "opacity-reduce", options: { reduction: -15 } }]
+        }
+      },
+      {
+        id: "outline",
+        name: "Outline",
+        enabled: true,
+        priority: 3,
+        background: { type: "transparent" },
+        textColorToken: "primary",
+        borderRadius: "rounded-lg",
+        border: { widthClass: "border", colorToken: "primary" },
+        effects: {
+          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
+        }
+      },
+      {
+        id: "ghost",
+        name: "Ghost",
+        enabled: true,
+        priority: 3,
+        background: { type: "transparent" },
+        textColorToken: "text",
+        borderRadius: "rounded-lg",
+        effects: {
+          hover: [
+            { effectId: "background-on-hover", options: { colorToken: "surface" } }
+          ]
+        }
+      }
+    ]
+  }
+});
+
+// ../theme-core/src/buttons/personalities/confident-chip.ts
+var confidentChip = defineButtonPersonality({
+  id: "confident-chip",
+  name: "Confident Chip",
+  description: "Mid-radius solid buttons with a crisp hover.",
+  tags: { tone: "classic", energy: "calm", motion: "standard", era: "modern" },
+  buttonSystem: {
+    global: {
+      cornerStyle: "rounded",
+      shadow: "medium",
+      textTransform: "none",
+      fontWeight: 600,
+      borderWidth: 1,
+      hoverTransform: "none",
+      hoverColor: "none"
     },
-    compositionBudget: balancedBudget,
-    defaultButtonPersonalityId: "pebble",
-    acceptedButtons: { tone: ["classic", "bold"], era: ["organic", "modern"] },
-    defaultPaletteVariantId: "brand-led-warm",
-    acceptedPalettes: { tone: ["classic", "bold"], era: ["modern", "organic"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:quiet-luxury",
-    name: "Quiet Luxury",
-    description: "Minimal, confident, and refined for premium experiences and private services.",
-    generationBrief: "Use fewer claims, more specificity, and restrained sensory detail. Favor elegant media and low repetition over dense panels.",
-    selectionKeywords: [
-      "luxury",
-      "premium",
-      "boutique",
-      "bespoke",
-      "exclusive"
-    ],
-    tokenRecipes: {
-      palette: "high-contrast",
-      contrast: "strong",
-      radius: "square",
+    variants: [
+      {
+        id: "primary",
+        name: "Primary",
+        enabled: true,
+        priority: 1,
+        background: { type: "solid", colorToken: "primary" },
+        textColorToken: "primaryForeground",
+        borderRadius: "rounded-md",
+        shadow: { elevation: "medium", softness: "soft", position: "bottom" },
+        effects: {
+          hover: [{ effectId: "darken-background", options: { amount: 60 } }],
+          active: [{ effectId: "scale-down", options: { scale: "0.97" } }]
+        }
+      },
+      {
+        id: "secondary",
+        name: "Secondary",
+        enabled: true,
+        priority: 2,
+        background: { type: "solid", colorToken: "surface" },
+        textColorToken: "text",
+        borderRadius: "rounded-md",
+        border: { widthClass: "border", colorToken: "border" },
+        effects: {
+          hover: [{ effectId: "background-on-hover", options: { colorToken: "background" } }]
+        }
+      },
+      {
+        id: "outline",
+        name: "Outline",
+        enabled: true,
+        priority: 3,
+        background: { type: "transparent" },
+        textColorToken: "primary",
+        borderRadius: "rounded-md",
+        border: { widthClass: "border", colorToken: "primary" },
+        effects: {
+          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
+        }
+      },
+      {
+        id: "ghost",
+        name: "Ghost",
+        enabled: true,
+        priority: 3,
+        background: { type: "transparent" },
+        textColorToken: "primary",
+        borderRadius: "rounded-md",
+        effects: {
+          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
+        }
+      }
+    ]
+  }
+});
+
+// ../theme-core/src/buttons/personalities/editorial-link.ts
+var editorialLink = defineButtonPersonality({
+  id: "editorial-link",
+  name: "Editorial Link",
+  description: "Link-style with a growing underline. Refined, typographic.",
+  tags: { tone: "minimal", energy: "calm", motion: "subtle", era: "editorial" },
+  buttonSystem: {
+    global: {
+      cornerStyle: "square",
       shadow: "none",
-      typography: "classic-serif",
-      spacing: "airy",
-      motion: "none"
-    },
-    compositionBudget: quietBudget,
-    defaultButtonPersonalityId: "editorial-link",
-    acceptedButtons: { tone: ["minimal", "classic"], era: ["editorial", "organic"] },
-    defaultPaletteVariantId: "high-contrast-charcoal",
-    acceptedPalettes: { tone: ["minimal", "classic"], era: ["editorial", "organic"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:practical-services",
-    name: "Practical Services",
-    description: "Efficient, plainspoken, and conversion-focused for trades and everyday services.",
-    generationBrief: "Make services, location, trust signals, and contact paths obvious. Keep copy brief and avoid ornate visual treatments.",
-    selectionKeywords: [
-      "repair",
-      "plumb",
-      "electric",
-      "cleaning",
-      "landscap",
-      "contractor"
-    ],
-    tokenRecipes: {
-      palette: "brand-led",
-      contrast: "maximum",
-      radius: "soft",
-      shadow: "subtle",
-      typography: "clean-sans",
-      spacing: "compact",
-      motion: "none"
-    },
-    compositionBudget: quietBudget,
-    defaultButtonPersonalityId: "confident-chip",
-    acceptedButtons: { tone: ["minimal", "classic", "bold"], era: ["modern", "editorial"] },
-    defaultPaletteVariantId: "brand-led-cool",
-    acceptedPalettes: { tone: ["minimal", "classic", "bold"], era: ["modern", "editorial"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:modern-wellness",
-    name: "Modern Wellness",
-    description: "Natural, current, and reassuring for practitioners, studios, and wellbeing offers.",
-    generationBrief: "Keep the tone warm and practical. Use gentle section variation, natural materials, and inclusive copy without making medical claims.",
-    tokenRecipes: {
-      palette: "soft-natural",
-      contrast: "standard",
-      radius: "rounded",
-      shadow: "subtle",
-      typography: "clean-sans",
-      spacing: "airy",
-      motion: "subtle"
-    },
-    compositionBudget: balancedBudget,
-    defaultButtonPersonalityId: "soft-pill",
-    acceptedButtons: { tone: ["minimal", "classic"], era: ["organic", "modern"] },
-    defaultPaletteVariantId: "soft-natural-sage",
-    acceptedPalettes: { tone: ["minimal", "classic"], era: ["organic"] }
-  }),
-  defineCuratedSiteStyle({
-    id: "site-style:bold-launch",
-    name: "Bold Launch",
-    description: "High-energy and punchy for launches, campaigns, and creative offers.",
-    generationBrief: "Use crisp positioning, bold hero structure, strong calls to action, and confident visual rhythm. Keep it precise, not shouty.",
-    selectionKeywords: [
-      "launch",
-      "campaign",
-      "preorder",
-      "pre-order",
-      "waitlist",
-      "drop"
-    ],
-    tokenRecipes: {
-      palette: "high-contrast",
-      contrast: "maximum",
-      radius: "pill",
-      shadow: "layered",
-      typography: "clean-sans",
-      spacing: "regular",
-      motion: "expressive"
-    },
-    compositionBudget: expressiveBudget,
-    defaultButtonPersonalityId: "ink-stamp",
-    acceptedButtons: { tone: ["classic", "bold"], era: ["editorial", "organic", "modern"] },
-    defaultPaletteVariantId: "high-contrast-monochrome",
-    acceptedPalettes: { tone: ["bold"], era: ["editorial", "modern"] }
-  })
-];
-var curatedSiteStylesById = new Map(
-  curatedSiteStyles.map((style) => [style.id, style])
-);
-
-// ../theme-core/src/site-styles/designState.ts
-import { z as z4 } from "zod";
-
-// ../theme-core/src/site-styles/rawStyleFields.ts
-var themeV2RuntimeStyleFieldNames = [
-  "_frameStyles",
-  "_sectionStyles",
-  "_containerStyles",
-  "_cardStyles",
-  // styleGroup is legacy runtime transition wiring rather than a nested
-  // override object, but normal editors should still never see it directly.
-  "styleGroup"
-];
-var themeV2BlockSpecificRawStyleFieldNames = [
-  "_contentCardStyles",
-  "_textCardStyles"
-];
-var themeV2NormalEditorRawStyleFieldNames = [
-  ...themeV2RuntimeStyleFieldNames,
-  ...themeV2BlockSpecificRawStyleFieldNames
-];
-var themeV2NormalEditorRawStyleFieldNameSet = new Set(
-  themeV2NormalEditorRawStyleFieldNames
-);
-
-// ../theme-core/src/site-styles/designState.ts
-var themeV2DesignStateSchemaVersion = 1;
-var designResolutionPolicySchema = z4.enum(["generated", "user", "admin", "sdk"]);
-var runtimeStyleFieldNameSchema = z4.enum(themeV2RuntimeStyleFieldNames);
-var nonEmptyRuntimeStyleFieldNamesSchema = z4.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
-  fields3[0],
-  ...fields3.slice(1)
-]);
-var heroLegibilityStrategySchema = z4.enum([
-  "none",
-  "scrim-gradient",
-  "solid-panel"
-]);
-function uniqueNonEmpty(values) {
-  const uniqueValues = [...new Set(values)];
-  const firstValue = uniqueValues[0];
-  if (!firstValue) {
-    throw new Error("Expected at least one Theme V2 design state option.");
-  }
-  return [firstValue, ...uniqueValues.slice(1)];
-}
-var userPanelTreatments = uniqueNonEmpty(
-  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
-);
-var userFlushTreatments = uniqueNonEmpty(
-  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
-);
-var userFlushBleeds = uniqueNonEmpty(
-  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
-);
-var contentFrameIntentSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("plain") }).strict(),
-  z4.object({
-    kind: z4.literal("panel"),
-    treatment: z4.enum(userPanelTreatments)
-  }).strict(),
-  z4.object({
-    kind: z4.literal("flush-panel"),
-    treatment: z4.enum(userFlushTreatments),
-    bleed: z4.enum(userFlushBleeds)
-  }).strict()
-]);
-var blockDesignPlanSchema = z4.object({
-  blockId: z4.string().min(1).transform(asDesignBlockId),
-  blockKind: z4.string().min(1),
-  purpose: z4.string().min(1),
-  sectionSurface: z4.enum(userDesignOptionCatalog.sectionSurfaces),
-  contentFrame: contentFrameIntentSchema,
-  itemSurface: z4.enum(userDesignOptionCatalog.itemSurfaces),
-  transitionAfter: z4.enum(userDesignOptionCatalog.transitions),
-  emphasis: z4.enum(userDesignOptionCatalog.emphases),
-  heroLegibility: heroLegibilityStrategySchema.optional()
-}).strict();
-var styleAuthoritySchema = z4.discriminatedUnion("kind", [
-  z4.object({
-    kind: z4.literal("theme-v2"),
-    source: designResolutionPolicySchema,
-    siteStyleId: z4.string().min(1).transform(asSiteStyleId),
-    templateId: z4.string().min(1).transform(asDesignSystemTemplateId),
-    templateVersion: z4.number().int().nonnegative(),
-    resolverVersion: z4.number().int().nonnegative()
-  }).strict(),
-  z4.object({
-    kind: z4.literal("legacy-raw"),
-    reason: z4.enum(["pre-theme-v2", "manual-runtime-fields"])
-  }).strict(),
-  z4.object({
-    kind: z4.literal("advanced-detached"),
-    reason: z4.literal("detached-custom-runtime-fields")
-  }).strict()
-]);
-var blockRuntimeStyleAuthoritySchema = z4.object({
-  unit: z4.literal("block-runtime-fields"),
-  blockId: z4.string().min(1).transform(asDesignBlockId),
-  fields: nonEmptyRuntimeStyleFieldNamesSchema,
-  authority: styleAuthoritySchema
-}).strict();
-var persistedPageDesignStateV1Schema = z4.object({
-  schemaVersion: z4.literal(themeV2DesignStateSchemaVersion),
-  siteStyleId: z4.string().min(1).transform(asSiteStyleId),
-  templateId: z4.string().min(1).transform(asDesignSystemTemplateId),
-  templateVersion: z4.number().int().nonnegative(),
-  resolverVersion: z4.number().int().nonnegative(),
-  rhythmPresetId: z4.string().min(1),
-  blocks: z4.array(blockDesignPlanSchema),
-  styleAuthorities: z4.array(blockRuntimeStyleAuthoritySchema)
-}).strict();
-
-// ../theme-core/src/site-styles/generatedSchemas.ts
-import { z as z5 } from "zod";
-function uniqueNonEmpty2(values) {
-  const uniqueValues = [...new Set(values)];
-  const firstValue = uniqueValues[0];
-  if (!firstValue) {
-    throw new Error("Expected at least one generated schema option.");
-  }
-  return [firstValue, ...uniqueValues.slice(1)];
-}
-var generatedPanelTreatments = uniqueNonEmpty2(
-  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
-);
-var generatedFlushTreatments = uniqueNonEmpty2(
-  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
-);
-var generatedFlushBleeds = uniqueNonEmpty2(
-  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
-);
-var generatedPanelFrameSchema = z5.object({
-  kind: z5.literal("panel"),
-  treatment: z5.enum(generatedPanelTreatments)
-}).strict();
-var generatedFlushPanelFrameSchema = z5.object({
-  kind: z5.literal("flush-panel"),
-  treatment: z5.enum(generatedFlushTreatments),
-  bleed: z5.enum(generatedFlushBleeds)
-}).strict();
-var generatedContentFrameIntentSchema = z5.discriminatedUnion("kind", [
-  z5.object({ kind: z5.literal("plain") }).strict(),
-  generatedPanelFrameSchema,
-  generatedFlushPanelFrameSchema
-]);
-var generatedSiteStyleIdSchema = z5.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
-function generatedChoiceSchema(valueSchema) {
-  return z5.discriminatedUnion("kind", [
-    z5.object({
-      source: z5.literal("generated"),
-      kind: z5.literal("auto")
-    }).strict(),
-    z5.object({
-      source: z5.literal("generated"),
-      kind: z5.literal("explicit"),
-      value: valueSchema
-    }).strict()
-  ]);
-}
-var generatedBlockDesignIntentSchema = z5.object({
-  sectionSurface: generatedChoiceSchema(
-    z5.enum(generatedDesignOptionCatalog.sectionSurfaces)
-  ),
-  contentFrame: generatedChoiceSchema(generatedContentFrameIntentSchema),
-  itemSurface: generatedChoiceSchema(
-    z5.enum(generatedDesignOptionCatalog.itemSurfaces)
-  ),
-  transitionAfter: generatedChoiceSchema(
-    z5.enum(generatedDesignOptionCatalog.transitions)
-  ),
-  emphasis: generatedChoiceSchema(
-    z5.enum(generatedDesignOptionCatalog.emphases)
-  )
-}).strict();
-var generatedMediaCompositionIntentSchema = z5.enum([
-  "none",
-  "supporting",
-  "dominant"
-]);
-var generatedDecorativeCompositionIntentSchema = z5.enum([
-  "none",
-  "supporting"
-]);
-var generatedHeroLegibilityStrategySchema = z5.enum([
-  "none",
-  "scrim-gradient"
-]);
-var generatedBlockMediaIntentSchema = z5.object({
-  media: generatedMediaCompositionIntentSchema,
-  decorative: generatedDecorativeCompositionIntentSchema,
-  heroLegibility: generatedChoiceSchema(generatedHeroLegibilityStrategySchema)
-}).strict();
-var generatedBoundaryIntentSchema = z5.object({
-  transitionAfter: generatedChoiceSchema(
-    z5.enum(generatedDesignOptionCatalog.transitions)
-  )
-}).strict();
-var generatedPageDesignBlockIntentSchema = z5.object({
-  blockId: z5.string().min(1),
-  blockKind: z5.string().min(1),
-  purpose: z5.string().min(1),
-  design: generatedBlockDesignIntentSchema,
-  mediaIntent: generatedBlockMediaIntentSchema,
-  boundaryIntent: generatedBoundaryIntentSchema
-}).strict();
-var generatedPageDesignIntentSchema = z5.object({
-  siteStyleId: generatedSiteStyleIdSchema,
-  blocks: z5.array(generatedPageDesignBlockIntentSchema)
-}).strict();
-
-// ../theme-core/src/site-styles/pageDesignIntent.ts
-import { z as z6 } from "zod";
-var pageDesignIntentSchemaVersion = 1;
-var pageDesignUserPinnedAppearanceChoiceSchema = z6.object({
-  kind: z6.literal("user-pinned"),
-  value: z6.string().min(1).transform(asAppearancePresetId)
-}).strict();
-var pageDesignUserPinnedBoundaryChoiceSchema = z6.object({
-  kind: z6.literal("user-pinned"),
-  value: z6.string().min(1).transform(asBoundaryOptionId)
-}).strict();
-var pageDesignBlockLookPinSchema = z6.object({
-  blockId: z6.string().min(1).transform(asDesignBlockId),
-  blockKind: z6.string().min(1),
-  choice: pageDesignUserPinnedAppearanceChoiceSchema
-}).strict();
-var pageDesignBoundaryPinSchema = z6.object({
-  boundaryId: z6.string().min(1).transform(asDesignBoundaryId),
-  previousBlockId: z6.string().min(1).transform(asDesignBlockId),
-  nextBlockId: z6.string().min(1).transform(asDesignBlockId),
-  choice: pageDesignUserPinnedBoundaryChoiceSchema
-}).strict().superRefine((pin, ctx) => {
-  const expectedBoundaryId = makeBoundaryId(
-    pin.previousBlockId,
-    pin.nextBlockId
-  );
-  if (pin.boundaryId !== expectedBoundaryId) {
-    ctx.addIssue({
-      code: z6.ZodIssueCode.custom,
-      path: ["boundaryId"],
-      message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
-    });
-  }
-});
-var pageDesignIntentV1Schema = z6.object({
-  schemaVersion: z6.literal(pageDesignIntentSchemaVersion),
-  siteStyleId: z6.string().min(1).transform(asSiteStyleId),
-  pageFlowPresetId: z6.string().min(1).transform(asPageFlowPresetId),
-  blockLookPins: z6.array(pageDesignBlockLookPinSchema),
-  boundaryPins: z6.array(pageDesignBoundaryPinSchema)
-}).strict().superRefine((intent, ctx) => {
-  addDuplicateStringIssues(ctx, {
-    values: intent.blockLookPins.map((pin) => pin.blockId),
-    path: ["blockLookPins"],
-    label: "block Look pin"
-  });
-  addDuplicateStringIssues(ctx, {
-    values: intent.boundaryPins.map(
-      (pin) => boundaryKey(pin.previousBlockId, pin.nextBlockId)
-    ),
-    path: ["boundaryPins"],
-    label: "boundary pin"
-  });
-});
-function addDuplicateStringIssues(ctx, input) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const value of input.values) {
-    if (seen.has(value)) {
-      duplicates.add(value);
-    }
-    seen.add(value);
-  }
-  for (const duplicate of duplicates) {
-    ctx.addIssue({
-      code: z6.ZodIssueCode.custom,
-      path: [...input.path],
-      message: `Duplicate ${input.label}: ${duplicate}.`
-    });
-  }
-}
-function boundaryKey(previousBlockId, nextBlockId) {
-  return makeBoundaryId(previousBlockId, nextBlockId);
-}
-
-// ../theme-core/src/schema.ts
-import { z as z19 } from "zod";
-
-// ../theme-core/src/lib/media.ts
-import z7 from "zod";
-var hotspotSchema = z7.object({
-  x: z7.number().min(0).max(1),
-  y: z7.number().min(0).max(1),
-  radius: z7.number().optional()
-});
-var rotationSchema = z7.union([z7.literal(0), z7.literal(90), z7.literal(180), z7.literal(270)]);
-var rectSchema = z7.tuple([z7.number(), z7.number(), z7.number(), z7.number()]);
-var aspectCropSchema = z7.object({
-  aspect: z7.preprocess((value) => value == null ? void 0 : value, z7.string().optional()),
-  rect: z7.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-  hotspot: z7.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-  rotation: z7.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
-});
-var transformSchema = z7.object({
-  aspectCrops: z7.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return void 0;
-    }
-    return value;
-  }, z7.record(z7.string(), aspectCropSchema.catch({}))).optional(),
-  rect: rectSchema.optional(),
-  hotspot: hotspotSchema.optional(),
-  rotation: rotationSchema.optional()
-});
-var mediaSchema = z7.object({
-  type: z7.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z7.string().optional(),
-  placeholder: z7.boolean().default(true).optional(),
-  assetId: z7.string().optional(),
-  identifier: z7.string().optional(),
-  src: z7.string().optional(),
-  alt: z7.string().optional(),
-  filename: z7.string().optional(),
-  mimeType: z7.string().optional(),
-  width: z7.number().optional(),
-  height: z7.number().optional(),
-  storageBucket: z7.string().optional(),
-  storagePath: z7.string().optional(),
-  transform: transformSchema.optional()
-});
-
-// ../theme-core/src/buttons/types.ts
-import { z as z8 } from "zod";
-var VARIANT_ROLES = [
-  "primary",
-  "secondary",
-  "outline",
-  "ghost",
-  "link",
-  "tertiary",
-  "accent"
-];
-var cornerStyleSchema = z8.enum(["square", "rounded", "pill"]);
-var shadowSizeSchema = z8.enum(["none", "low", "medium", "high"]);
-var textTransformSchema = z8.enum(["none", "uppercase", "lowercase", "capitalize"]);
-var fontWeightSchema = z8.union([z8.literal(500), z8.literal(600), z8.literal(700)]);
-var buttonTypographySchema = z8.enum(["body", "heading"]);
-var letterSpacingSchema = z8.enum(["tight", "normal", "loose"]);
-var hoverTransformSchema = z8.enum(["none", "lift", "scale", "press"]);
-var hoverColorSchema = z8.enum(["none", "brighten", "darken", "saturate", "token"]);
-var buttonPaddingPresetSchema = z8.enum(["compact", "default", "spacious"]);
-var gradientStyleSchema = z8.enum(["linear", "radial", "conic"]);
-var gradientSharpnessSchema = z8.enum(["smooth", "medium", "hard"]);
-var prioritySchema = z8.union([z8.literal(1), z8.literal(2), z8.literal(3)]);
-var variantRoleSchema = z8.enum(VARIANT_ROLES);
-var buttonSizeNameSchema = z8.enum(["sm", "md", "lg", "xl"]);
-var PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
-var paddingShorthandSchema = z8.string().refine(
-  (value) => {
-    const parts = value.split(/\s+/).filter(Boolean);
-    return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
-  },
-  {
-    message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
-  }
-);
-var buttonSizeConfigSchema = z8.object({
-  padding: paddingShorthandSchema,
-  fontSize: z8.string().optional()
-});
-var buttonSizesSchema = z8.object({
-  sm: buttonSizeConfigSchema,
-  md: buttonSizeConfigSchema,
-  lg: buttonSizeConfigSchema,
-  xl: buttonSizeConfigSchema.optional()
-}).transform(({ sm, md, lg, xl }) => ({
-  sm,
-  md,
-  lg,
-  xl: xl ?? lg
-}));
-var buttonGlobalSettingsSchema = z8.object({
-  cornerStyle: cornerStyleSchema,
-  cornerRadius: z8.number().min(0).max(24).optional(),
-  shadow: shadowSizeSchema,
-  textTransform: textTransformSchema,
-  fontWeight: fontWeightSchema,
-  /**
-   * @deprecated Set per-variant via `variant.border.widthClass` instead.
-   * Schema field is preserved so existing presets parse; the value is unread
-   * by the current generator and will be removed once the legacy
-   * `primitives/content/components/Button.tsx` slot exports are deleted.
-   */
-  borderWidth: z8.union([z8.literal(1), z8.literal(2), z8.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: z8.string().optional(),
-  // Letter spacing applied to all variants
-  letterSpacing: letterSpacingSchema.optional(),
-  // Italic style
-  italic: z8.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: z8.string().optional(),
-  // Gradient settings (if any variant uses gradients)
-  gradientStyle: gradientStyleSchema.optional(),
-  gradientAngle: z8.number().min(0).max(360).optional(),
-  gradientSharpness: gradientSharpnessSchema.optional()
-});
-var gradientDirectionSchema = z8.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var buttonBackgroundSchema = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("solid"), colorToken: z8.string() }),
-  z8.object({
-    type: z8.literal("gradient"),
-    stops: z8.array(z8.string()).min(2),
-    direction: gradientDirectionSchema
-  }),
-  z8.object({ type: z8.literal("transparent") })
-]);
-var effectApplicationSchema = z8.object({
-  effectId: z8.string(),
-  options: z8.record(z8.string(), z8.any()).optional()
-});
-var buttonBorderSchema = z8.object({
-  widthClass: z8.string(),
-  colorToken: z8.string()
-});
-var variantShadowSchema = z8.object({
-  elevation: z8.enum(["none", "low", "medium", "high"]),
-  softness: z8.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z8.enum(["bottom", "bottom-right"]).default("bottom")
-});
-var variantEffectsSchema = z8.object({
-  base: z8.array(effectApplicationSchema).optional(),
-  hover: z8.array(effectApplicationSchema).optional(),
-  active: z8.array(effectApplicationSchema).optional(),
-  focus: z8.array(effectApplicationSchema).optional()
-});
-var variantSizeOverridesSchema = z8.object({
-  sm: buttonSizeConfigSchema.optional(),
-  md: buttonSizeConfigSchema.optional(),
-  lg: buttonSizeConfigSchema.optional(),
-  xl: buttonSizeConfigSchema.optional()
-});
-var buttonVariantSchema = z8.object({
-  id: z8.string(),
-  name: z8.string().min(1).max(20),
-  enabled: z8.boolean(),
-  priority: prioritySchema,
-  // Base appearance (token-based)
-  background: buttonBackgroundSchema,
-  textColorToken: z8.string(),
-  /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-  borderRadius: z8.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: z8.string().optional(),
-  // Effect composition
-  effects: variantEffectsSchema.optional(),
-  // Per-variant size overrides — see VariantSizeOverrides
-  sizes: variantSizeOverridesSchema.optional()
-});
-var buttonSystemSchema = z8.object({
-  global: buttonGlobalSettingsSchema,
-  variants: z8.array(buttonVariantSchema).min(1).max(6),
-  sizes: buttonSizesSchema.optional()
-});
-
-// ../theme-core/src/buttons/generateButtonCss.ts
-var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
-
-// ../theme-core/src/buttons/personalities/types.ts
-import { z as z9 } from "zod";
-function asButtonPersonalityId(value) {
-  if (value.length === 0) {
-    throw new Error("ButtonPersonalityId must be a non-empty string");
-  }
-  return value;
-}
-var buttonPersonalityIdSchema = z9.string().min(1).transform((value) => asButtonPersonalityId(value));
-var buttonPersonalitySchema = z9.object({
-  id: buttonPersonalityIdSchema,
-  name: z9.string().min(1),
-  description: z9.string().min(1),
-  tags: styleTagsSchema,
-  buttonSystem: buttonSystemSchema
-});
-function defineButtonPersonality(input) {
-  return {
-    id: asButtonPersonalityId(input.id),
-    name: input.name,
-    description: input.description,
-    tags: input.tags,
-    buttonSystem: input.buttonSystem
-  };
-}
-
-// ../theme-core/src/buttons/personalities/brushed-wash.ts
-var brushedWash = defineButtonPersonality({
-  id: "brushed-wash",
-  name: "Brushed Wash",
-  description: "Watercolour-gradient buttons with soft shadows and generous padding.",
-  tags: { tone: "classic", energy: "vibrant", motion: "standard", era: "organic" },
-  buttonSystem: {
-    global: {
-      cornerStyle: "rounded",
-      shadow: "low",
-      textTransform: "none",
-      fontWeight: 500,
-      borderWidth: 1,
-      hoverTransform: "none",
-      hoverColor: "none"
-    },
-    sizes: {
-      sm: { padding: "0.75rem 2rem", fontSize: "text-sm" },
-      md: { padding: "1rem 2.5rem" },
-      lg: { padding: "1.25rem 3rem", fontSize: "text-lg" },
-      xl: { padding: "1.625rem 3.75rem", fontSize: "text-xl" }
-    },
-    variants: [
-      {
-        id: "primary",
-        name: "Primary",
-        enabled: true,
-        priority: 1,
-        background: {
-          type: "gradient",
-          stops: ["primary", "accent"],
-          direction: "to-r"
-        },
-        textColorToken: "primaryForeground",
-        borderRadius: "rounded-lg",
-        shadow: { elevation: "low", softness: "soft", position: "bottom" },
-        effects: {
-          hover: [{ effectId: "opacity-reduce", options: { reduction: -15 } }]
-        }
-      },
-      {
-        id: "secondary",
-        name: "Secondary",
-        enabled: true,
-        priority: 2,
-        background: {
-          type: "gradient",
-          stops: ["secondary", "accent"],
-          direction: "to-br"
-        },
-        textColorToken: "primaryForeground",
-        borderRadius: "rounded-lg",
-        shadow: { elevation: "low", softness: "soft", position: "bottom" },
-        effects: {
-          hover: [{ effectId: "opacity-reduce", options: { reduction: -15 } }]
-        }
-      },
-      {
-        id: "outline",
-        name: "Outline",
-        enabled: true,
-        priority: 3,
-        background: { type: "transparent" },
-        textColorToken: "primary",
-        borderRadius: "rounded-lg",
-        border: { widthClass: "border", colorToken: "primary" },
-        effects: {
-          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
-        }
-      },
-      {
-        id: "ghost",
-        name: "Ghost",
-        enabled: true,
-        priority: 3,
-        background: { type: "transparent" },
-        textColorToken: "text",
-        borderRadius: "rounded-lg",
-        effects: {
-          hover: [
-            { effectId: "background-on-hover", options: { colorToken: "surface" } }
-          ]
-        }
-      }
-    ]
-  }
-});
-
-// ../theme-core/src/buttons/personalities/confident-chip.ts
-var confidentChip = defineButtonPersonality({
-  id: "confident-chip",
-  name: "Confident Chip",
-  description: "Mid-radius solid buttons with a crisp hover.",
-  tags: { tone: "classic", energy: "calm", motion: "standard", era: "modern" },
-  buttonSystem: {
-    global: {
-      cornerStyle: "rounded",
-      shadow: "medium",
-      textTransform: "none",
-      fontWeight: 600,
-      borderWidth: 1,
-      hoverTransform: "none",
-      hoverColor: "none"
-    },
-    variants: [
-      {
-        id: "primary",
-        name: "Primary",
-        enabled: true,
-        priority: 1,
-        background: { type: "solid", colorToken: "primary" },
-        textColorToken: "primaryForeground",
-        borderRadius: "rounded-md",
-        shadow: { elevation: "medium", softness: "soft", position: "bottom" },
-        effects: {
-          hover: [{ effectId: "darken-background", options: { amount: 60 } }],
-          active: [{ effectId: "scale-down", options: { scale: "0.97" } }]
-        }
-      },
-      {
-        id: "secondary",
-        name: "Secondary",
-        enabled: true,
-        priority: 2,
-        background: { type: "solid", colorToken: "surface" },
-        textColorToken: "text",
-        borderRadius: "rounded-md",
-        border: { widthClass: "border", colorToken: "border" },
-        effects: {
-          hover: [{ effectId: "background-on-hover", options: { colorToken: "background" } }]
-        }
-      },
-      {
-        id: "outline",
-        name: "Outline",
-        enabled: true,
-        priority: 3,
-        background: { type: "transparent" },
-        textColorToken: "primary",
-        borderRadius: "rounded-md",
-        border: { widthClass: "border", colorToken: "primary" },
-        effects: {
-          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
-        }
-      },
-      {
-        id: "ghost",
-        name: "Ghost",
-        enabled: true,
-        priority: 3,
-        background: { type: "transparent" },
-        textColorToken: "primary",
-        borderRadius: "rounded-md",
-        effects: {
-          hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
-        }
-      }
-    ]
-  }
-});
-
-// ../theme-core/src/buttons/personalities/editorial-link.ts
-var editorialLink = defineButtonPersonality({
-  id: "editorial-link",
-  name: "Editorial Link",
-  description: "Link-style with a growing underline. Refined, typographic.",
-  tags: { tone: "minimal", energy: "calm", motion: "subtle", era: "editorial" },
-  buttonSystem: {
-    global: {
-      cornerStyle: "square",
-      shadow: "none",
-      textTransform: "none",
-      fontWeight: 500,
-      borderWidth: 1,
-      hoverTransform: "none",
-      hoverColor: "none"
+      textTransform: "none",
+      fontWeight: 500,
+      borderWidth: 1,
+      hoverTransform: "none",
+      hoverColor: "none"
     },
     variants: [
       {
@@ -2568,49 +1924,101 @@ var personalitiesById = new Map(
   buttonPersonalities.map((p) => [p.id, p])
 );
 
+// ../theme-core/src/palette/variants/types.ts
+import { z as z17 } from "zod";
+
+// ../theme-core/src/schema.ts
+import { z as z16 } from "zod";
+
+// ../theme-core/src/lib/media.ts
+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 = 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 = z6.object({
+  aspectCrops: z6.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return void 0;
+    }
+    return value;
+  }, z6.record(z6.string(), aspectCropSchema.catch({}))).optional(),
+  rect: rectSchema.optional(),
+  hotspot: hotspotSchema.optional(),
+  rotation: rotationSchema.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()
+});
+
+// ../theme-core/src/buttons/generateButtonCss.ts
+var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
+
 // ../theme-core/src/cards/types.ts
-import { z as z10 } from "zod";
-var cardSpacingSchema = z10.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z10.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardBackgroundSchema = z10.discriminatedUnion("type", [
-  z10.object({ type: z10.literal("solid"), colorToken: z10.string() }),
-  z10.object({
-    type: z10.literal("gradient"),
-    fromToken: z10.string(),
-    toToken: z10.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: z7.string() }),
+  z7.object({
+    type: z7.literal("gradient"),
+    fromToken: z7.string(),
+    toToken: z7.string(),
     direction: gradientDirectionSchema2
   }),
-  z10.object({ type: z10.literal("transparent") })
+  z7.object({ type: z7.literal("transparent") })
 ]);
-var cardBorderSchema = z10.object({
-  widthClass: z10.string(),
-  colorToken: z10.string()
-});
-var cardVariantSchema = z10.object({
-  id: z10.string(),
-  name: z10.string().min(1).max(20),
-  enabled: z10.boolean(),
-  priority: z10.union([z10.literal(1), z10.literal(2), z10.literal(3)]),
+var cardBorderSchema = z7.object({
+  widthClass: z7.string(),
+  colorToken: z7.string()
+});
+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: z10.object({
-    elevation: z10.enum(["none", "low", "medium", "high"]),
-    softness: z10.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z10.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: z10.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z7.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Border (optional)
   border: cardBorderSchema.optional()
 });
-var cardSystemSchema = z10.object({
-  variants: z10.array(cardVariantSchema).min(1).max(3)
+var cardSystemSchema = z7.object({
+  variants: z7.array(cardVariantSchema).min(1).max(3)
 });
 
 // ../theme-core/src/accordions/types.ts
-import { z as z11 } from "zod";
-var accordionIconSchema = z11.enum([
+import { z as z8 } from "zod";
+var accordionIconSchema = z8.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -2622,180 +2030,180 @@ var accordionIconSchema = z11.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z11.object({
+var accordionSystemSchema = z8.object({
   // Visual styling (solid color only - gradients can be added later if needed)
-  background: z11.object({
-    type: z11.literal("solid"),
-    colorToken: z11.string()
+  background: z8.object({
+    type: z8.literal("solid"),
+    colorToken: z8.string()
   }),
   // Spacing (padding inside items)
-  spacing: z11.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z8.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z11.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z8.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z11.object({
-    widthClass: z11.string(),
+  border: z8.object({
+    widthClass: z8.string(),
     // e.g., 'border', 'border-2', 'border-0'
-    colorToken: z11.string()
+    colorToken: z8.string()
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z11.object({
-    elevation: z11.enum(["none", "low", "medium", "high"]),
-    softness: z11.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z11.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: z11.object({
+  icon: z8.object({
     style: accordionIconSchema,
-    position: z11.enum(["left", "right"]),
-    size: z11.enum(["sm", "md", "lg"])
+    position: z8.enum(["left", "right"]),
+    size: z8.enum(["sm", "md", "lg"])
   }),
   // Trigger (question) styling
-  trigger: z11.object({
-    textColorToken: z11.string(),
-    fontWeight: z11.enum(["regular", "medium", "semibold", "bold"]).nullable()
+  trigger: z8.object({
+    textColorToken: z8.string(),
+    fontWeight: z8.enum(["regular", "medium", "semibold", "bold"]).nullable()
     // null = inherit from theme
   }),
   // Hover state styling
-  hover: z11.object({
-    backgroundColorToken: z11.string().optional(),
-    textColorToken: z11.string().optional(),
-    borderColorToken: z11.string().optional()
+  hover: z8.object({
+    backgroundColorToken: z8.string().optional(),
+    textColorToken: z8.string().optional(),
+    borderColorToken: z8.string().optional()
   }),
   // Content (answer) styling
-  content: z11.object({
-    textColorToken: z11.string()
+  content: z8.object({
+    textColorToken: z8.string()
   })
 });
 
 // ../theme-core/src/inputs/types.ts
-import { z as z12 } from "zod";
-var inputSystemSchema = z12.object({
+import { z as z9 } from "zod";
+var inputSystemSchema = z9.object({
   // Base styling (applied to all inputs)
-  base: z12.object({
-    background: z12.union([
-      z12.object({
-        type: z12.literal("solid"),
-        colorToken: z12.string()
+  base: z9.object({
+    background: z9.union([
+      z9.object({
+        type: z9.literal("solid"),
+        colorToken: z9.string()
       }),
-      z12.object({
-        type: z12.literal("transparent")
+      z9.object({
+        type: z9.literal("transparent")
       })
     ]),
-    textColorToken: z12.string(),
-    border: z12.object({
-      widthClass: z12.string(),
+    textColorToken: z9.string(),
+    border: z9.object({
+      widthClass: z9.string(),
       // e.g., 'border', 'border-2'
-      colorToken: z12.string(),
-      style: z12.enum(["all", "underline"]).optional()
+      colorToken: z9.string(),
+      style: z9.enum(["all", "underline"]).optional()
     }),
-    corners: z12.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z9.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z12.object({
-      elevation: z12.enum(["none", "low", "medium"]),
-      softness: z12.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z9.object({
+      elevation: z9.enum(["none", "low", "medium"]),
+      softness: z9.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z12.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z9.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z12.enum(["sm", "base", "lg"])
+    fontSize: z9.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z12.object({
-    textColorToken: z12.string(),
-    fontWeight: z12.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z12.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z12.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z12.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z12.number().min(0.2).max(1).optional()
+  label: z9.object({
+    textColorToken: z9.string(),
+    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: z12.object({
-    ringColorToken: z12.string(),
-    ringWidth: z12.enum(["0", "1", "2", "3"]),
-    borderColorToken: z12.string().optional()
+  focus: z9.object({
+    ringColorToken: z9.string(),
+    ringWidth: z9.enum(["0", "1", "2", "3"]),
+    borderColorToken: z9.string().optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z12.object({
-    borderColorToken: z12.string(),
-    textColorToken: z12.string()
+  error: z9.object({
+    borderColorToken: z9.string(),
+    textColorToken: z9.string()
   }),
   // Disabled state
-  disabled: z12.object({
-    backgroundColorToken: z12.string(),
-    textColorToken: z12.string(),
-    opacity: z12.number().min(0.3).max(0.7)
+  disabled: z9.object({
+    backgroundColorToken: z9.string(),
+    textColorToken: z9.string(),
+    opacity: z9.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/gradients/types.ts
-import { z as z13 } from "zod";
-var gradientStopSchema = z13.object({
-  color: z13.string(),
+import { z as z10 } from "zod";
+var gradientStopSchema = z10.object({
+  color: z10.string(),
   // Theme color token name (e.g., 'primary-500')
-  position: z13.number().min(0).max(100)
+  position: z10.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z13.object({
-  type: z13.enum(["linear", "radial"]),
-  angle: z13.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: z13.string().optional(),
+  position: z10.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z13.array(gradientStopSchema).min(2)
+  stops: z10.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z15 } from "zod";
+import { z as z12 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z14 } from "zod";
-var interactiveTypographySchema = z14.object({
+import { z as z11 } from "zod";
+var interactiveTypographySchema = z11.object({
   /** Font family source */
-  typography: z14.enum(["body", "heading"]).default("body"),
+  typography: z11.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z14.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z11.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z14.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z11.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z14.boolean().default(false)
+  italic: z11.boolean().default(false)
 });
-var effectApplicationSchema2 = z14.object({
+var effectApplicationSchema2 = z11.object({
   /** Effect preset ID */
-  effectId: z14.string(),
+  effectId: z11.string(),
   /** User-provided customization options */
-  options: z14.record(z14.string(), z14.any()).optional()
+  options: z11.record(z11.string(), z11.any()).optional()
 });
-var effectCompositionSchema = z14.object({
+var effectCompositionSchema = z11.object({
   /** Effects always applied */
-  base: z14.array(effectApplicationSchema2).optional(),
+  base: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z14.array(effectApplicationSchema2).optional(),
+  hover: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z14.array(effectApplicationSchema2).optional(),
+  active: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z14.array(effectApplicationSchema2).optional()
+  focus: z11.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z15.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z15.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z15.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z15.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z15.enum(["normal", "wide", "wider", "widest"]);
-var navLinkStyleSchema = z15.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: z15.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: z15.string().default("text"),
+  colorToken: z12.string().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: z15.string().nullable().optional(),
+  hoverColorToken: z12.string().nullable().optional(),
   /** Padding preset */
   padding: navLinkPaddingSchema.default("compact"),
   /** Horizontal padding override (overrides horizontal component of padding preset) */
@@ -2807,7 +2215,7 @@ var navLinkStyleSchema = z15.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z16 } 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;
@@ -2849,7 +2257,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z16.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" }
 );
@@ -2859,38 +2267,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z16.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 = z16.record(
-  z16.string().min(1).max(100),
+var declarationsSchema = z13.record(
+  z13.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z16.object({
-  id: z16.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: z16.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 = z16.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z16.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z13.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z13.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z17 } 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 = z17.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z17.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
 });
@@ -2902,146 +2310,146 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z17.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 = z17.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 = z17.object({
+var keyframeSchema = z14.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z17.object({
+var keyframesAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z17.literal("keyframes"),
+  type: z14.literal("keyframes"),
   name: animationNameSchema,
-  frames: z17.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z14.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z17.record(z17.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 = z17.object({
+var fontFaceAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z17.literal("font-face"),
+  type: z14.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z17.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z17.object({
+var mediaQuerySchema = z14.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z17.literal("media"),
+  type: z14.literal("media"),
   query: mediaQuerySchema,
-  rules: z17.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z17.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z17.object({
+var supportsConditionSchema = z14.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z17.literal("supports"),
+  type: z14.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z17.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 = z17.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 = z17.object({
+var rawAtRuleSchema = z14.object({
   id: ruleIdSchema,
-  type: z17.literal("raw"),
+  type: z14.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z17.discriminatedUnion("type", [
+var customCssAtRuleSchema = z14.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z17.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z14.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z18 } from "zod";
-var componentBorderSchema = z18.object({
-  width: z18.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z18.enum(["solid", "dashed"]).default("solid"),
-  colorToken: z18.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: z15.string().optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z18.object({
-  elevation: z18.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/schema.ts
-var axesSchema = z19.object({
-  tone: z19.enum(["minimal", "classic", "bold"]),
-  energy: z19.enum(["calm", "vibrant"]),
-  density: z19.enum(["airy", "regular", "compact"]),
-  mediaBias: z19.enum(["text", "media", "mixed"]),
-  conversionBias: z19.enum(["low", "med", "high"]),
-  motion: z19.enum(["subtle", "standard", "expressive"])
-});
-var colourHexString = z19.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z19.object({
-  name: z19.string().min(1),
+var axesSchema = z16.object({
+  tone: z16.enum(["minimal", "classic", "bold"]),
+  energy: z16.enum(["calm", "vibrant"]),
+  density: z16.enum(["airy", "regular", "compact"]),
+  mediaBias: z16.enum(["text", "media", "mixed"]),
+  conversionBias: z16.enum(["low", "med", "high"]),
+  motion: z16.enum(["subtle", "standard", "expressive"])
+});
+var colourHexString = z16.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z16.object({
+  name: z16.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z19.object({
-  mode: z19.enum(["light", "dark"])
+var paletteMetaSchema = z16.object({
+  mode: z16.enum(["light", "dark"])
 });
-var paletteSchema = z19.object({
-  colors: z19.array(paletteColorSchema),
+var paletteSchema = z16.object({
+  colors: z16.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z19.object({
-  family: z19.string().min(1),
-  weight: z19.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z19.enum(["tight", "normal", "loose"]),
-  lineHeight: z19.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z16.object({
+  family: z16.string().min(1),
+  weight: z16.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z16.enum(["tight", "normal", "loose"]),
+  lineHeight: z16.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z19.enum(["md", "lg", "xl"])
+  size: z16.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z19.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z19.object({
-  weight: z19.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z19.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z16.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z16.object({
+  weight: z16.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z16.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z19.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z19.boolean().nullable().optional(),
-  colorToken: z19.string().min(1).nullable().optional()
+  lineHeight: z16.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z16.boolean().nullable().optional(),
+  colorToken: z16.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z19.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z19.boolean().nullable(),
-  colorToken: z19.string().min(1).nullable().optional()
+  case: z16.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z16.boolean().nullable(),
+  colorToken: z16.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
-var proseLinkUnderlineStyleSchema = z19.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z19.enum(["auto", "fromFont", "thin", "medium", "thick"]);
-var proseLinkUnderlineOffsetSchema = z19.enum(["auto", "tight", "normal", "loose"]);
-var proseLinkStyleSchema = z19.object({
-  colorToken: z19.string().min(1).optional(),
-  hoverColorToken: z19.string().min(1).optional(),
-  underline: z19.boolean().optional(),
-  decorationColorToken: z19.string().min(1).optional(),
-  hoverDecorationColorToken: z19.string().min(1).optional(),
+var proseLinkUnderlineStyleSchema = z16.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z16.enum(["auto", "fromFont", "thin", "medium", "thick"]);
+var proseLinkUnderlineOffsetSchema = z16.enum(["auto", "tight", "normal", "loose"]);
+var proseLinkStyleSchema = z16.object({
+  colorToken: z16.string().min(1).optional(),
+  hoverColorToken: z16.string().min(1).optional(),
+  underline: z16.boolean().optional(),
+  decorationColorToken: z16.string().min(1).optional(),
+  hoverDecorationColorToken: z16.string().min(1).optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z19.enum([
+var semanticSpacingSchema = z16.enum([
   "none",
   "compact",
   "cozy",
@@ -3049,62 +2457,62 @@ var semanticSpacingSchema = z19.enum([
   "comfortable",
   "spacious"
 ]);
-var boxRoundedSchema = z19.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z19.object({
-  type: z19.enum(["none", "color", "gradient"]).nullable().optional(),
-  color: z19.string().nullable().optional(),
-  gradient: z19.string().nullable().optional(),
-  opacity: z19.number().min(0).max(1).nullable().optional()
-});
-var boxBackgroundSchema = z19.object({
-  type: z19.enum(["color", "gradient", "image"]).optional(),
-  color: z19.string().nullable().optional(),
-  gradient: z19.string().nullable().optional(),
+var boxRoundedSchema = z16.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z16.object({
+  type: z16.enum(["none", "color", "gradient"]).nullable().optional(),
+  color: z16.string().nullable().optional(),
+  gradient: z16.string().nullable().optional(),
+  opacity: z16.number().min(0).max(1).nullable().optional()
+});
+var boxBackgroundSchema = z16.object({
+  type: z16.enum(["color", "gradient", "image"]).optional(),
+  color: z16.string().nullable().optional(),
+  gradient: z16.string().nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  objectFit: z19.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z19.string().nullable().optional(),
-  position: z19.string().nullable().optional(),
-  opacity: z19.number().min(0).max(1).nullable().optional(),
+  objectFit: z16.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z16.string().nullable().optional(),
+  position: z16.string().nullable().optional(),
+  opacity: z16.number().min(0).max(1).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
-  textColor: z19.string().nullable().optional(),
-  headingColor: z19.string().nullable().optional()
+  textColor: z16.string().nullable().optional(),
+  headingColor: z16.string().nullable().optional()
 });
-var sectionStylesOverrideSchema = z19.object({
+var sectionStylesOverrideSchema = z16.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z19.enum(["none", "hero", "immersive"]).nullable().optional()
+  minHeight: z16.enum(["none", "hero", "immersive"]).nullable().optional()
 });
-var containerStylesOverrideSchema = z19.object({
+var containerStylesOverrideSchema = z16.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z19.boolean().nullable().optional(),
+  raised: z16.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z19.boolean().nullable().optional()
+  fullWidth: z16.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z19.object({
-  enabled: z19.boolean().nullable().optional(),
-  width: z19.enum(["none", "1", "2", "3"]).nullable().optional(),
-  colorToken: z19.string().nullable().optional()
+var cardBorderOverrideSchema = z16.object({
+  enabled: z16.boolean().nullable().optional(),
+  width: z16.enum(["none", "1", "2", "3"]).nullable().optional(),
+  colorToken: z16.string().nullable().optional()
 });
-var cardStylesOverrideSchema = z19.object({
+var cardStylesOverrideSchema = z16.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z19.boolean().nullable().optional(),
+  raised: z16.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional()
 });
-var blockStyleOverridesSchema = z19.object({
+var blockStyleOverridesSchema = z16.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z19.object({
-  typography: z19.object({
+var blockThemeOverrideSchema = z16.object({
+  typography: z16.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z19.enum([
+var typographyScaleSchema = z16.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -3117,9 +2525,9 @@ var typographyScaleSchema = z19.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z19.object({
+var typographySchema = z16.object({
   body: bodyTypographyStyleSchema,
-  headings: z19.object({
+  headings: z16.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -3132,41 +2540,41 @@ var typographySchema = z19.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z19.enum(["comfortable", "standard", "dense"]);
-var corners = z19.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z19.object({
-  elevation: z19.enum(["none", "low", "medium", "high"]),
-  softness: z19.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z19.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z16.enum(["comfortable", "standard", "dense"]);
+var corners = z16.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z16.object({
+  elevation: z16.enum(["none", "low", "medium", "high"]),
+  softness: z16.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z16.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z19.object({
-  width: z19.enum(["none", "hairline", "thin", "thick"]),
-  style: z19.enum(["solid", "dashed"])
+var border = z16.object({
+  width: z16.enum(["none", "hairline", "thin", "thick"]),
+  style: z16.enum(["solid", "dashed"])
 });
-var motion = z19.object({
-  level: z19.enum(["off", "low", "medium", "high"]),
-  easing: z19.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z16.object({
+  level: z16.enum(["off", "low", "medium", "high"]),
+  easing: z16.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z19.object({
+var buttonStyle = z16.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z19.object({
-  elevation: z19.enum(["none", "low", "medium", "high"]),
-  border: z19.enum(["none", "subtle", "defined"]),
+var cardStyle = z16.object({
+  elevation: z16.enum(["none", "low", "medium", "high"]),
+  border: z16.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z19.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z19.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z16.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z16.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z19.object({
+var inputStyle = z16.object({
   shape: corners,
-  border: z19.enum(["subtle", "defined", "underline"]),
-  focus: z19.enum(["glow", "ring", "underline"]),
-  label: z19.enum(["inside", "above"])
+  border: z16.enum(["subtle", "defined", "underline"]),
+  focus: z16.enum(["glow", "ring", "underline"]),
+  label: z16.enum(["inside", "above"])
 });
-var headerVariant = z19.enum(["classic", "centered", "transparent", "floating", "editorial"]);
-var headerPositioning = z19.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z19.enum([
+var headerVariant = z16.enum(["classic", "centered", "transparent", "floating", "editorial"]);
+var headerPositioning = z16.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z16.enum([
   "minimal",
   "underline",
   "underline-grow",
@@ -3175,82 +2583,82 @@ var headerNavStyle = z19.enum([
   "frosted",
   "solid"
 ]);
-var navFontWeight = z19.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z19.enum(["container", "full"]);
-var headerContainerSchema = z19.object({
-  rounded: z19.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z19.boolean().default(true),
-  shadow: z19.boolean().default(true),
-  padding: z19.enum(["sm", "md", "lg"]).default("md"),
-  tint: z19.string().nullable().optional(),
-  opacity: z19.number().min(0).max(1).default(0.12)
+var navFontWeight = z16.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z16.enum(["container", "full"]);
+var headerContainerSchema = z16.object({
+  rounded: z16.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z16.boolean().default(true),
+  shadow: z16.boolean().default(true),
+  padding: z16.enum(["sm", "md", "lg"]).default("md"),
+  tint: z16.string().nullable().optional(),
+  opacity: z16.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z19.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z16.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z19.object({
-  fontFamily: z19.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z19.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z19.boolean().default(false)
+var logoStyleSchema = z16.object({
+  fontFamily: z16.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z16.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z16.boolean().default(false)
 }).optional();
-var headerLogoTextSchema = z19.object({
-  mobileWrapLines: z19.union([z19.literal(1), z19.literal(2)]).optional(),
-  mobileMaxWidth: z19.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z19.boolean().optional()
+var headerLogoTextSchema = z16.object({
+  mobileWrapLines: z16.union([z16.literal(1), z16.literal(2)]).optional(),
+  mobileMaxWidth: z16.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z16.boolean().optional()
 }).optional();
-var navEffectsSchema = z19.object({
-  underlineGradient: z19.boolean().default(false),
-  glow: z19.boolean().default(false),
-  glowColor: z19.string().optional(),
-  neumorphic: z19.boolean().default(false)
+var navEffectsSchema = z16.object({
+  underlineGradient: z16.boolean().default(false),
+  glow: z16.boolean().default(false),
+  glowColor: z16.string().optional(),
+  neumorphic: z16.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z19.object({
+var dropdownStyleSchema = z16.object({
   // Container styling
-  background: z19.string().default("surface"),
+  background: z16.string().default("surface"),
   // color token
-  textColor: z19.string().default("text"),
+  textColor: z16.string().default("text"),
   // color token
-  borderColor: z19.string().nullable().default("border"),
+  borderColor: z16.string().nullable().default("border"),
   // null = no border
-  shadow: z19.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z19.enum(["none", "sm", "md", "lg"]).default("md"),
+  shadow: z16.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z16.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
-  hoverBackground: z19.string().nullable().optional(),
+  hoverBackground: z16.string().nullable().optional(),
   // color token, null = transparent
-  hoverTextColor: z19.string().nullable().optional(),
+  hoverTextColor: z16.string().nullable().optional(),
   // color token, null = inherit
   // Typography
-  textTransform: z19.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z19.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z19.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z16.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z16.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z16.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z19.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z16.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z19.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navContainerSchema = z19.object({
-  type: z19.enum(["none", "pill", "glass"]).default("none"),
-  tint: z19.string().nullable().optional(),
-  opacity: z19.number().min(0).max(1).default(0.15)
+var headerCtaGapSchema = z16.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navContainerSchema = z16.object({
+  type: z16.enum(["none", "pill", "glass"]).default("none"),
+  tint: z16.string().nullable().optional(),
+  opacity: z16.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z19.object({
-  type: z19.enum(["color", "gradient", "image"]),
-  color: z19.string().nullable().optional(),
+var headerBackgroundSchema = z16.object({
+  type: z16.enum(["color", "gradient", "image"]),
+  color: z16.string().nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  textColor: z19.string().nullable().optional()
+  textColor: z16.string().nullable().optional()
 });
-var headerSchema = z19.object({
+var headerSchema = z16.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z19.boolean(),
+  shrinkOnScroll: z16.boolean(),
   maxWidth: headerMaxWidth,
   logoOverride: mediaSchema.nullable().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
-  textColor: z19.string().nullable().optional(),
+  textColor: z16.string().nullable().optional(),
   // Site title and general header text
   navStyle: headerNavStyle,
-  navColor: z19.string().nullable().optional(),
+  navColor: z16.string().nullable().optional(),
   // Nav links (inherits textColor if not set)
   navWeight: navFontWeight.default("medium"),
   // New fields for header system enhancement
@@ -3269,50 +2677,50 @@ var headerSchema = z19.object({
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z19.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z19.enum(["container", "full"]);
-var footerMode = z19.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z19.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z19.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z19.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var footerLogoPlacement = z19.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z19.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z19.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z19.object({
-  colorToken: z19.string().optional(),
-  hoverColorToken: z19.string().nullable().optional(),
-  decorationColorToken: z19.string().nullable().optional(),
-  underline: z19.boolean().optional()
-});
-var footerBottomBarSchema = z19.object({
-  enabled: z19.boolean().optional(),
-  fullBleed: z19.boolean().optional(),
+var footerVariant = z16.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z16.enum(["container", "full"]);
+var footerMode = z16.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z16.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z16.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z16.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var footerLogoPlacement = z16.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z16.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z16.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z16.object({
+  colorToken: z16.string().optional(),
+  hoverColorToken: z16.string().nullable().optional(),
+  decorationColorToken: z16.string().nullable().optional(),
+  underline: z16.boolean().optional()
+});
+var footerBottomBarSchema = z16.object({
+  enabled: z16.boolean().optional(),
+  fullBleed: z16.boolean().optional(),
   background: headerBackgroundSchema.optional(),
-  textColor: z19.string().nullable().optional(),
-  textAlign: z19.enum(["left", "center", "right"]).optional(),
+  textColor: z16.string().nullable().optional(),
+  textAlign: z16.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z19.object({
-    colorToken: z19.string().nullable().optional(),
-    width: z19.enum(["none", "thin", "medium", "thick"]).optional()
+  borderTop: z16.object({
+    colorToken: z16.string().nullable().optional(),
+    width: z16.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z19.object({
+var footerNavLayoutSchema = z16.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z19.number().int().min(1).max(6).optional()
+  columns: z16.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z19.object({
-  showLogo: z19.boolean().default(true),
-  showLogoText: z19.boolean().optional(),
+var footerLogoSchema = z16.object({
+  showLogo: z16.boolean().default(true),
+  showLogoText: z16.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z19.enum(["start", "center", "end"]).optional()
+  align: z16.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z19.object({
+var footerSchema = z16.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -3321,11 +2729,11 @@ var footerSchema = z19.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z19.boolean().optional(),
+  showLogoText: z16.boolean().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
   // Footer nav styling (independent from header)
   navStyle: headerNavStyle.default("minimal"),
-  navColor: z19.string().nullable().optional(),
+  navColor: z16.string().nullable().optional(),
   navWeight: navFontWeight.default("medium"),
   // Full nav link customization (overrides navStyle if set)
   navLinkStyle: navLinkStyleSchema.optional(),
@@ -3336,15 +2744,15 @@ var footerSchema = z19.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z19.enum(["tight", "compact", "default", "relaxed"]);
-var layoutSchema = z19.object({
-  containerPadding: z19.object({
+var containerPaddingPresetSchema = z16.enum(["tight", "compact", "default", "relaxed"]);
+var layoutSchema = z16.object({
+  containerPadding: z16.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z19.enum([
+var heroTypographySizeSchema = z16.enum([
   "sm",
   "base",
   "lg",
@@ -3355,14 +2763,14 @@ var heroTypographySizeSchema = z19.enum([
   "5xl",
   "6xl"
 ]);
-var heroTypographyLineHeightSchema = z19.enum(["tight", "snug", "normal", "relaxed"]);
-var heroResponsiveTypographySchema = z19.object({
+var heroTypographyLineHeightSchema = z16.enum(["tight", "snug", "normal", "relaxed"]);
+var heroResponsiveTypographySchema = z16.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z19.object({
+var heroTypographySchema = z16.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -3371,24 +2779,24 @@ var heroTypographySchema = z19.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z19.object({
+  responsive: z16.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z19.object({
+var heroSchema = z16.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var gradientsSchema = z19.object({
-  button: z19.string().min(1).nullable().optional(),
-  hero: z19.string().min(1).nullable().optional(),
-  background: z19.string().min(1).nullable().optional()
-});
-var themeSchema = z19.object({
-  name: z19.string().min(1).max(30),
-  description: z19.string().min(1).max(400),
-  rationale: z19.string().min(1).max(400),
-  siteStyleId: z19.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var gradientsSchema = z16.object({
+  button: z16.string().min(1).nullable().optional(),
+  hero: z16.string().min(1).nullable().optional(),
+  background: z16.string().min(1).nullable().optional()
+});
+var themeSchema = z16.object({
+  name: z16.string().min(1).max(30),
+  description: z16.string().min(1).max(400),
+  rationale: z16.string().min(1).max(400),
+  siteStyleId: z16.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -3415,16 +2823,16 @@ var themeSchema = z19.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z19.record(
-    z19.string(),
+  blockCustomVars: z16.record(
+    z16.string(),
     // block kind (matches data-block attribute)
-    z19.record(z19.string(), z19.string())
+    z16.record(z16.string(), z16.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: z19.record(
-    z19.string(),
+  blockOverrides: z16.record(
+    z16.string(),
     blockThemeOverrideSchema
   ).optional(),
   // Structured custom CSS rules
@@ -3460,371 +2868,1021 @@ var themeSchema = z19.object({
    * }
    * ```
    */
-  styleGroups: z19.record(z19.string(), z19.array(z19.string())).optional()
+  styleGroups: z16.record(z16.string(), z16.array(z16.string())).optional()
+});
+var themesTurnSchema = z16.object({
+  message: z16.string().min(1),
+  themes: z16.array(themeSchema).length(3)
+});
+
+// ../theme-core/src/palette/variants/types.ts
+function asPaletteVariantId(value) {
+  if (value.length === 0) {
+    throw new Error("PaletteVariantId must be a non-empty string");
+  }
+  return value;
+}
+var paletteVariantIdSchema = z17.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 = z17.enum(PALETTE_TOKEN_NAMES);
+var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
+var hexColorSchema = z17.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var variantPaletteColorSchema = paletteColorSchema.extend({
+  name: paletteTokenNameSchema
+});
+var paletteVariantSchema = z17.object({
+  id: paletteVariantIdSchema,
+  name: z17.string().min(1),
+  description: z17.string().min(1),
+  tags: styleTagsSchema,
+  mode: z17.enum(["light", "dark"]),
+  colors: z17.array(variantPaletteColorSchema).min(1)
+});
+function definePaletteVariant(input) {
+  return {
+    id: asPaletteVariantId(input.id),
+    name: input.name,
+    description: input.description,
+    tags: input.tags,
+    mode: input.mode,
+    colors: input.colors
+  };
+}
+var paletteOverridesSchema = z17.object({
+  primary: hexColorSchema.optional(),
+  primaryForeground: hexColorSchema.optional(),
+  secondary: hexColorSchema.optional(),
+  accent: hexColorSchema.optional(),
+  success: hexColorSchema.optional(),
+  warning: hexColorSchema.optional(),
+  destructive: hexColorSchema.optional(),
+  background: hexColorSchema.optional(),
+  surface: hexColorSchema.optional(),
+  surfaceAlt: hexColorSchema.optional(),
+  muted: hexColorSchema.optional(),
+  text: hexColorSchema.optional(),
+  border: hexColorSchema.optional()
+}).strict().transform((value) => value);
+
+// ../theme-core/src/palette/variants/brand-led.ts
+var brandLedCool = definePaletteVariant({
+  id: "brand-led-cool",
+  name: "Brand-led \u2014 Cool",
+  description: "Confident blue primary with slate neutrals.",
+  tags: { tone: "classic", energy: "calm", era: "modern" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#2563eb" },
+    { name: "secondary", hex: "#64748b" },
+    { name: "accent", hex: "#0f766e" },
+    { name: "success", hex: "#16a34a" },
+    { name: "warning", hex: "#d97706" },
+    { name: "destructive", hex: "#dc2626" },
+    { name: "background", hex: "#ffffff" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f8fafc" },
+    { name: "muted", hex: "#f1f5f9" },
+    { name: "text", hex: "#0f172a" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#cbd5e1" }
+  ]
+});
+var brandLedWarm = definePaletteVariant({
+  id: "brand-led-warm",
+  name: "Brand-led \u2014 Warm",
+  description: "Sunset orange primary with warm grey neutrals.",
+  tags: { tone: "classic", energy: "vibrant", era: "modern" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#ea580c" },
+    { name: "secondary", hex: "#78716c" },
+    { name: "accent", hex: "#a16207" },
+    { name: "success", hex: "#16a34a" },
+    { name: "warning", hex: "#d97706" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#fffaf3" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#fbeee0" },
+    { name: "muted", hex: "#f4e2cd" },
+    { name: "text", hex: "#1c1917" },
+    { name: "primaryForeground", hex: "#fffaf3" },
+    { name: "border", hex: "#d6c4ad" }
+  ]
+});
+var brandLedJewel = definePaletteVariant({
+  id: "brand-led-jewel",
+  name: "Brand-led \u2014 Jewel",
+  description: "Deep emerald primary with rich neutrals.",
+  tags: { tone: "bold", energy: "vibrant", era: "modern" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#047857" },
+    { name: "secondary", hex: "#4b5563" },
+    { name: "accent", hex: "#7c3aed" },
+    { name: "success", hex: "#15803d" },
+    { name: "warning", hex: "#b45309" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#ffffff" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f5f5f4" },
+    { name: "muted", hex: "#e7e5e4" },
+    { name: "text", hex: "#0c0a09" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#a8a29e" }
+  ]
+});
+
+// ../theme-core/src/palette/variants/high-contrast.ts
+var highContrastInk = definePaletteVariant({
+  id: "high-contrast-ink",
+  name: "High Contrast \u2014 Ink",
+  description: "Near-black primary with cool greys.",
+  tags: { tone: "bold", energy: "calm", era: "editorial" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#111827" },
+    { name: "secondary", hex: "#374151" },
+    { name: "accent", hex: "#1d4ed8" },
+    { name: "success", hex: "#047857" },
+    { name: "warning", hex: "#b45309" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#ffffff" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f3f4f6" },
+    { name: "muted", hex: "#e5e7eb" },
+    { name: "text", hex: "#030712" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#6b7280" }
+  ]
+});
+var highContrastCharcoal = definePaletteVariant({
+  id: "high-contrast-charcoal",
+  name: "High Contrast \u2014 Charcoal",
+  description: "Warm charcoal primary on a soft cream ground.",
+  tags: { tone: "minimal", energy: "calm", era: "editorial" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#1f2937" },
+    { name: "secondary", hex: "#52525b" },
+    { name: "accent", hex: "#a16207" },
+    { name: "success", hex: "#15803d" },
+    { name: "warning", hex: "#b45309" },
+    { name: "destructive", hex: "#991b1b" },
+    { name: "background", hex: "#fafaf9" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f5f5f4" },
+    { name: "muted", hex: "#e7e5e4" },
+    { name: "text", hex: "#0c0a09" },
+    { name: "primaryForeground", hex: "#fafaf9" },
+    { name: "border", hex: "#a8a29e" }
+  ]
+});
+var highContrastMonochrome = definePaletteVariant({
+  id: "high-contrast-monochrome",
+  name: "High Contrast \u2014 Monochrome",
+  description: "Pure black-on-white with a single saturated accent.",
+  tags: { tone: "bold", energy: "vibrant", era: "editorial" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#000000" },
+    { name: "secondary", hex: "#404040" },
+    { name: "accent", hex: "#dc2626" },
+    { name: "success", hex: "#000000" },
+    { name: "warning", hex: "#000000" },
+    { name: "destructive", hex: "#dc2626" },
+    { name: "background", hex: "#ffffff" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f5f5f5" },
+    { name: "muted", hex: "#e5e5e5" },
+    { name: "text", hex: "#000000" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#525252" }
+  ]
+});
+
+// ../theme-core/src/palette/variants/soft-natural.ts
+var softNaturalSage = definePaletteVariant({
+  id: "soft-natural-sage",
+  name: "Soft Natural \u2014 Sage",
+  description: "Olive sage primary on an off-white ground.",
+  tags: { tone: "classic", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#3f6212" },
+    { name: "secondary", hex: "#6b7280" },
+    { name: "accent", hex: "#0f766e" },
+    { name: "success", hex: "#15803d" },
+    { name: "warning", hex: "#a16207" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#fbfdf7" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#eef5e8" },
+    { name: "muted", hex: "#e7efdf" },
+    { name: "text", hex: "#1f2a1d" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#cbd8c0" }
+  ]
+});
+var softNaturalStone = definePaletteVariant({
+  id: "soft-natural-stone",
+  name: "Soft Natural \u2014 Stone",
+  description: "River-stone grey-green primary with cool neutrals.",
+  tags: { tone: "minimal", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#5a7a5d" },
+    { name: "secondary", hex: "#8a9a8c" },
+    { name: "accent", hex: "#c9b88f" },
+    { name: "success", hex: "#5a7a5d" },
+    { name: "warning", hex: "#a89466" },
+    { name: "destructive", hex: "#a3503e" },
+    { name: "background", hex: "#faf6ec" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f0ecdf" },
+    { name: "muted", hex: "#e6e1d0" },
+    { name: "text", hex: "#2f3d31" },
+    { name: "primaryForeground", hex: "#faf6ec" },
+    { name: "border", hex: "#c9c1ad" }
+  ]
 });
-var themesTurnSchema = z19.object({
-  message: z19.string().min(1),
-  themes: z19.array(themeSchema).length(3)
+var softNaturalWatercolor = definePaletteVariant({
+  id: "soft-natural-watercolor",
+  name: "Soft Natural \u2014 Watercolor",
+  description: "Soft sand primary with watercolour sage accents.",
+  tags: { tone: "classic", energy: "vibrant", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#a8825f" },
+    { name: "secondary", hex: "#88a888" },
+    { name: "accent", hex: "#c8a78e" },
+    { name: "success", hex: "#7d8a5f" },
+    { name: "warning", hex: "#c89a4d" },
+    { name: "destructive", hex: "#a3503e" },
+    { name: "background", hex: "#fefdfa" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f6f1e6" },
+    { name: "muted", hex: "#eee7d1" },
+    { name: "text", hex: "#4a3d30" },
+    { name: "primaryForeground", hex: "#fefdfa" },
+    { name: "border", hex: "#d8c9a8" }
+  ]
 });
 
-// ../theme-core/src/palette/variants/types.ts
-import { z as z20 } from "zod";
-function asPaletteVariantId(value) {
-  if (value.length === 0) {
-    throw new Error("PaletteVariantId must be a non-empty string");
-  }
-  return value;
-}
-var paletteVariantIdSchema = z20.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 = z20.enum(PALETTE_TOKEN_NAMES);
-var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z20.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
-var variantPaletteColorSchema = paletteColorSchema.extend({
-  name: paletteTokenNameSchema
+// ../theme-core/src/palette/variants/warm-neutral.ts
+var warmNeutralClay = definePaletteVariant({
+  id: "warm-neutral-clay",
+  name: "Warm Neutral \u2014 Clay",
+  description: "Terracotta primary on a cream ground.",
+  tags: { tone: "classic", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#8b5e34" },
+    { name: "secondary", hex: "#7c6f64" },
+    { name: "accent", hex: "#a15c38" },
+    { name: "success", hex: "#527853" },
+    { name: "warning", hex: "#b7791f" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#fffaf3" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f5eadc" },
+    { name: "muted", hex: "#efe2d0" },
+    { name: "text", hex: "#2f241c" },
+    { name: "primaryForeground", hex: "#fffaf3" },
+    { name: "border", hex: "#d8c6b3" }
+  ]
 });
-var paletteVariantSchema = z20.object({
-  id: paletteVariantIdSchema,
-  name: z20.string().min(1),
-  description: z20.string().min(1),
-  tags: styleTagsSchema,
-  mode: z20.enum(["light", "dark"]),
-  colors: z20.array(variantPaletteColorSchema).min(1)
+var warmNeutralCream = definePaletteVariant({
+  id: "warm-neutral-cream",
+  name: "Warm Neutral \u2014 Cream",
+  description: "Soft sand primary with pale cream surfaces.",
+  tags: { tone: "minimal", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#b08864" },
+    { name: "secondary", hex: "#9a8c7e" },
+    { name: "accent", hex: "#c2956a" },
+    { name: "success", hex: "#7d8a5f" },
+    { name: "warning", hex: "#c89a4d" },
+    { name: "destructive", hex: "#a3503e" },
+    { name: "background", hex: "#fdf8ee" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f4ebd9" },
+    { name: "muted", hex: "#ede3cf" },
+    { name: "text", hex: "#3b2f24" },
+    { name: "primaryForeground", hex: "#fdf8ee" },
+    { name: "border", hex: "#e0d2b8" }
+  ]
 });
-function definePaletteVariant(input) {
+var warmNeutralForest = definePaletteVariant({
+  id: "warm-neutral-forest",
+  name: "Warm Neutral \u2014 Forest",
+  description: "Deep forest green primary with earthy neutrals.",
+  tags: { tone: "classic", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#3d5840" },
+    { name: "secondary", hex: "#7a6f5d" },
+    { name: "accent", hex: "#b06b50" },
+    { name: "success", hex: "#5a7a5d" },
+    { name: "warning", hex: "#b7791f" },
+    { name: "destructive", hex: "#b91c1c" },
+    { name: "background", hex: "#fbf8f0" },
+    { name: "surface", hex: "#ffffff" },
+    { name: "surfaceAlt", hex: "#f2ecdb" },
+    { name: "muted", hex: "#ebe3cc" },
+    { name: "text", hex: "#2a2a2a" },
+    { name: "primaryForeground", hex: "#fbf8f0" },
+    { name: "border", hex: "#cdc1a4" }
+  ]
+});
+
+// ../theme-core/src/palette/variants/index.ts
+var paletteVariants = [
+  // Brand-led family
+  brandLedCool,
+  brandLedWarm,
+  brandLedJewel,
+  // Warm-neutral family
+  warmNeutralClay,
+  warmNeutralCream,
+  warmNeutralForest,
+  // High-contrast family
+  highContrastInk,
+  highContrastCharcoal,
+  highContrastMonochrome,
+  // Soft-natural family
+  softNaturalSage,
+  softNaturalStone,
+  softNaturalWatercolor
+];
+var paletteVariantsById = new Map(
+  paletteVariants.map((v) => [v.id, v])
+);
+
+// ../theme-core/src/site-styles/sourceCatalogs.ts
+var generatedContentFrames = [
+  plainFrame,
+  panelFrame("inset"),
+  panelFrame("raised"),
+  flushPanelFrame({ bleed: "start" })
+];
+var userContentFrames = [
+  ...generatedContentFrames,
+  panelFrame("editorial"),
+  flushPanelFrame({ bleed: "end" }),
+  flushPanelFrame({ bleed: "both" })
+];
+var generatedDesignOptionCatalog = {
+  source: "generated",
+  sectionSurfaces: ["base", "muted-band", "accent-band", "hero-image"],
+  contentFrames: generatedContentFrames,
+  itemSurfaces: ["none", "default", "flat", "outlined", "raised"],
+  transitions: ["none", "soft-fade-short", "soft-fade-long"],
+  emphases: ["low", "medium", "high"],
+  detachedCustom: false
+};
+var userDesignOptionCatalog = {
+  source: "user",
+  sectionSurfaces: generatedDesignOptionCatalog.sectionSurfaces,
+  contentFrames: userContentFrames,
+  itemSurfaces: [
+    ...generatedDesignOptionCatalog.itemSurfaces,
+    "inset",
+    "editorial"
+  ],
+  transitions: [
+    ...generatedDesignOptionCatalog.transitions,
+    "wave-edge",
+    "angle-edge"
+  ],
+  emphases: generatedDesignOptionCatalog.emphases,
+  detachedCustom: false
+};
+var advancedDesignOptionCatalog = {
+  source: "advanced",
+  sectionSurfaces: userDesignOptionCatalog.sectionSurfaces,
+  contentFrames: userDesignOptionCatalog.contentFrames,
+  itemSurfaces: userDesignOptionCatalog.itemSurfaces,
+  transitions: userDesignOptionCatalog.transitions,
+  emphases: userDesignOptionCatalog.emphases,
+  detachedCustom: true
+};
+
+// ../theme-core/src/site-styles/curatedSiteStyles.ts
+var curatedSiteStyleIdValues = [
+  "site-style:calm-studio",
+  "site-style:clear-professional",
+  "site-style:warm-editorial",
+  "site-style:bright-community",
+  "site-style:quiet-luxury",
+  "site-style:practical-services",
+  "site-style:modern-wellness",
+  "site-style:bold-launch"
+];
+var quietBudget = {
+  accentDensity: "low",
+  panelDensity: "medium",
+  transitionMix: "quiet",
+  primaryCtaLimit: 2,
+  mediaDensity: "medium",
+  decorativeRepetition: "low"
+};
+var balancedBudget = {
+  accentDensity: "medium",
+  panelDensity: "medium",
+  transitionMix: "balanced",
+  primaryCtaLimit: 3,
+  mediaDensity: "medium",
+  decorativeRepetition: "medium"
+};
+var expressiveBudget = {
+  accentDensity: "high",
+  panelDensity: "high",
+  transitionMix: "expressive",
+  primaryCtaLimit: 3,
+  mediaDensity: "high",
+  decorativeRepetition: "medium"
+};
+function uniqueContentFrameKinds() {
+  const kinds = [...new Set(
+    generatedDesignOptionCatalog.contentFrames.map((frame) => frame.kind)
+  )];
+  const firstKind = kinds[0];
+  if (!firstKind) {
+    throw new Error("Expected generated design option catalog to expose at least one content frame kind.");
+  }
+  return [firstKind, ...kinds.slice(1)];
+}
+var generatedContentFrameKinds = uniqueContentFrameKinds();
+function defineCuratedSiteStyle(input) {
   return {
-    id: asPaletteVariantId(input.id),
+    id: asSiteStyleId(input.id),
     name: input.name,
     description: input.description,
-    tags: input.tags,
-    mode: input.mode,
-    colors: input.colors
+    generationBrief: input.generationBrief,
+    selectionKeywords: input.selectionKeywords ?? [],
+    template: {
+      id: asDesignSystemTemplateId(`template:${input.id.replace("site-style:", "")}`),
+      name: input.name,
+      version: 1,
+      tokenRecipes: input.tokenRecipes,
+      compositionBudget: input.compositionBudget,
+      supportedSectionSurfaces: generatedDesignOptionCatalog.sectionSurfaces,
+      supportedContentFrames: generatedContentFrameKinds,
+      supportedItemSurfaces: generatedDesignOptionCatalog.itemSurfaces,
+      supportedTransitions: generatedDesignOptionCatalog.transitions
+    },
+    buttonPersonalityChoices: input.buttonPersonalityChoices,
+    paletteVariantChoices: input.paletteVariantChoices
   };
 }
-var paletteOverridesSchema = z20.object({
-  primary: hexColorSchema.optional(),
-  primaryForeground: hexColorSchema.optional(),
-  secondary: hexColorSchema.optional(),
-  accent: hexColorSchema.optional(),
-  success: hexColorSchema.optional(),
-  warning: hexColorSchema.optional(),
-  destructive: hexColorSchema.optional(),
-  background: hexColorSchema.optional(),
-  surface: hexColorSchema.optional(),
-  surfaceAlt: hexColorSchema.optional(),
-  muted: hexColorSchema.optional(),
-  text: hexColorSchema.optional(),
-  border: hexColorSchema.optional()
-}).strict().transform((value) => value);
-
-// ../theme-core/src/palette/variants/brand-led.ts
-var brandLedCool = definePaletteVariant({
-  id: "brand-led-cool",
-  name: "Brand-led \u2014 Cool",
-  description: "Confident blue primary with slate neutrals.",
-  tags: { tone: "classic", energy: "calm", era: "modern" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#2563eb" },
-    { name: "secondary", hex: "#64748b" },
-    { name: "accent", hex: "#0f766e" },
-    { name: "success", hex: "#16a34a" },
-    { name: "warning", hex: "#d97706" },
-    { name: "destructive", hex: "#dc2626" },
-    { name: "background", hex: "#ffffff" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f8fafc" },
-    { name: "muted", hex: "#f1f5f9" },
-    { name: "text", hex: "#0f172a" },
-    { name: "primaryForeground", hex: "#ffffff" },
-    { name: "border", hex: "#cbd5e1" }
-  ]
-});
-var brandLedWarm = definePaletteVariant({
-  id: "brand-led-warm",
-  name: "Brand-led \u2014 Warm",
-  description: "Sunset orange primary with warm grey neutrals.",
-  tags: { tone: "classic", energy: "vibrant", era: "modern" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#ea580c" },
-    { name: "secondary", hex: "#78716c" },
-    { name: "accent", hex: "#a16207" },
-    { name: "success", hex: "#16a34a" },
-    { name: "warning", hex: "#d97706" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#fffaf3" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#fbeee0" },
-    { name: "muted", hex: "#f4e2cd" },
-    { name: "text", hex: "#1c1917" },
-    { name: "primaryForeground", hex: "#fffaf3" },
-    { name: "border", hex: "#d6c4ad" }
-  ]
-});
-var brandLedJewel = definePaletteVariant({
-  id: "brand-led-jewel",
-  name: "Brand-led \u2014 Jewel",
-  description: "Deep emerald primary with rich neutrals.",
-  tags: { tone: "bold", energy: "vibrant", era: "modern" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#047857" },
-    { name: "secondary", hex: "#4b5563" },
-    { name: "accent", hex: "#7c3aed" },
-    { name: "success", hex: "#15803d" },
-    { name: "warning", hex: "#b45309" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#ffffff" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f5f5f4" },
-    { name: "muted", hex: "#e7e5e4" },
-    { name: "text", hex: "#0c0a09" },
-    { name: "primaryForeground", hex: "#ffffff" },
-    { name: "border", hex: "#a8a29e" }
-  ]
-});
+function buttonChoice(id, note) {
+  return note ? { id: asButtonPersonalityId(id), note } : { id: asButtonPersonalityId(id) };
+}
+function paletteChoice(id, note) {
+  return note ? { id: asPaletteVariantId(id), note } : { id: asPaletteVariantId(id) };
+}
+var curatedSiteStyles = [
+  defineCuratedSiteStyle({
+    id: "site-style:calm-studio",
+    name: "Calm Studio",
+    description: "Soft, measured, and spacious for intimate appointment or class businesses.",
+    generationBrief: "Use calm pacing, concise copy, generous breathing room, and natural imagery. Keep calls to action steady rather than urgent.",
+    tokenRecipes: {
+      palette: "soft-natural",
+      contrast: "standard",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "friendly-sans",
+      spacing: "airy",
+      motion: "subtle"
+    },
+    compositionBudget: quietBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("soft-pill"),
+      buttonChoice("pebble"),
+      buttonChoice("editorial-link"),
+      buttonChoice("brushed-wash")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("soft-natural-sage"),
+      paletteChoice("soft-natural-stone"),
+      paletteChoice("warm-neutral-clay"),
+      paletteChoice("soft-natural-watercolor")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:clear-professional",
+    name: "Clear Professional",
+    description: "Crisp, trustworthy, and direct for local services and consultancies.",
+    generationBrief: "Prioritize clarity, proof, service detail, and easy next steps. Keep visuals polished and specific, with restrained decorative treatment.",
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "strong",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "regular",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("confident-chip"),
+      buttonChoice("soft-pill"),
+      buttonChoice("editorial-link")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("brand-led-cool"),
+      paletteChoice("high-contrast-ink"),
+      paletteChoice("brand-led-jewel")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:warm-editorial",
+    name: "Warm Editorial",
+    description: "Story-led and textured for educators, makers, venues, and retreats.",
+    generationBrief: "Let the copy feel thoughtful and grounded. Favor narrative sections, supporting media, and a small number of editorial panels.",
+    tokenRecipes: {
+      palette: "warm-neutral",
+      contrast: "standard",
+      radius: "square",
+      shadow: "none",
+      typography: "serif-editorial",
+      spacing: "airy",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("editorial-link"),
+      buttonChoice("soft-pill"),
+      buttonChoice("brushed-wash")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("warm-neutral-cream"),
+      paletteChoice("warm-neutral-clay"),
+      paletteChoice("warm-neutral-forest"),
+      paletteChoice("soft-natural-stone")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:bright-community",
+    name: "Bright Community",
+    description: "Friendly, welcoming, and active for groups, classes, and neighborhood offers.",
+    generationBrief: "Use welcoming language, clear event or booking routes, and optimistic imagery. Let accents appear, but avoid noisy decoration.",
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "standard",
+      radius: "rounded",
+      shadow: "subtle",
+      typography: "friendly-sans",
+      spacing: "regular",
+      motion: "expressive"
+    },
+    compositionBudget: balancedBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("pebble"),
+      buttonChoice("brushed-wash"),
+      buttonChoice("confident-chip")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("brand-led-warm"),
+      paletteChoice("brand-led-jewel"),
+      paletteChoice("soft-natural-watercolor")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:quiet-luxury",
+    name: "Quiet Luxury",
+    description: "Minimal, confident, and refined for premium experiences and private services.",
+    generationBrief: "Use fewer claims, more specificity, and restrained sensory detail. Favor elegant media and low repetition over dense panels.",
+    selectionKeywords: [
+      "luxury",
+      "premium",
+      "boutique",
+      "bespoke",
+      "exclusive"
+    ],
+    tokenRecipes: {
+      palette: "high-contrast",
+      contrast: "strong",
+      radius: "square",
+      shadow: "none",
+      typography: "classic-serif",
+      spacing: "airy",
+      motion: "none"
+    },
+    compositionBudget: quietBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("editorial-link"),
+      buttonChoice("confident-chip"),
+      buttonChoice("soft-pill")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("high-contrast-charcoal"),
+      paletteChoice("high-contrast-ink"),
+      paletteChoice("warm-neutral-cream")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:practical-services",
+    name: "Practical Services",
+    description: "Efficient, plainspoken, and conversion-focused for trades and everyday services.",
+    generationBrief: "Make services, location, trust signals, and contact paths obvious. Keep copy brief and avoid ornate visual treatments.",
+    selectionKeywords: [
+      "repair",
+      "plumb",
+      "electric",
+      "cleaning",
+      "landscap",
+      "contractor"
+    ],
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "maximum",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "compact",
+      motion: "none"
+    },
+    compositionBudget: quietBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("confident-chip"),
+      buttonChoice("pebble"),
+      buttonChoice("ink-stamp")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("brand-led-cool"),
+      paletteChoice("high-contrast-ink"),
+      paletteChoice("brand-led-warm")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:modern-wellness",
+    name: "Modern Wellness",
+    description: "Natural, current, and reassuring for practitioners, studios, and wellbeing offers.",
+    generationBrief: "Keep the tone warm and practical. Use gentle section variation, natural materials, and inclusive copy without making medical claims.",
+    tokenRecipes: {
+      palette: "soft-natural",
+      contrast: "standard",
+      radius: "rounded",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "airy",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("soft-pill"),
+      buttonChoice("pebble"),
+      buttonChoice("confident-chip")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("soft-natural-sage"),
+      paletteChoice("soft-natural-stone"),
+      paletteChoice("warm-neutral-forest")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:bold-launch",
+    name: "Bold Launch",
+    description: "High-energy and punchy for launches, campaigns, and creative offers.",
+    generationBrief: "Use crisp positioning, bold hero structure, strong calls to action, and confident visual rhythm. Keep it precise, not shouty.",
+    selectionKeywords: [
+      "launch",
+      "campaign",
+      "preorder",
+      "pre-order",
+      "waitlist",
+      "drop"
+    ],
+    tokenRecipes: {
+      palette: "high-contrast",
+      contrast: "maximum",
+      radius: "pill",
+      shadow: "layered",
+      typography: "clean-sans",
+      spacing: "regular",
+      motion: "expressive"
+    },
+    compositionBudget: expressiveBudget,
+    buttonPersonalityChoices: [
+      buttonChoice("ink-stamp"),
+      buttonChoice("confident-chip"),
+      buttonChoice("brushed-wash"),
+      buttonChoice("pebble")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("high-contrast-monochrome"),
+      paletteChoice("high-contrast-ink"),
+      paletteChoice("brand-led-jewel"),
+      paletteChoice("brand-led-warm")
+    ]
+  })
+];
+var curatedSiteStylesById = new Map(
+  curatedSiteStyles.map((style) => [style.id, style])
+);
 
-// ../theme-core/src/palette/variants/high-contrast.ts
-var highContrastInk = definePaletteVariant({
-  id: "high-contrast-ink",
-  name: "High Contrast \u2014 Ink",
-  description: "Near-black primary with cool greys.",
-  tags: { tone: "bold", energy: "calm", era: "editorial" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#111827" },
-    { name: "secondary", hex: "#374151" },
-    { name: "accent", hex: "#1d4ed8" },
-    { name: "success", hex: "#047857" },
-    { name: "warning", hex: "#b45309" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#ffffff" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f3f4f6" },
-    { name: "muted", hex: "#e5e7eb" },
-    { name: "text", hex: "#030712" },
-    { name: "primaryForeground", hex: "#ffffff" },
-    { name: "border", hex: "#6b7280" }
-  ]
-});
-var highContrastCharcoal = definePaletteVariant({
-  id: "high-contrast-charcoal",
-  name: "High Contrast \u2014 Charcoal",
-  description: "Warm charcoal primary on a soft cream ground.",
-  tags: { tone: "minimal", energy: "calm", era: "editorial" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#1f2937" },
-    { name: "secondary", hex: "#52525b" },
-    { name: "accent", hex: "#a16207" },
-    { name: "success", hex: "#15803d" },
-    { name: "warning", hex: "#b45309" },
-    { name: "destructive", hex: "#991b1b" },
-    { name: "background", hex: "#fafaf9" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f5f5f4" },
-    { name: "muted", hex: "#e7e5e4" },
-    { name: "text", hex: "#0c0a09" },
-    { name: "primaryForeground", hex: "#fafaf9" },
-    { name: "border", hex: "#a8a29e" }
-  ]
-});
-var highContrastMonochrome = definePaletteVariant({
-  id: "high-contrast-monochrome",
-  name: "High Contrast \u2014 Monochrome",
-  description: "Pure black-on-white with a single saturated accent.",
-  tags: { tone: "bold", energy: "vibrant", era: "editorial" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#000000" },
-    { name: "secondary", hex: "#404040" },
-    { name: "accent", hex: "#dc2626" },
-    { name: "success", hex: "#000000" },
-    { name: "warning", hex: "#000000" },
-    { name: "destructive", hex: "#dc2626" },
-    { name: "background", hex: "#ffffff" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f5f5f5" },
-    { name: "muted", hex: "#e5e5e5" },
-    { name: "text", hex: "#000000" },
-    { name: "primaryForeground", hex: "#ffffff" },
-    { name: "border", hex: "#525252" }
-  ]
-});
+// ../theme-core/src/site-styles/designState.ts
+import { z as z18 } from "zod";
 
-// ../theme-core/src/palette/variants/soft-natural.ts
-var softNaturalSage = definePaletteVariant({
-  id: "soft-natural-sage",
-  name: "Soft Natural \u2014 Sage",
-  description: "Olive sage primary on an off-white ground.",
-  tags: { tone: "classic", energy: "calm", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#3f6212" },
-    { name: "secondary", hex: "#6b7280" },
-    { name: "accent", hex: "#0f766e" },
-    { name: "success", hex: "#15803d" },
-    { name: "warning", hex: "#a16207" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#fbfdf7" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#eef5e8" },
-    { name: "muted", hex: "#e7efdf" },
-    { name: "text", hex: "#1f2a1d" },
-    { name: "primaryForeground", hex: "#ffffff" },
-    { name: "border", hex: "#cbd8c0" }
-  ]
-});
-var softNaturalStone = definePaletteVariant({
-  id: "soft-natural-stone",
-  name: "Soft Natural \u2014 Stone",
-  description: "River-stone grey-green primary with cool neutrals.",
-  tags: { tone: "minimal", energy: "calm", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#5a7a5d" },
-    { name: "secondary", hex: "#8a9a8c" },
-    { name: "accent", hex: "#c9b88f" },
-    { name: "success", hex: "#5a7a5d" },
-    { name: "warning", hex: "#a89466" },
-    { name: "destructive", hex: "#a3503e" },
-    { name: "background", hex: "#faf6ec" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f0ecdf" },
-    { name: "muted", hex: "#e6e1d0" },
-    { name: "text", hex: "#2f3d31" },
-    { name: "primaryForeground", hex: "#faf6ec" },
-    { name: "border", hex: "#c9c1ad" }
-  ]
-});
-var softNaturalWatercolor = definePaletteVariant({
-  id: "soft-natural-watercolor",
-  name: "Soft Natural \u2014 Watercolor",
-  description: "Soft sand primary with watercolour sage accents.",
-  tags: { tone: "classic", energy: "vibrant", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#a8825f" },
-    { name: "secondary", hex: "#88a888" },
-    { name: "accent", hex: "#c8a78e" },
-    { name: "success", hex: "#7d8a5f" },
-    { name: "warning", hex: "#c89a4d" },
-    { name: "destructive", hex: "#a3503e" },
-    { name: "background", hex: "#fefdfa" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f6f1e6" },
-    { name: "muted", hex: "#eee7d1" },
-    { name: "text", hex: "#4a3d30" },
-    { name: "primaryForeground", hex: "#fefdfa" },
-    { name: "border", hex: "#d8c9a8" }
-  ]
-});
+// ../theme-core/src/site-styles/rawStyleFields.ts
+var themeV2RuntimeStyleFieldNames = [
+  "_frameStyles",
+  "_sectionStyles",
+  "_containerStyles",
+  "_cardStyles",
+  // styleGroup is legacy runtime transition wiring rather than a nested
+  // override object, but normal editors should still never see it directly.
+  "styleGroup"
+];
+var themeV2BlockSpecificRawStyleFieldNames = [
+  "_contentCardStyles",
+  "_textCardStyles"
+];
+var themeV2NormalEditorRawStyleFieldNames = [
+  ...themeV2RuntimeStyleFieldNames,
+  ...themeV2BlockSpecificRawStyleFieldNames
+];
+var themeV2NormalEditorRawStyleFieldNameSet = new Set(
+  themeV2NormalEditorRawStyleFieldNames
+);
+
+// ../theme-core/src/site-styles/designState.ts
+var themeV2DesignStateSchemaVersion = 1;
+var designResolutionPolicySchema = z18.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z18.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z18.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
+  fields3[0],
+  ...fields3.slice(1)
+]);
+var heroLegibilityStrategySchema = z18.enum([
+  "none",
+  "scrim-gradient",
+  "solid-panel"
+]);
+function uniqueNonEmpty(values) {
+  const uniqueValues = [...new Set(values)];
+  const firstValue = uniqueValues[0];
+  if (!firstValue) {
+    throw new Error("Expected at least one Theme V2 design state option.");
+  }
+  return [firstValue, ...uniqueValues.slice(1)];
+}
+var userPanelTreatments = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
+);
+var userFlushTreatments = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
+);
+var userFlushBleeds = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
+);
+var contentFrameIntentSchema = z18.discriminatedUnion("kind", [
+  z18.object({ kind: z18.literal("plain") }).strict(),
+  z18.object({
+    kind: z18.literal("panel"),
+    treatment: z18.enum(userPanelTreatments)
+  }).strict(),
+  z18.object({
+    kind: z18.literal("flush-panel"),
+    treatment: z18.enum(userFlushTreatments),
+    bleed: z18.enum(userFlushBleeds)
+  }).strict()
+]);
+var blockDesignPlanSchema = z18.object({
+  blockId: z18.string().min(1).transform(asDesignBlockId),
+  blockKind: z18.string().min(1),
+  purpose: z18.string().min(1),
+  sectionSurface: z18.enum(userDesignOptionCatalog.sectionSurfaces),
+  contentFrame: contentFrameIntentSchema,
+  itemSurface: z18.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z18.enum(userDesignOptionCatalog.transitions),
+  emphasis: z18.enum(userDesignOptionCatalog.emphases),
+  heroLegibility: heroLegibilityStrategySchema.optional()
+}).strict();
+var styleAuthoritySchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("theme-v2"),
+    source: designResolutionPolicySchema,
+    siteStyleId: z18.string().min(1).transform(asSiteStyleId),
+    templateId: z18.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z18.number().int().nonnegative(),
+    resolverVersion: z18.number().int().nonnegative()
+  }).strict(),
+  z18.object({
+    kind: z18.literal("legacy-raw"),
+    reason: z18.enum(["pre-theme-v2", "manual-runtime-fields"])
+  }).strict(),
+  z18.object({
+    kind: z18.literal("advanced-detached"),
+    reason: z18.literal("detached-custom-runtime-fields")
+  }).strict()
+]);
+var blockRuntimeStyleAuthoritySchema = z18.object({
+  unit: z18.literal("block-runtime-fields"),
+  blockId: z18.string().min(1).transform(asDesignBlockId),
+  fields: nonEmptyRuntimeStyleFieldNamesSchema,
+  authority: styleAuthoritySchema
+}).strict();
+var persistedPageDesignStateV1Schema = z18.object({
+  schemaVersion: z18.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z18.string().min(1).transform(asSiteStyleId),
+  templateId: z18.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z18.number().int().nonnegative(),
+  resolverVersion: z18.number().int().nonnegative(),
+  rhythmPresetId: z18.string().min(1),
+  blocks: z18.array(blockDesignPlanSchema),
+  styleAuthorities: z18.array(blockRuntimeStyleAuthoritySchema)
+}).strict();
+
+// ../theme-core/src/site-styles/generatedSchemas.ts
+import { z as z19 } from "zod";
+function uniqueNonEmpty2(values) {
+  const uniqueValues = [...new Set(values)];
+  const firstValue = uniqueValues[0];
+  if (!firstValue) {
+    throw new Error("Expected at least one generated schema option.");
+  }
+  return [firstValue, ...uniqueValues.slice(1)];
+}
+var generatedPanelTreatments = uniqueNonEmpty2(
+  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
+);
+var generatedFlushTreatments = uniqueNonEmpty2(
+  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
+);
+var generatedFlushBleeds = uniqueNonEmpty2(
+  generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
+);
+var generatedPanelFrameSchema = z19.object({
+  kind: z19.literal("panel"),
+  treatment: z19.enum(generatedPanelTreatments)
+}).strict();
+var generatedFlushPanelFrameSchema = z19.object({
+  kind: z19.literal("flush-panel"),
+  treatment: z19.enum(generatedFlushTreatments),
+  bleed: z19.enum(generatedFlushBleeds)
+}).strict();
+var generatedContentFrameIntentSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("plain") }).strict(),
+  generatedPanelFrameSchema,
+  generatedFlushPanelFrameSchema
+]);
+var generatedSiteStyleIdSchema = z19.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
+function generatedChoiceSchema(valueSchema) {
+  return z19.discriminatedUnion("kind", [
+    z19.object({
+      source: z19.literal("generated"),
+      kind: z19.literal("auto")
+    }).strict(),
+    z19.object({
+      source: z19.literal("generated"),
+      kind: z19.literal("explicit"),
+      value: valueSchema
+    }).strict()
+  ]);
+}
+var generatedBlockDesignIntentSchema = z19.object({
+  sectionSurface: generatedChoiceSchema(
+    z19.enum(generatedDesignOptionCatalog.sectionSurfaces)
+  ),
+  contentFrame: generatedChoiceSchema(generatedContentFrameIntentSchema),
+  itemSurface: generatedChoiceSchema(
+    z19.enum(generatedDesignOptionCatalog.itemSurfaces)
+  ),
+  transitionAfter: generatedChoiceSchema(
+    z19.enum(generatedDesignOptionCatalog.transitions)
+  ),
+  emphasis: generatedChoiceSchema(
+    z19.enum(generatedDesignOptionCatalog.emphases)
+  )
+}).strict();
+var generatedMediaCompositionIntentSchema = z19.enum([
+  "none",
+  "supporting",
+  "dominant"
+]);
+var generatedDecorativeCompositionIntentSchema = z19.enum([
+  "none",
+  "supporting"
+]);
+var generatedHeroLegibilityStrategySchema = z19.enum([
+  "none",
+  "scrim-gradient"
+]);
+var generatedBlockMediaIntentSchema = z19.object({
+  media: generatedMediaCompositionIntentSchema,
+  decorative: generatedDecorativeCompositionIntentSchema,
+  heroLegibility: generatedChoiceSchema(generatedHeroLegibilityStrategySchema)
+}).strict();
+var generatedBoundaryIntentSchema = z19.object({
+  transitionAfter: generatedChoiceSchema(
+    z19.enum(generatedDesignOptionCatalog.transitions)
+  )
+}).strict();
+var generatedPageDesignBlockIntentSchema = z19.object({
+  blockId: z19.string().min(1),
+  blockKind: z19.string().min(1),
+  purpose: z19.string().min(1),
+  design: generatedBlockDesignIntentSchema,
+  mediaIntent: generatedBlockMediaIntentSchema,
+  boundaryIntent: generatedBoundaryIntentSchema
+}).strict();
+var generatedPageDesignIntentSchema = z19.object({
+  siteStyleId: generatedSiteStyleIdSchema,
+  blocks: z19.array(generatedPageDesignBlockIntentSchema)
+}).strict();
 
-// ../theme-core/src/palette/variants/warm-neutral.ts
-var warmNeutralClay = definePaletteVariant({
-  id: "warm-neutral-clay",
-  name: "Warm Neutral \u2014 Clay",
-  description: "Terracotta primary on a cream ground.",
-  tags: { tone: "classic", energy: "calm", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#8b5e34" },
-    { name: "secondary", hex: "#7c6f64" },
-    { name: "accent", hex: "#a15c38" },
-    { name: "success", hex: "#527853" },
-    { name: "warning", hex: "#b7791f" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#fffaf3" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f5eadc" },
-    { name: "muted", hex: "#efe2d0" },
-    { name: "text", hex: "#2f241c" },
-    { name: "primaryForeground", hex: "#fffaf3" },
-    { name: "border", hex: "#d8c6b3" }
-  ]
-});
-var warmNeutralCream = definePaletteVariant({
-  id: "warm-neutral-cream",
-  name: "Warm Neutral \u2014 Cream",
-  description: "Soft sand primary with pale cream surfaces.",
-  tags: { tone: "minimal", energy: "calm", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#b08864" },
-    { name: "secondary", hex: "#9a8c7e" },
-    { name: "accent", hex: "#c2956a" },
-    { name: "success", hex: "#7d8a5f" },
-    { name: "warning", hex: "#c89a4d" },
-    { name: "destructive", hex: "#a3503e" },
-    { name: "background", hex: "#fdf8ee" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f4ebd9" },
-    { name: "muted", hex: "#ede3cf" },
-    { name: "text", hex: "#3b2f24" },
-    { name: "primaryForeground", hex: "#fdf8ee" },
-    { name: "border", hex: "#e0d2b8" }
-  ]
+// ../theme-core/src/site-styles/pageDesignIntent.ts
+import { z as z20 } from "zod";
+var pageDesignIntentSchemaVersion = 1;
+var pageDesignUserPinnedAppearanceChoiceSchema = z20.object({
+  kind: z20.literal("user-pinned"),
+  value: z20.string().min(1).transform(asAppearancePresetId)
+}).strict();
+var pageDesignUserPinnedBoundaryChoiceSchema = z20.object({
+  kind: z20.literal("user-pinned"),
+  value: z20.string().min(1).transform(asBoundaryOptionId)
+}).strict();
+var pageDesignBlockLookPinSchema = z20.object({
+  blockId: z20.string().min(1).transform(asDesignBlockId),
+  blockKind: z20.string().min(1),
+  choice: pageDesignUserPinnedAppearanceChoiceSchema
+}).strict();
+var pageDesignBoundaryPinSchema = z20.object({
+  boundaryId: z20.string().min(1).transform(asDesignBoundaryId),
+  previousBlockId: z20.string().min(1).transform(asDesignBlockId),
+  nextBlockId: z20.string().min(1).transform(asDesignBlockId),
+  choice: pageDesignUserPinnedBoundaryChoiceSchema
+}).strict().superRefine((pin, ctx) => {
+  const expectedBoundaryId = makeBoundaryId(
+    pin.previousBlockId,
+    pin.nextBlockId
+  );
+  if (pin.boundaryId !== expectedBoundaryId) {
+    ctx.addIssue({
+      code: z20.ZodIssueCode.custom,
+      path: ["boundaryId"],
+      message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
+    });
+  }
 });
-var warmNeutralForest = definePaletteVariant({
-  id: "warm-neutral-forest",
-  name: "Warm Neutral \u2014 Forest",
-  description: "Deep forest green primary with earthy neutrals.",
-  tags: { tone: "classic", energy: "calm", era: "organic" },
-  mode: "light",
-  colors: [
-    { name: "primary", hex: "#3d5840" },
-    { name: "secondary", hex: "#7a6f5d" },
-    { name: "accent", hex: "#b06b50" },
-    { name: "success", hex: "#5a7a5d" },
-    { name: "warning", hex: "#b7791f" },
-    { name: "destructive", hex: "#b91c1c" },
-    { name: "background", hex: "#fbf8f0" },
-    { name: "surface", hex: "#ffffff" },
-    { name: "surfaceAlt", hex: "#f2ecdb" },
-    { name: "muted", hex: "#ebe3cc" },
-    { name: "text", hex: "#2a2a2a" },
-    { name: "primaryForeground", hex: "#fbf8f0" },
-    { name: "border", hex: "#cdc1a4" }
-  ]
+var pageDesignIntentV1Schema = z20.object({
+  schemaVersion: z20.literal(pageDesignIntentSchemaVersion),
+  siteStyleId: z20.string().min(1).transform(asSiteStyleId),
+  pageFlowPresetId: z20.string().min(1).transform(asPageFlowPresetId),
+  blockLookPins: z20.array(pageDesignBlockLookPinSchema),
+  boundaryPins: z20.array(pageDesignBoundaryPinSchema)
+}).strict().superRefine((intent, ctx) => {
+  addDuplicateStringIssues(ctx, {
+    values: intent.blockLookPins.map((pin) => pin.blockId),
+    path: ["blockLookPins"],
+    label: "block Look pin"
+  });
+  addDuplicateStringIssues(ctx, {
+    values: intent.boundaryPins.map(
+      (pin) => boundaryKey(pin.previousBlockId, pin.nextBlockId)
+    ),
+    path: ["boundaryPins"],
+    label: "boundary pin"
+  });
 });
-
-// ../theme-core/src/palette/variants/index.ts
-var paletteVariants = [
-  // Brand-led family
-  brandLedCool,
-  brandLedWarm,
-  brandLedJewel,
-  // Warm-neutral family
-  warmNeutralClay,
-  warmNeutralCream,
-  warmNeutralForest,
-  // High-contrast family
-  highContrastInk,
-  highContrastCharcoal,
-  highContrastMonochrome,
-  // Soft-natural family
-  softNaturalSage,
-  softNaturalStone,
-  softNaturalWatercolor
-];
-var paletteVariantsById = new Map(
-  paletteVariants.map((v) => [v.id, v])
-);
+function addDuplicateStringIssues(ctx, input) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const value of input.values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+    }
+    seen.add(value);
+  }
+  for (const duplicate of duplicates) {
+    ctx.addIssue({
+      code: z20.ZodIssueCode.custom,
+      path: [...input.path],
+      message: `Duplicate ${input.label}: ${duplicate}.`
+    });
+  }
+}
+function boundaryKey(previousBlockId, nextBlockId) {
+  return makeBoundaryId(previousBlockId, nextBlockId);
+}
 
 // ../theme-core/src/site-styles/runtimeCompiler.ts
 function defineDesignRuntimeRules(rules) {
@@ -5091,7 +5149,8 @@ function ctaButton(opts) {
       },
       size: {
         $bind: {
-          from: sizePath
+          from: sizePath,
+          fallback: opts?.sizeFallback ?? "md"
         }
       },
       ...opts?.className ? { className: opts.className } : {},
@@ -8214,7 +8273,19 @@ var teamMemberFragment = defineFragment({
           bind("photo")
         )
       ]),
-      text({ as: "h3" }, bind("name")),
+      link(
+        {
+          href: { $bind: { from: "profilePath" } },
+          className: "rb-team-member-name-link"
+        },
+        [text({ as: "h3" }, bind("name"))],
+        when("profilePath")
+      ),
+      text(
+        { as: "h3" },
+        when("profilePath", { not: true }),
+        bind("name")
+      ),
       text({ as: "p", className: "rb-team-member-role" }, when("role"), bind("role")),
       richText(
         { className: "rb-prose rb-max-w-none" },
@@ -9450,14 +9521,16 @@ var headerCta = ctaButton({
   whenPath: "menu.ctaItem.label",
   variantPath: "menu.ctaItem.variant",
   linkPath: "menu.ctaItem.link",
-  className: `header-cta btn-sm ${desktopOnlyDisplay("inline-flex")} rb-ml-6`
+  sizeFallback: "sm",
+  className: `header-cta ${desktopOnlyDisplay("inline-flex")} rb-ml-6`
 });
 var mobileCta = ctaButton({
   basePath: "menu.ctaItem",
   whenPath: "menu.ctaItem.label",
   variantPath: "menu.ctaItem.variant",
   linkPath: "menu.ctaItem.link",
-  className: "nav-mobile-cta btn-md rb-w-full"
+  sizeFallback: "md",
+  className: "nav-mobile-cta rb-w-full"
 });
 var mobileToggleIcon = stack({ gap: "xs", className: "nav-mobile-icon" }, [
   {
@@ -11307,7 +11380,9 @@ var courseSessionSchema = z31.object({
 var courseTeamMemberSummarySchema = z31.object({
   id: z31.string(),
   name: z31.string(),
-  summary: z31.string().nullable()
+  roleLabel: z31.string().nullable(),
+  summary: z31.string().nullable(),
+  profilePath: z31.string().nullable()
 });
 var coursePricingOptionSchema = z31.object({
   id: z31.string(),
@@ -11412,7 +11487,9 @@ var publicEventTicketTypeSchema = z32.object({
 var publicTeamMemberSummarySchema = z32.object({
   id: z32.string(),
   name: z32.string(),
-  summary: z32.string().nullable()
+  roleLabel: z32.string().nullable(),
+  summary: z32.string().nullable(),
+  profilePath: z32.string().nullable()
 });
 var publicEventSchema = z32.object({
   kind: z32.enum(["event", "course_session"]).optional(),
@@ -17183,7 +17260,25 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
+import { z as z50 } from "zod";
 var ITEM_NAME2 = "member";
+var teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
+  message: "Team member photos must be image media"
+}).nullable();
+var teamMemberDataSchema = z50.object({
+  _type: z50.literal("teamMember"),
+  id: z50.string(),
+  name: z50.string(),
+  role: z50.string().nullable(),
+  roleLabel: z50.string().nullable(),
+  bio: z50.string().nullable(),
+  summary: z50.string().nullable(),
+  photo: teamMemberPhotoSchema,
+  profilePath: z50.string().nullable()
+});
+var teamMembersDataSchema = z50.array(teamMemberDataSchema);
+var dynamicSourceWhen = { equals: "site_staff" };
+var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
   { as: "h2" },
   bind("content.heading"),
@@ -17273,7 +17368,15 @@ var teamMemberStackLayout = el(
       ]
     ),
     stack({ gap: "sm", className: "rb-team-member-body rb-flex-1 rb-min-w-0" }, [
-      text({ as: "h3" }, bind("name")),
+      link(
+        {
+          href: { $bind: { from: "profilePath" } },
+          className: "rb-team-member-name-link"
+        },
+        [text({ as: "h3" }, bind("name"))],
+        when("profilePath")
+      ),
+      text({ as: "h3" }, when("profilePath", { not: true }), bind("name")),
       text(
         { as: "p", className: "rb-team-member-role" },
         when("role"),
@@ -17287,12 +17390,18 @@ var teamMemberStackLayout = el(
     ])
   ]
 );
-var gridMembersNode = repeaterFragmentLayout({
+var manualGridMembersNode = when("content.source", manualSourceWhen)(repeaterFragmentLayout({
   collectionPath: "content.members",
   itemName: ITEM_NAME2,
   fragments: { teamMember: teamMemberFragment },
   itemGap: "sm"
-});
+}));
+var dynamicGridMembersNode = when("content.source", dynamicSourceWhen)(repeaterFragmentLayout({
+  collectionPath: "data.members",
+  itemName: ITEM_NAME2,
+  fragments: { teamMember: teamMemberFragment },
+  itemGap: "sm"
+}));
 var gridVariant = wrapVariant3(
   el(
     "grid",
@@ -17306,22 +17415,29 @@ var gridVariant = wrapVariant3(
       },
       gap: { $bind: { from: "content.gap", fallback: "medium" } }
     },
-    [gridMembersNode]
+    [manualGridMembersNode, dynamicGridMembersNode]
   )
 );
-var stackMembersNode = repeaterFragmentLayout({
+var manualStackMembersNode = when("content.source", manualSourceWhen)(repeaterFragmentLayout({
   collectionPath: "content.members",
   itemName: ITEM_NAME2,
   fragments: { teamMember: teamMemberFragment },
   layoutOverrides: { teamMember: teamMemberStackLayout },
   itemGap: "sm"
-});
+}));
+var dynamicStackMembersNode = when("content.source", dynamicSourceWhen)(repeaterFragmentLayout({
+  collectionPath: "data.members",
+  itemName: ITEM_NAME2,
+  fragments: { teamMember: teamMemberFragment },
+  layoutOverrides: { teamMember: teamMemberStackLayout },
+  itemGap: "sm"
+}));
 var stackVariant = wrapVariant3({
   type: "stack",
   props: {
     gap: { $bind: { from: "content.gap", fallback: "medium" } }
   },
-  children: [stackMembersNode]
+  children: [manualStackMembersNode, dynamicStackMembersNode]
 });
 var teamMembersManifest = createBlockManifest({
   id: "block.team-members",
@@ -17336,6 +17452,18 @@ var teamMembersManifest = createBlockManifest({
       required: false,
       maxLength: 120
     }),
+    parseFieldDefinition({
+      id: "source",
+      type: "select",
+      label: "Team members",
+      description: "Choose whether to use the site-wide team or a hand-picked list.",
+      defaultValue: "manual",
+      options: [
+        { value: "manual", label: "Choose manually" },
+        { value: "site_staff", label: "Use all site team members" }
+      ],
+      ui: { intent: "behavior" }
+    }),
     parseFieldDefinition({
       id: "layoutAlign",
       type: "select",
@@ -17438,18 +17566,24 @@ var teamMembersManifest = createBlockManifest({
       ],
       ui: { intent: "display" }
     }),
-    fragmentsToRepeaterField(
-      "members",
-      "Team members",
-      { teamMember: teamMemberFragment },
-      {
-        minItems: 0,
-        maxItems: 50,
-        itemLabel: "Team member",
-        itemLabelSource: "name",
-        description: "Add people to this section."
+    {
+      ...fragmentsToRepeaterField(
+        "members",
+        "Team members",
+        { teamMember: teamMemberFragment },
+        {
+          minItems: 0,
+          maxItems: 50,
+          itemLabel: "Team member",
+          itemLabelSource: "name",
+          description: "Add people to this section."
+        }
+      ),
+      ui: {
+        intent: "content",
+        visibleWhen: { field: "source", equals: "manual" }
       }
-    )
+    }
   ],
   layout: gridVariant,
   variants: {
@@ -17475,7 +17609,20 @@ var teamMembersManifest = createBlockManifest({
   styleTokens: { spacing: "lg" }
 });
 var teamMembersBlockDefinition = {
-  manifest: teamMembersManifest
+  manifest: teamMembersManifest,
+  dataSchemas: {
+    members: teamMembersDataSchema
+  },
+  dataLoaders: {
+    members: {
+      endpoint: "listPublicTeamMembers",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
 };
 
 // ../blocks/src/system/runtime/nodes/location-map.shared.ts
@@ -18453,11 +18600,11 @@ function resolveModelForPass(passId, tierOverrides, passOverrides, globalModel)
 }
 
 // src/page-converter/passes/pass1-segmentation-matching.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // src/manifest/passes/pass1-fields.ts
-import { z as z50 } from "zod";
-var simpleFieldTypeEnum = z50.enum([
+import { z as z51 } from "zod";
+var simpleFieldTypeEnum = z51.enum([
   "text",
   "richText",
   "media",
@@ -18466,7 +18613,7 @@ var simpleFieldTypeEnum = z50.enum([
   "select",
   "number"
 ]);
-var fieldTypeEnum = z50.enum([
+var fieldTypeEnum = z51.enum([
   "text",
   "richText",
   "media",
@@ -18477,109 +18624,109 @@ var fieldTypeEnum = z50.enum([
   "repeater",
   "group"
 ]);
-var linkDefaultValue = z50.object({
-  label: z50.string().describe("The visible link text")
+var linkDefaultValue = z51.object({
+  label: z51.string().describe("The visible link text")
 });
-var mediaDefaultValue = z50.object({
-  src: z50.string().describe("Image/video source URL"),
-  alt: z50.string().describe("Alt text for accessibility (empty string if none)")
+var mediaDefaultValue = z51.object({
+  src: z51.string().describe("Image/video source URL"),
+  alt: z51.string().describe("Alt text for accessibility (empty string if none)")
 });
-var nestedFieldSchema = z50.object({
-  id: z50.string().min(1).describe("camelCase field ID"),
+var nestedFieldSchema = z51.object({
+  id: z51.string().min(1).describe("camelCase field ID"),
   type: simpleFieldTypeEnum,
-  label: z50.string().min(1),
-  required: z50.boolean().nullable()
+  label: z51.string().min(1),
+  required: z51.boolean().nullable()
 });
-var simpleFieldSchema = z50.object({
-  id: z50.string().min(1).describe("camelCase field ID (e.g., headline, ctaButton)"),
+var simpleFieldSchema = z51.object({
+  id: z51.string().min(1).describe("camelCase field ID (e.g., headline, ctaButton)"),
   type: simpleFieldTypeEnum,
-  label: z50.string().min(1),
-  required: z50.boolean(),
-  multiline: z50.boolean().nullable().describe("For text fields: true if multiple lines"),
-  defaultValue: z50.union([
-    z50.string(),
-    z50.number(),
-    z50.boolean(),
+  label: z51.string().min(1),
+  required: z51.boolean(),
+  multiline: z51.boolean().nullable().describe("For text fields: true if multiple lines"),
+  defaultValue: z51.union([
+    z51.string(),
+    z51.number(),
+    z51.boolean(),
     linkDefaultValue,
     mediaDefaultValue,
-    z50.null()
+    z51.null()
   ]).describe("Default content extracted from HTML"),
-  htmlContext: z50.string().describe("Brief description of where this appears in the HTML")
-});
-var repeaterFieldSchema2 = z50.object({
-  id: z50.string().min(1).describe("camelCase field ID (e.g., socialLinks, features)"),
-  type: z50.literal("repeater"),
-  label: z50.string().min(1),
-  required: z50.boolean(),
-  itemLabel: z50.string().min(1).describe('Singular label for each item (e.g., "Link", "Feature")'),
-  itemFields: z50.array(nestedFieldSchema).min(1).describe("Fields for each item in the repeater"),
-  htmlContext: z50.string().describe("Brief description of where this appears in the HTML")
-});
-var groupFieldSchema2 = z50.object({
-  id: z50.string().min(1).describe("camelCase field ID (e.g., contactInfo, seoSettings)"),
-  type: z50.literal("group"),
-  label: z50.string().min(1),
-  required: z50.boolean(),
-  groupFields: z50.array(nestedFieldSchema).min(1).describe("Fields within the group"),
-  htmlContext: z50.string().describe("Brief description of where this appears in the HTML")
-});
-var extractedFieldSchema = z50.union([
+  htmlContext: z51.string().describe("Brief description of where this appears in the HTML")
+});
+var repeaterFieldSchema2 = z51.object({
+  id: z51.string().min(1).describe("camelCase field ID (e.g., socialLinks, features)"),
+  type: z51.literal("repeater"),
+  label: z51.string().min(1),
+  required: z51.boolean(),
+  itemLabel: z51.string().min(1).describe('Singular label for each item (e.g., "Link", "Feature")'),
+  itemFields: z51.array(nestedFieldSchema).min(1).describe("Fields for each item in the repeater"),
+  htmlContext: z51.string().describe("Brief description of where this appears in the HTML")
+});
+var groupFieldSchema2 = z51.object({
+  id: z51.string().min(1).describe("camelCase field ID (e.g., contactInfo, seoSettings)"),
+  type: z51.literal("group"),
+  label: z51.string().min(1),
+  required: z51.boolean(),
+  groupFields: z51.array(nestedFieldSchema).min(1).describe("Fields within the group"),
+  htmlContext: z51.string().describe("Brief description of where this appears in the HTML")
+});
+var extractedFieldSchema = z51.union([
   simpleFieldSchema,
   repeaterFieldSchema2,
   groupFieldSchema2
 ]);
-var extractedEntrySchema = z50.object({
-  identifier: z50.string().regex(/^[a-z0-9-]+$/).describe("Unique slug-safe identifier (e.g., wine-tasting-evening)"),
-  title: z50.string().min(1).describe("Entry title"),
+var extractedEntrySchema = z51.object({
+  identifier: z51.string().regex(/^[a-z0-9-]+$/).describe("Unique slug-safe identifier (e.g., wine-tasting-evening)"),
+  title: z51.string().min(1).describe("Entry title"),
   // Use passthrough() instead of record() - generates additionalProperties:true without propertyNames
   // which OpenAI's structured output accepts
-  data: z50.object({}).passthrough().describe("Entry data matching the content type schema")
-});
-var newContentTypeSchema = z50.object({
-  key: z50.string().regex(/^[a-z][a-z0-9-]*$/).describe("Content type key (e.g., testimonial, team-member)"),
-  name: z50.string().min(1).describe("Human-readable name"),
-  description: z50.string().nullable().describe("Description of this content type"),
-  fields: z50.array(z50.object({
-    id: z50.string().min(1),
-    type: z50.string().min(1),
-    label: z50.string().min(1),
-    required: z50.boolean().nullable(),
-    description: z50.string().nullable()
+  data: z51.object({}).passthrough().describe("Entry data matching the content type schema")
+});
+var newContentTypeSchema = z51.object({
+  key: z51.string().regex(/^[a-z][a-z0-9-]*$/).describe("Content type key (e.g., testimonial, team-member)"),
+  name: z51.string().min(1).describe("Human-readable name"),
+  description: z51.string().nullable().describe("Description of this content type"),
+  fields: z51.array(z51.object({
+    id: z51.string().min(1),
+    type: z51.string().min(1),
+    label: z51.string().min(1),
+    required: z51.boolean().nullable(),
+    description: z51.string().nullable()
   })).min(1),
-  isRouted: z50.boolean().describe("Whether entries have their own pages")
+  isRouted: z51.boolean().describe("Whether entries have their own pages")
 });
-var contentTypeApproachSchema = z50.discriminatedUnion("approach", [
+var contentTypeApproachSchema = z51.discriminatedUnion("approach", [
   // Use an existing content type
-  z50.object({
-    approach: z50.literal("existingContentType"),
-    contentTypeKey: z50.string().min(1).describe("Key of the existing content type to use"),
-    entries: z50.array(extractedEntrySchema).min(1).describe("Extracted entries"),
-    rationale: z50.string().describe("Why this content type fits")
+  z51.object({
+    approach: z51.literal("existingContentType"),
+    contentTypeKey: z51.string().min(1).describe("Key of the existing content type to use"),
+    entries: z51.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z51.string().describe("Why this content type fits")
   }),
   // Create a new content type
-  z50.object({
-    approach: z50.literal("newContentType"),
+  z51.object({
+    approach: z51.literal("newContentType"),
     contentType: newContentTypeSchema,
-    entries: z50.array(extractedEntrySchema).min(1).describe("Extracted entries"),
-    rationale: z50.string().describe("Why a new content type is needed")
+    entries: z51.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z51.string().describe("Why a new content type is needed")
   }),
   // Use repeater field (page-specific data)
-  z50.object({
-    approach: z50.literal("repeater"),
-    rationale: z50.string().describe("Why repeater is preferred over content type")
+  z51.object({
+    approach: z51.literal("repeater"),
+    rationale: z51.string().describe("Why repeater is preferred over content type")
   }),
   // No list data - standard field extraction
-  z50.object({
-    approach: z50.literal("none"),
-    rationale: z50.string().describe("Why this is not list data")
+  z51.object({
+    approach: z51.literal("none"),
+    rationale: z51.string().describe("Why this is not list data")
   })
 ]);
-var pass1OutputSchema = z50.object({
-  blockId: z50.string().regex(/^custom\.[a-z][a-z0-9-]*$/).describe("Block ID like custom.hero-section"),
-  blockTitle: z50.string().min(1),
-  blockDescription: z50.string().nullable(),
-  category: z50.enum(["marketing", "content", "blog", "media", "layout", "interactive"]),
-  fields: z50.array(extractedFieldSchema).min(1),
+var pass1OutputSchema = z51.object({
+  blockId: z51.string().regex(/^custom\.[a-z][a-z0-9-]*$/).describe("Block ID like custom.hero-section"),
+  blockTitle: z51.string().min(1),
+  blockDescription: z51.string().nullable(),
+  category: z51.enum(["marketing", "content", "blog", "media", "layout", "interactive"]),
+  fields: z51.array(extractedFieldSchema).min(1),
   /**
    * Content type decision for list-like content.
    * When content types are available, the LLM may decide to use content entries
@@ -18821,10 +18968,10 @@ async function getJsonFromAiText(ai, config, userMessage, schema) {
 }
 
 // src/manifest/passes/pass3-styling.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 
 // src/manifest/validation/output-schema.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // src/manifest/validation/layout-utils.ts
 function collectLayoutNodeInfos(node, path2 = "layout", out = []) {
@@ -18865,53 +19012,53 @@ function collectLayoutClassNames(node, out = /* @__PURE__ */ new Set()) {
 }
 
 // src/zod/titleSourceSchema.ts
-import { z as z51 } from "zod";
-var titleSourceValueSchema = z51.union([
-  z51.string().min(1),
-  z51.array(z51.string().min(1)).min(1)
+import { z as z52 } from "zod";
+var titleSourceValueSchema = z52.union([
+  z52.string().min(1),
+  z52.array(z52.string().min(1)).min(1)
 ]);
 
 // src/manifest/validation/output-schema.ts
-var blockCategoryEnum2 = z52.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
-var llmColorValue = z52.object({
-  name: z52.string(),
-  hex: z52.string()
-});
-var llmThemePrimitive = z52.union([
-  z52.string(),
-  z52.number(),
-  z52.boolean(),
-  z52.null()
+var blockCategoryEnum2 = z53.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+var llmColorValue = z53.object({
+  name: z53.string(),
+  hex: z53.string()
+});
+var llmThemePrimitive = z53.union([
+  z53.string(),
+  z53.number(),
+  z53.boolean(),
+  z53.null()
 ]);
-var llmThemePatchValue = z52.union([
+var llmThemePatchValue = z53.union([
   llmThemePrimitive,
   llmColorValue,
-  z52.array(llmColorValue),
-  z52.array(llmThemePrimitive)
+  z53.array(llmColorValue),
+  z53.array(llmThemePrimitive)
 ]);
-var llmThemePatchOpSchema = z52.discriminatedUnion("op", [
-  z52.object({ op: z52.literal("add"), path: z52.string().min(1), value: llmThemePatchValue }),
-  z52.object({ op: z52.literal("replace"), path: z52.string().min(1), value: llmThemePatchValue }),
-  z52.object({ op: z52.literal("remove"), path: z52.string().min(1) })
+var llmThemePatchOpSchema = z53.discriminatedUnion("op", [
+  z53.object({ op: z53.literal("add"), path: z53.string().min(1), value: llmThemePatchValue }),
+  z53.object({ op: z53.literal("replace"), path: z53.string().min(1), value: llmThemePatchValue }),
+  z53.object({ op: z53.literal("remove"), path: z53.string().min(1) })
 ]);
-var llmCssDeclaration = z52.object({
-  property: z52.string(),
-  value: z52.string()
+var llmCssDeclaration = z53.object({
+  property: z53.string(),
+  value: z53.string()
 });
-var llmCustomCssRuleSchema = z52.object({
-  id: z52.string().min(1),
-  selector: z52.string().min(1),
-  declarations: z52.array(llmCssDeclaration)
+var llmCustomCssRuleSchema = z53.object({
+  id: z53.string().min(1),
+  selector: z53.string().min(1),
+  declarations: z53.array(llmCssDeclaration)
 });
-var llmNestedRuleSchema = z52.object({
-  selector: z52.string().min(1),
-  declarations: z52.array(llmCssDeclaration)
+var llmNestedRuleSchema = z53.object({
+  selector: z53.string().min(1),
+  declarations: z53.array(llmCssDeclaration)
 });
-var llmMediaAtRuleSchema = z52.object({
-  id: z52.string().min(1),
-  type: z52.literal("media"),
-  query: z52.string().min(1),
-  rules: z52.array(llmNestedRuleSchema)
+var llmMediaAtRuleSchema = z53.object({
+  id: z53.string().min(1),
+  type: z53.literal("media"),
+  query: z53.string().min(1),
+  rules: z53.array(llmNestedRuleSchema)
 });
 function normalizeDeclarationsArrayToRecord(declarations) {
   const record = {};
@@ -18941,79 +19088,79 @@ function normalizeLlmMediaAtRule(atRule) {
     rules: atRule.rules.map(normalizeLlmNestedRule)
   };
 }
-var jsonPrimitiveSchema = z52.union([
-  z52.string(),
-  z52.number(),
-  z52.boolean(),
-  z52.null()
+var jsonPrimitiveSchema = z53.union([
+  z53.string(),
+  z53.number(),
+  z53.boolean(),
+  z53.null()
 ]);
-var jsonValueSchema = z52.union([
+var jsonValueSchema = z53.union([
   jsonPrimitiveSchema,
-  z52.array(jsonPrimitiveSchema)
+  z53.array(jsonPrimitiveSchema)
 ]);
-var llmBaseFieldSchema = z52.object({
-  id: z52.string().min(1),
-  label: z52.string().min(1),
-  description: z52.string().nullable(),
-  required: z52.boolean(),
+var llmBaseFieldSchema = z53.object({
+  id: z53.string().min(1),
+  label: z53.string().min(1),
+  description: z53.string().nullable(),
+  required: z53.boolean(),
   defaultValue: jsonValueSchema.nullable()
 });
 var llmTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("text"),
-  multiline: z52.boolean(),
-  maxLength: z52.number().int().positive().nullable()
+  type: z53.literal("text"),
+  multiline: z53.boolean(),
+  maxLength: z53.number().int().positive().nullable()
 });
 var llmRichTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("richText")
+  type: z53.literal("richText")
 });
 var llmMediaFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("media"),
-  mediaKinds: z52.array(z52.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])).nullable()
+  type: z53.literal("media"),
+  mediaKinds: z53.array(z53.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])).nullable()
 });
 var llmBooleanFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("boolean")
+  type: z53.literal("boolean")
 });
 var llmLinkFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("link")
+  type: z53.literal("link")
 });
 var llmSelectFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("select"),
-  options: z52.array(z52.object({
-    value: z52.string(),
-    label: z52.string()
+  type: z53.literal("select"),
+  options: z53.array(z53.object({
+    value: z53.string(),
+    label: z53.string()
   })),
-  multiple: z52.boolean().nullable()
+  multiple: z53.boolean().nullable()
 });
 var llmNumberFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("number")
-});
-var llmNestedFieldSchema = z52.object({
-  id: z52.string(),
-  type: z52.string(),
-  label: z52.string(),
-  required: z52.boolean().nullable(),
-  multiline: z52.boolean().nullable(),
+  type: z53.literal("number")
+});
+var llmNestedFieldSchema = z53.object({
+  id: z53.string(),
+  type: z53.string(),
+  label: z53.string(),
+  required: z53.boolean().nullable(),
+  multiline: z53.boolean().nullable(),
   defaultValue: jsonValueSchema.nullable()
 }).passthrough();
-var llmNestedFieldsSchema = z52.array(llmNestedFieldSchema);
+var llmNestedFieldsSchema = z53.array(llmNestedFieldSchema);
 var llmGroupFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("group"),
-  schema: z52.object({
+  type: z53.literal("group"),
+  schema: z53.object({
     fields: llmNestedFieldsSchema
   })
 });
 var llmRepeaterFieldSchema = llmBaseFieldSchema.extend({
-  type: z52.literal("repeater"),
-  itemLabel: z52.string(),
-  itemLabelSource: z52.string().nullable(),
-  minItems: z52.number().int().min(0),
-  maxItems: z52.number().int().positive().nullable(),
-  allowConversion: z52.boolean(),
-  schema: z52.object({
+  type: z53.literal("repeater"),
+  itemLabel: z53.string(),
+  itemLabelSource: z53.string().nullable(),
+  minItems: z53.number().int().min(0),
+  maxItems: z53.number().int().positive().nullable(),
+  allowConversion: z53.boolean(),
+  schema: z53.object({
     fields: llmNestedFieldsSchema
   })
 });
-var llmFieldSchema = z52.union([
+var llmFieldSchema = z53.union([
   llmTextFieldSchema,
   llmRichTextFieldSchema,
   llmMediaFieldSchema,
@@ -19024,64 +19171,64 @@ var llmFieldSchema = z52.union([
   llmGroupFieldSchema,
   llmRepeaterFieldSchema
 ]);
-var llmBindingSchema = z52.object({
-  from: z52.string(),
-  fallback: z52.string().nullable(),
-  transforms: z52.array(z52.object({
-    id: z52.string()
+var llmBindingSchema = z53.object({
+  from: z53.string(),
+  fallback: z53.string().nullable(),
+  transforms: z53.array(z53.object({
+    id: z53.string()
   })).nullable()
 });
-var llmRepeatSchema = z52.object({
-  collection: z52.object({ from: z52.string() }),
-  itemName: z52.string()
+var llmRepeatSchema = z53.object({
+  collection: z53.object({ from: z53.string() }),
+  itemName: z53.string()
 });
-var llmPropsSchema = z52.object({}).passthrough().nullable();
+var llmPropsSchema = z53.object({}).passthrough().nullable();
 function buildLlmNodeSchema(maxDepth) {
-  const nodeBase = z52.object({
-    type: z52.string(),
+  const nodeBase = z53.object({
+    type: z53.string(),
     props: llmPropsSchema,
     $bind: llmBindingSchema.nullable(),
     $repeat: llmRepeatSchema.nullable(),
-    $when: z52.object({
-      condition: z52.object({ from: z52.string() })
+    $when: z53.object({
+      condition: z53.object({ from: z53.string() })
     }).nullable()
   });
-  let schema = nodeBase.extend({ children: z52.null() });
+  let schema = nodeBase.extend({ children: z53.null() });
   for (let i = 0; i < maxDepth; i++) {
-    schema = nodeBase.extend({ children: z52.array(schema).nullable() });
+    schema = nodeBase.extend({ children: z53.array(schema).nullable() });
   }
   return schema;
 }
 var MAX_LAYOUT_DEPTH = 6;
 var llmNodeSchema = buildLlmNodeSchema(MAX_LAYOUT_DEPTH);
-var llmCustomBlockSchema = z52.object({
-  id: z52.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var llmCustomBlockSchema = z53.object({
+  id: z53.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
     message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
   }),
-  title: z52.string().min(1, "Title is required"),
+  title: z53.string().min(1, "Title is required"),
   // Keep in sync with `sdkCustomBlockSchema` and the system manifest schema:
   // - `null` used by OpenAI structured output for "optional" values
   // - array allows multi-part titles (e.g. ["navLabel", "title"])
   titleSource: titleSourceValueSchema.nullable(),
-  description: z52.string().nullable(),
+  description: z53.string().nullable(),
   category: blockCategoryEnum2,
-  icon: z52.string().nullable(),
-  tags: z52.array(z52.string()).nullable(),
+  icon: z53.string().nullable(),
+  tags: z53.array(z53.string()).nullable(),
   // Use LLM-specific field schema (no z.any() for OpenAI compatibility)
   fields: llmFieldSchema.array().min(1, "Custom blocks must have at least one field"),
   // Use LLM-specific node schema (no z.any() for OpenAI compatibility)
   layout: llmNodeSchema
 });
-var htmlToManifestOutputSchema = z52.object({
-  blocks: z52.array(llmCustomBlockSchema).min(1, "At least one block is required").max(10, "Maximum 10 blocks per conversion"),
-  themePatch: z52.array(llmThemePatchOpSchema).nullable(),
-  customCssRules: z52.array(llmCustomCssRuleSchema).nullable(),
-  customCssAtRules: z52.array(llmMediaAtRuleSchema).nullable(),
+var htmlToManifestOutputSchema = z53.object({
+  blocks: z53.array(llmCustomBlockSchema).min(1, "At least one block is required").max(10, "Maximum 10 blocks per conversion"),
+  themePatch: z53.array(llmThemePatchOpSchema).nullable(),
+  customCssRules: z53.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z53.array(llmMediaAtRuleSchema).nullable(),
   /**
    * Explanation of fixes made when retrying after validation errors.
    * Should explain what changes were made and why.
    */
-  fixRationale: z52.string().nullable()
+  fixRationale: z53.string().nullable()
 });
 function collectValidationErrors(output) {
   const errors = [];
@@ -19916,20 +20063,20 @@ function formatValidationFeedback(errors, output) {
 }
 
 // src/manifest/passes/pass3-styling.ts
-var pass3aOutputSchema = z53.object({
-  classNamePatches: z53.array(
-    z53.object({
-      nodePath: z53.string(),
+var pass3aOutputSchema = z54.object({
+  classNamePatches: z54.array(
+    z54.object({
+      nodePath: z54.string(),
       // "" for root, "children[0]", "children[0].children[1]" etc.
-      className: z53.string().min(1)
+      className: z54.string().min(1)
     })
   ),
-  rationale: z53.string()
+  rationale: z54.string()
 });
-var pass3bOutputSchema = z53.object({
-  customCssRules: z53.array(llmCustomCssRuleSchema).nullable(),
-  customCssAtRules: z53.array(llmMediaAtRuleSchema).nullable(),
-  rationale: z53.string()
+var pass3bOutputSchema = z54.object({
+  customCssRules: z54.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z54.array(llmMediaAtRuleSchema).nullable(),
+  rationale: z54.string()
 });
 function getNodeAtPath(layout, path2) {
   if (path2 === "" || path2 === "root" || path2 === "layout") {
@@ -20236,38 +20383,38 @@ Do NOT include [data-block=...] in selectors - we add that automatically.
 
 // src/page-converter/passes/pass1-segmentation-matching.ts
 var SIZE_WARNING_BYTES = 100 * 1024;
-var sectionTypeEnum = z54.enum(["header", "content", "footer"]);
-var blockCategoryEnum3 = z54.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
-var baseSectionSchema = z54.object({
-  html: z54.string().min(1),
-  purpose: z54.string().min(1),
+var sectionTypeEnum = z55.enum(["header", "content", "footer"]);
+var blockCategoryEnum3 = z55.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+var baseSectionSchema = z55.object({
+  html: z55.string().min(1),
+  purpose: z55.string().min(1),
   sectionType: sectionTypeEnum
 });
 var builtinMatchSchema = baseSectionSchema.extend({
-  decision: z54.literal("builtin"),
-  matchedBlock: z54.string().min(1),
-  matchScore: z54.number().min(0).max(100),
-  matchRationale: z54.string().min(1)
+  decision: z55.literal("builtin"),
+  matchedBlock: z55.string().min(1),
+  matchScore: z55.number().min(0).max(100),
+  matchRationale: z55.string().min(1)
 });
 var customMatchSchema = baseSectionSchema.extend({
-  decision: z54.literal("custom"),
-  customBlockSuggestion: z54.object({
-    title: z54.string().min(1),
+  decision: z55.literal("custom"),
+  customBlockSuggestion: z55.object({
+    title: z55.string().min(1),
     category: blockCategoryEnum3
   })
 });
-var sectionMatchSchema = z54.discriminatedUnion("decision", [
+var sectionMatchSchema = z55.discriminatedUnion("decision", [
   builtinMatchSchema,
   customMatchSchema
 ]);
-var skippedContentSchema = z54.object({
-  description: z54.string(),
-  reason: z54.string()
+var skippedContentSchema = z55.object({
+  description: z55.string(),
+  reason: z55.string()
 });
-var combinedPassSchema = z54.object({
-  sections: z54.array(sectionMatchSchema).min(1),
-  skippedContent: z54.array(skippedContentSchema).nullable(),
-  rationale: z54.string()
+var combinedPassSchema = z55.object({
+  sections: z55.array(sectionMatchSchema).min(1),
+  skippedContent: z55.array(skippedContentSchema).nullable(),
+  rationale: z55.string()
 });
 function buildSystemPrompt(availableBlocks, matchThreshold) {
   const blockCatalog = availableBlocks.map((b) => {
@@ -20474,10 +20621,10 @@ async function segmentAndMatchBlocks(html, availableBlocks, ctx) {
 }
 
 // src/page-converter/passes/pass2-population.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // src/manifest/three-pass-converter.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 
 // src/manifest/prompt/theme-summary.ts
 var WEIGHT_MAP = {
@@ -20813,9 +20960,9 @@ function mapPass1FieldToOutputField(field) {
     maxLength: null
   };
 }
-var pass2OutputSchema = z55.object({
+var pass2OutputSchema = z56.object({
   layout: llmNodeSchema,
-  rationale: z55.string().describe("Explain which node binds to which field")
+  rationale: z56.string().describe("Explain which node binds to which field")
 });
 function buildPass2SystemPrompt(fields3, contentTypeApproach) {
   const fieldList = fields3.map((f) => {
@@ -21675,9 +21822,9 @@ async function convertHtmlToManifest(input, options) {
 }
 
 // src/page-converter/passes/pass2-population.ts
-var builtinContentSchema = z56.object({
-  content: z56.any(),
-  rationale: z56.string()
+var builtinContentSchema = z57.object({
+  content: z57.any(),
+  rationale: z57.string()
 });
 var SECTION_STYLES_ALLOWED_KEYS = /* @__PURE__ */ new Set(["background", "spacing"]);
 var BOX_STYLES_ALLOWED_KEYS = /* @__PURE__ */ new Set(["background", "spacing", "raised", "rounded", "border", "fullWidth"]);