@riverbankcms/sdk 0.77.1 → 0.78.2

package/dist/client/bookings.mjs

@@ -86,7 +86,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z12(e) {
+function z18(e) {
   if (L) {
     if (/* @__PURE__ */ Te(P) !== null)
       throw Tt(), Je;
@@ -2115,12 +2115,12 @@ function ha(e, t) {
   var mt = we(Dr, 2);
   let Pr;
   var We = X(mt);
-  en(We), We.__change = ui, z12(mt);
+  en(We), We.__change = ui, z18(mt);
   var Ut = we(mt, 2), wi = X(Ut);
   {
     var pi = (n) => {
       var u = na(), _ = Gr(u), y = X(_);
-      Ge(y, () => c(re).verified), z12(_);
+      Ge(y, () => c(re).verified), z18(_);
       var T = we(_, 2);
       en(T), Pe(() => {
         se(T, "name", V()), jo(T, c(Le));
@@ -2129,10 +2129,10 @@ function ha(e, t) {
       {
         var _ = (T) => {
           var E = ia(), p = X(E);
-          Ge(p, () => c(re).verifying), z12(E), ne(T, E);
+          Ge(p, () => c(re).verifying), z18(E), ne(T, E);
         }, y = (T) => {
           var E = oa(), p = X(E);
-          Ge(p, () => c(re).label), z12(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
+          Ge(p, () => c(re).label), z18(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
         };
         $e(
           n,
@@ -2147,18 +2147,18 @@ function ha(e, t) {
       c(C) === b.VERIFIED ? n(pi) : n(bi, false);
     });
   }
-  z12(Ut);
+  z18(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n) => {
       var u = aa(), _ = X(u);
-      se(_, "href", sr), z12(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
+      se(_, "href", sr), z18(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
     };
     $e(yi, (n) => {
       (N() !== true || c(Dt)) && n(Ei);
     });
   }
-  z12(Mt);
+  z18(Mt);
   var Or = we(Mt, 2);
   {
     var xi = (n) => {
@@ -2166,16 +2166,16 @@ function ha(e, t) {
       {
         var y = (E) => {
           var p = la(), x = X(p);
-          Ge(x, () => c(re).expired), z12(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).expired), z18(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         }, T = (E) => {
           var p = sa(), x = X(p);
-          Ge(x, () => c(re).error), z12(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).error), z18(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         };
         $e(_, (E) => {
           c(C) === b.EXPIRED ? E(y) : E(T, false);
         });
       }
-      z12(u), ne(n, u);
+      z18(u), ne(n, u);
     };
     $e(Or, (n) => {
       (c(He) || c(C) === b.EXPIRED) && n(xi);
@@ -2185,7 +2185,7 @@ function ha(e, t) {
   {
     var $i = (n) => {
       var u = ua(), _ = X(u), y = X(_);
-      Ge(y, () => c(re).footer), z12(_), z12(u), ne(n, u);
+      Ge(y, () => c(re).footer), z18(_), z18(u), ne(n, u);
     };
     $e(Fr, (n) => {
       c(re).footer && (k() !== true || c(Dt)) && n($i);
@@ -2201,7 +2201,7 @@ function ha(e, t) {
       v() && n(Ci);
     });
   }
-  return z12(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
+  return z18(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
     (n) => {
       se(ot, "data-state", c(C)), se(ot, "data-floating", v()), Pr = Fo(mt, 1, "altcha-checkbox", null, Pr, n), se(We, "id", c(cr)), We.required = r2() !== "onsubmit" && (!v() || r2() !== "off");
     },
@@ -2990,6 +2990,10 @@ var DISCOUNTS = {
   available: {
     path: "/public/sites/{siteId}/bookings/discounts/available",
     method: "POST"
+  },
+  apply: {
+    path: "/public/sites/{siteId}/bookings/discounts/apply",
+    method: "POST"
   }
 };
 var NEWSLETTER = {
@@ -3601,6 +3605,14 @@ function createBlockApi(config) {
         body: { context: data.context, subtotalCents: data.subtotalCents }
       });
     },
+    async applyDiscountCode(data) {
+      const sid = requireSiteId();
+      const path = buildPath(DISCOUNTS.apply.path, { siteId: sid });
+      return request(DISCOUNTS.apply, {
+        path,
+        body: data
+      });
+    },
     // Shop
     async getPublicProducts(params) {
       const sid = requireSiteId();
@@ -5003,12 +5015,12 @@ var personalitiesById = new Map(
 );
 
 // ../core/src/branded.ts
-var asSiteId = (id) => id;
-var asFormId = (id) => id;
-var asPassId = (id) => id;
-var asCustomerPassId = (id) => id;
-var asAppointmentServiceId = (id) => id;
-var asAppointmentResourceId = (id) => id;
+var unsafeAsSiteId = (id) => id;
+var unsafeAsFormId = (id) => id;
+var unsafeAsPassId = (id) => id;
+var unsafeAsCustomerPassId = (id) => id;
+var unsafeAsAppointmentServiceId = (id) => id;
+var unsafeAsAppointmentResourceId = (id) => id;
 
 // ../core/src/date-math.ts
 function addDaysToDate(date, dayCount) {
@@ -5256,7 +5268,8 @@ var accordionSystemSchema = z5.object({
   icon: z5.object({
     style: accordionIconSchema,
     position: z5.enum(["left", "right"]),
-    size: z5.enum(["sm", "md", "lg"])
+    size: z5.enum(["sm", "md", "lg"]),
+    colorToken: themeColorTokenSchema.optional()
   }),
   // Trigger (question) styling
   trigger: z5.object({
@@ -5276,10 +5289,108 @@ var accordionSystemSchema = z5.object({
   })
 });
 
+// ../theme-core/src/site-styles/types.ts
+function asAppearancePresetId(value) {
+  return brandNonEmptyString(value, "AppearancePresetId");
+}
+function asSiteStyleId(value) {
+  const siteStyleId = brandNonEmptyString(value, "SiteStyleId");
+  if (!siteStyleId.startsWith("site-style:")) {
+    throw new Error(
+      `SiteStyleId must start with "site-style:". Received: ${value}`
+    );
+  }
+  return siteStyleId;
+}
+function asDesignSystemTemplateId(value) {
+  return brandNonEmptyString(value, "DesignSystemTemplateId");
+}
+function assertNever3(value, message = "Unhandled Theme V2 variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
+function brandNonEmptyString(value, label) {
+  if (value.length === 0) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+var plainFrame = {
+  kind: "plain"
+};
+function panelFrame(treatment) {
+  return { kind: "panel", treatment };
+}
+function flushPanelFrame(options) {
+  return {
+    kind: "flush-panel",
+    treatment: options.treatment ?? "media-panel",
+    bleed: options.bleed
+  };
+}
+var tileTreatmentValues = [
+  "default",
+  "quiet",
+  "brand-depth"
+];
+var eventListTreatmentValues = [
+  "plain",
+  "lined-panel"
+];
+var eyebrowTreatmentValues = [
+  "plain",
+  "pill",
+  "accent-pill",
+  "pill-bounce",
+  "accent-pill-bounce"
+];
+var visibleHeadingDecorationFamilyValues = [
+  "organic-squiggle",
+  "short-center-rule"
+];
+var visibleHeadingDecorationPlacementValues = [
+  "after-heading",
+  "between-heading-and-body",
+  "under-centered-heading"
+];
+var headingDecorationOverrideValues = [
+  "site-default",
+  "on",
+  "off"
+];
+var headingDecorationColorTokenValues = [
+  "text",
+  "primary",
+  "secondary",
+  "accent",
+  "border",
+  "muted"
+];
+var accordionIconSetValues = [
+  "plus",
+  "chevron",
+  "caret",
+  "minimal-cross"
+];
+var accordionIconColorTokenValues = [
+  "text",
+  "muted",
+  "primary",
+  "secondary",
+  "accent",
+  "current"
+];
+var accordionIconMotionValues = [
+  "none",
+  "rotate",
+  "swap"
+];
+
 // ../blocks/src/system/runtime/nodes/spinner.tsx
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
 function resolveColorStyle(color) {
   switch (color) {
+    case void 0:
+      return void 0;
     case "inherit":
       return { color: "inherit" };
     case "foreground":
@@ -5349,13 +5460,44 @@ function SpinnerNode({
 }
 
 // ../frontend-state/dist/index.mjs
-function okWith(data) {
+var IDLE_FEEDBACK = idleFeedback();
+function idleFeedback() {
+  return { tag: "idle" };
+}
+function clearWorkflowFeedback(state) {
+  return {
+    ...state,
+    feedback: idleSubmissionFeedback()
+  };
+}
+function reportWorkflowError(state, message) {
+  return {
+    ...state,
+    feedback: errorSubmissionFeedback(message)
+  };
+}
+function reportWorkflowSuccess(state, message) {
+  return {
+    ...state,
+    feedback: successSubmissionFeedback(message)
+  };
+}
+function idleSubmissionFeedback() {
+  return { tag: "idle" };
+}
+function errorSubmissionFeedback(message) {
+  return { tag: "error", message };
+}
+function successSubmissionFeedback(message) {
+  return { tag: "success", message };
+}
+function okWith2(data) {
   return { ok: true, data };
 }
-function err(error) {
+function err2(error) {
   return { ok: false, error };
 }
-function assertNever3(value, message) {
+function assertNever11(value, message) {
   throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 
@@ -5510,7 +5652,7 @@ function deriveBookingFormViewState(input) {
         resourceName: input.verificationState.resourceName
       };
     default:
-      return assertNever3(input.verificationState);
+      return assertNever11(input.verificationState);
   }
 }
 function resolveBookingSiteId(siteId, form) {
@@ -5680,7 +5822,7 @@ function getBookingServicePaymentSelectionMode(service) {
       case "flexible_balance":
         return "implicit_flexible_balance";
       default:
-        return assertNever3(onlyKind);
+        return assertNever11(onlyKind);
     }
   }
   if (allowedKinds.length === 2 && allowedKinds.includes("upfront") && (allowedKinds.includes("deferred_manual") || allowedKinds.includes("instalment_plan") || allowedKinds.includes("flexible_balance"))) {
@@ -5882,7 +6024,7 @@ function formatBookingSubmissionPreparationError(error) {
     case "service-missing-duration":
       return `Service "${error.serviceTitle}" is missing duration. Please update the service in the dashboard to include a duration (e.g., 30 minutes).`;
     default:
-      return assertNever3(error);
+      return assertNever11(error);
   }
 }
 function getBookingSuccessMessage(successMessage) {
@@ -5900,107 +6042,241 @@ var logger = {
   withFields: (_) => logger
 };
 
-// ../theme-core/src/inputs/types.ts
+// ../theme-core/src/utils/tokenOrColor.ts
 import { z as z6 } from "zod";
-var inputSystemSchema = z6.object({
+var tokenOrCssColorValueSchema = z6.string();
+
+// ../theme-core/src/site-styles/headerCtaVariants.ts
+function hasButtonVariant(theme, variantId) {
+  return theme.buttons?.variants.some((variant) => variant.enabled && variant.id === variantId) ?? false;
+}
+function resolveHeaderCtaVariant(theme, treatment) {
+  switch (treatment) {
+    case "default":
+      return void 0;
+    case "primary":
+      return "primary";
+    case "secondary":
+      return hasButtonVariant(theme, "secondary") ? "secondary" : "primary";
+    case "inverted":
+      if (hasButtonVariant(theme, "header")) return "header";
+      if (hasButtonVariant(theme, "secondary")) return "secondary";
+      if (hasButtonVariant(theme, "outline")) return "outline";
+      return "primary";
+    case "outline":
+      return hasButtonVariant(theme, "outline") ? "outline" : "secondary";
+    case "ghost":
+      return hasButtonVariant(theme, "ghost") ? "ghost" : "secondary";
+  }
+}
+
+// ../theme-core/src/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 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/cards/types.ts
+import { z as z8 } from "zod";
+var cardSpacingSchema = z8.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z8.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardBackgroundSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("solid"), colorToken: themeColorTokenSchema }),
+  z8.object({
+    type: z8.literal("gradient"),
+    fromToken: themeColorTokenSchema,
+    toToken: themeColorTokenSchema,
+    direction: gradientDirectionSchema2
+  }),
+  z8.object({ type: z8.literal("transparent") })
+]);
+var cardBorderSchema = z8.object({
+  widthClass: z8.string(),
+  colorToken: themeColorTokenSchema
+});
+var cardVariantSchema = z8.object({
+  id: z8.string(),
+  name: z8.string().min(1).max(20),
+  enabled: z8.boolean(),
+  priority: z8.union([z8.literal(1), z8.literal(2), z8.literal(3)]),
+  // Appearance (token-based)
+  background: cardBackgroundSchema,
+  spacing: cardSpacingSchema,
+  // Optional overrides (uses theme defaults if not specified)
+  shadow: z8.object({
+    elevation: z8.enum(["none", "low", "medium", "high"]),
+    softness: z8.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z8.enum(["bottom", "bottom-right"]).default("bottom")
+  }).optional(),
+  corners: z8.enum(["square", "soft", "rounded", "pill"]).optional(),
+  // Border (optional)
+  border: cardBorderSchema.optional()
+});
+var cardSystemSchema = z8.object({
+  variants: z8.array(cardVariantSchema).min(1).max(3)
+});
+
+// ../theme-core/src/inputs/types.ts
+import { z as z9 } from "zod";
+var inputSystemSchema = z9.object({
   // Base styling (applied to all inputs)
-  base: z6.object({
-    background: z6.union([
-      z6.object({
-        type: z6.literal("solid"),
+  base: z9.object({
+    background: z9.union([
+      z9.object({
+        type: z9.literal("solid"),
         colorToken: themeColorTokenSchema
       }),
-      z6.object({
-        type: z6.literal("transparent")
+      z9.object({
+        type: z9.literal("transparent")
       })
     ]),
     textColorToken: themeColorTokenSchema,
-    border: z6.object({
-      widthClass: z6.string(),
+    border: z9.object({
+      widthClass: z9.string(),
       // e.g., 'border', 'border-2'
       colorToken: themeColorTokenSchema,
-      style: z6.enum(["all", "underline"]).optional()
+      style: z9.enum(["all", "underline"]).optional()
     }),
-    corners: z6.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z9.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z6.object({
-      elevation: z6.enum(["none", "low", "medium"]),
-      softness: z6.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z9.object({
+      elevation: z9.enum(["none", "low", "medium"]),
+      softness: z9.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z6.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z9.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z6.enum(["sm", "base", "lg"])
+    fontSize: z9.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z6.object({
+  label: z9.object({
     textColorToken: themeColorTokenSchema,
-    fontWeight: z6.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z6.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z6.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z6.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z6.number().min(0.2).max(1).optional()
+    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: z6.object({
+  focus: z9.object({
     ringColorToken: themeColorTokenSchema,
-    ringWidth: z6.enum(["0", "1", "2", "3"]),
+    ringWidth: z9.enum(["0", "1", "2", "3"]),
     borderColorToken: themeColorTokenSchema.optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z6.object({
+  error: z9.object({
     borderColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema
   }),
   // Disabled state
-  disabled: z6.object({
+  disabled: z9.object({
     backgroundColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema,
-    opacity: z6.number().min(0.3).max(0.7)
+    opacity: z9.number().min(0.3).max(0.7)
   })
 });
 
+// ../theme-core/src/gradients/types.ts
+import { z as z10 } from "zod";
+var gradientStopSchema = z10.object({
+  color: themeColorTokenSchema,
+  position: z10.number().min(0).max(100)
+  // Percentage 0-100
+});
+var gradientConfigSchema = z10.object({
+  type: z10.enum(["linear", "radial"]),
+  angle: z10.number().min(0).max(360).optional(),
+  // For linear gradients (degrees)
+  position: z10.string().optional(),
+  // For radial gradients ('center', 'top left', etc.)
+  stops: z10.array(gradientStopSchema).min(2)
+});
+
 // ../theme-core/src/navigation/types.ts
-import { z as z8 } from "zod";
+import { z as z12 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z7 } from "zod";
-var interactiveTypographySchema = z7.object({
+import { z as z11 } from "zod";
+var interactiveTypographySchema = z11.object({
   /** Font family source */
-  typography: z7.enum(["body", "heading"]).default("body"),
+  typography: z11.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z7.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z11.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z7.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z11.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z7.boolean().default(false)
+  italic: z11.boolean().default(false)
 });
-var effectApplicationSchema2 = z7.object({
+var effectApplicationSchema2 = z11.object({
   /** Effect preset ID */
-  effectId: z7.string(),
+  effectId: z11.string(),
   /** User-provided customization options */
-  options: z7.record(z7.string(), z7.any()).optional()
+  options: z11.record(z11.string(), z11.any()).optional()
 });
-var effectCompositionSchema = z7.object({
+var effectCompositionSchema = z11.object({
   /** Effects always applied */
-  base: z7.array(effectApplicationSchema2).optional(),
+  base: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z7.array(effectApplicationSchema2).optional(),
+  hover: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z7.array(effectApplicationSchema2).optional(),
+  active: z11.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z7.array(effectApplicationSchema2).optional()
+  focus: z11.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z8.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z8.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z8.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z8.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z8.enum(["normal", "wide", "wider", "widest"]);
-var navLinkStyleSchema = z8.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 navLinkContrastTreatmentSchema = z12.enum(["none", "soft-glow"]);
+var navLinkStyleSchema = z12.object({
   /** Display name for the style */
-  name: z8.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 */
@@ -6009,6 +6285,8 @@ var navLinkStyleSchema = z8.object({
   textSize: navLinkTextSizeSchema.optional(),
   /** Optional letter spacing override */
   letterSpacing: navLinkLetterSpacingSchema.optional(),
+  /** Optional text-only contrast treatment for transparent/overlay navigation */
+  contrastTreatment: navLinkContrastTreatmentSchema.optional(),
   /** Hover/active color token (for color-change effects) */
   hoverColorToken: themeColorTokenSchema.nullable().optional(),
   /** Padding preset */
@@ -6022,7 +6300,7 @@ var navLinkStyleSchema = z8.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z9 } 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;
@@ -6050,152 +6328,3215 @@ function hasScopeEscapingSiblingCombinator(selector) {
   const normalized = selector.trim();
   return /&\s*[+~]/.test(normalized);
 }
-function containsForbiddenSelector(selector) {
-  const normalized = selector.toLowerCase().trim();
-  if (!normalized) return true;
-  if (hasScopeEscapingSiblingCombinator(selector)) {
+function containsForbiddenSelector(selector) {
+  const normalized = selector.toLowerCase().trim();
+  if (!normalized) return true;
+  if (hasScopeEscapingSiblingCombinator(selector)) {
+    return true;
+  }
+  const parts = normalized.split(",");
+  for (const part of parts) {
+    if (isForbiddenSelectorPart(part)) {
+      return true;
+    }
+  }
+  return false;
+}
+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" }
+);
+function containsRemoteUrl(value) {
+  return REMOTE_URL_PATTERN.test(value);
+}
+function containsJavascriptUrl(value) {
+  return JAVASCRIPT_URL_PATTERN.test(value);
+}
+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 = z13.record(
+  z13.string().min(1).max(100),
+  // property name
+  declarationValueSchema
+  // property value
+);
+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: z13.string().min(1, "Block kind is required").max(50, "Block kind too long")
+});
+var customCssRulesSchema = z13.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z13.array(blockCustomCssRuleSchema).optional();
+
+// ../theme-core/src/customCss/atRuleValidation.ts
+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 = z14.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z14.object({
+  selector: selectorSchema,
+  declarations: declarationsSchema
+});
+function isValidKeyframeOffset(offset) {
+  const trimmed = offset.trim().toLowerCase();
+  if (trimmed === "from" || trimmed === "to") return true;
+  const match = trimmed.match(/^(\d{1,3})%$/);
+  if (!match || match[1] === void 0) return false;
+  const value = parseInt(match[1], 10);
+  return value >= 0 && value <= 100;
+}
+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 = 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 = z14.object({
+  offset: keyframeOffsetSchema,
+  declarations: declarationsSchema
+});
+var keyframesAtRuleSchema = z14.object({
+  id: ruleIdSchema,
+  type: z14.literal("keyframes"),
+  name: animationNameSchema,
+  frames: z14.array(keyframeSchema).min(1, "At least one keyframe is required")
+});
+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 = z14.object({
+  id: ruleIdSchema,
+  type: z14.literal("font-face"),
+  declarations: fontFaceDeclarationsSchema
+});
+var mediaQuerySchema = z14.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z14.object({
+  id: ruleIdSchema,
+  type: z14.literal("media"),
+  query: mediaQuerySchema,
+  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
+});
+var supportsConditionSchema = z14.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z14.object({
+  id: ruleIdSchema,
+  type: z14.literal("supports"),
+  condition: supportsConditionSchema,
+  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
+});
+function containsBlockedAtRule(css) {
+  return BLOCKED_AT_RULE_PATTERN.test(css);
+}
+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 = z14.object({
+  id: ruleIdSchema,
+  type: z14.literal("raw"),
+  css: rawCssSchema
+});
+var customCssAtRuleSchema = z14.discriminatedUnion("type", [
+  keyframesAtRuleSchema,
+  fontFaceAtRuleSchema,
+  mediaAtRuleSchema,
+  supportsAtRuleSchema,
+  rawAtRuleSchema
+]);
+var customCssAtRulesSchema = z14.array(customCssAtRuleSchema).optional();
+
+// ../theme-core/src/shared/componentStyles.ts
+import { z as z15 } from "zod";
+var componentBorderSchema = z15.object({
+  width: z15.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z15.enum(["solid", "dashed"]).default("solid"),
+  colorToken: themeColorTokenSchema.optional()
+  // defaults to "border" if not set
+});
+var componentShadowSchema = z15.object({
+  elevation: z15.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+});
+
+// ../theme-core/src/schema.ts
+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 = z16.object({
+  mode: z16.enum(["light", "dark"])
+});
+var paletteSchema = z16.object({
+  colors: z16.array(paletteColorSchema),
+  meta: paletteMetaSchema
+});
+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: z16.enum(["md", "lg", "xl"])
+});
+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: z16.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z16.boolean().nullable().optional(),
+  colorToken: themeColorTokenSchema.nullable().optional()
+});
+var headingTypographyStyleSchema = typographyStyleSchema.extend({
+  case: z16.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z16.boolean().nullable(),
+  colorToken: themeColorTokenSchema.nullable().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: themeColorTokenSchema.optional(),
+  hoverColorToken: themeColorTokenSchema.optional(),
+  underline: z16.boolean().optional(),
+  decorationColorToken: themeColorTokenSchema.optional(),
+  hoverDecorationColorToken: themeColorTokenSchema.optional(),
+  underlineStyle: proseLinkUnderlineStyleSchema.optional(),
+  underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
+  underlineOffset: proseLinkUnderlineOffsetSchema.optional()
+});
+var semanticSpacingSchema = z16.enum([
+  "none",
+  "compact",
+  "cozy",
+  "medium",
+  "comfortable",
+  "spacious"
+]);
+var boxRoundedSchema = z16.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z16.object({
+  type: z16.enum(["none", "color", "gradient"]).nullable().optional(),
+  color: tokenOrCssColorValueSchema.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: tokenOrCssColorValueSchema.nullable().optional(),
+  gradient: z16.string().nullable().optional(),
+  image: mediaSchema.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(),
+  motion: z16.enum(["static", "fixed-frame"]).nullable().optional(),
+  overlay: boxBackgroundOverlaySchema.nullable().optional(),
+  textColor: tokenOrCssColorValueSchema.nullable().optional(),
+  headingColor: tokenOrCssColorValueSchema.nullable().optional()
+});
+var noHeadingDecorationSchema = z16.object({
+  family: z16.literal("none"),
+  placement: z16.literal("none")
+});
+var visibleHeadingDecorationSchema = z16.object({
+  family: z16.enum(visibleHeadingDecorationFamilyValues),
+  placement: z16.enum(visibleHeadingDecorationPlacementValues),
+  colorToken: z16.enum(headingDecorationColorTokenValues).optional()
+});
+var headingDecorationSchema = z16.union([
+  noHeadingDecorationSchema,
+  visibleHeadingDecorationSchema
+]);
+var accordionIconTreatmentSchema = z16.object({
+  iconSet: z16.enum(accordionIconSetValues),
+  colorToken: z16.enum(accordionIconColorTokenValues),
+  openColorToken: z16.enum(accordionIconColorTokenValues).optional(),
+  motion: z16.enum(accordionIconMotionValues)
+});
+var sectionStylesOverrideSchema = z16.object({
+  background: boxBackgroundSchema.nullable().optional(),
+  spacing: semanticSpacingSchema.nullable().optional(),
+  minHeight: z16.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
+  tileTreatment: z16.enum(tileTreatmentValues).nullable().optional(),
+  eventListTreatment: z16.enum(eventListTreatmentValues).nullable().optional(),
+  eyebrowTreatment: z16.enum(eyebrowTreatmentValues).nullable().optional(),
+  headingDecoration: headingDecorationSchema.nullable().optional(),
+  // Author-level override consumed by later block/editor rendering phases.
+  // Keeping it in section styles lets existing block save APIs persist it.
+  headingDecorationOverride: z16.enum(headingDecorationOverrideValues).nullable().optional(),
+  accordionIconTreatment: accordionIconTreatmentSchema.nullable().optional()
+});
+var containerStylesOverrideSchema = z16.object({
+  background: boxBackgroundSchema.nullable().optional(),
+  spacing: semanticSpacingSchema.nullable().optional(),
+  raised: z16.boolean().nullable().optional(),
+  rounded: boxRoundedSchema.nullable().optional(),
+  fullWidth: z16.boolean().nullable().optional()
+});
+var cardBorderOverrideSchema = z16.object({
+  enabled: z16.boolean().nullable().optional(),
+  width: z16.enum(["none", "1", "2", "3"]).nullable().optional(),
+  colorToken: themeColorTokenSchema.nullable().optional()
+});
+var cardStylesOverrideSchema = z16.object({
+  background: boxBackgroundSchema.nullable().optional(),
+  border: cardBorderOverrideSchema.nullable().optional(),
+  spacing: semanticSpacingSchema.nullable().optional(),
+  raised: z16.boolean().nullable().optional(),
+  rounded: boxRoundedSchema.nullable().optional(),
+  treatment: z16.enum(["accent-quote"]).nullable().optional()
+});
+var blockStyleOverridesSchema = z16.object({
+  sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
+  containerStyles: containerStylesOverrideSchema.nullable().optional(),
+  cardStyles: cardStylesOverrideSchema.nullable().optional()
+});
+var blockThemeOverrideSchema = z16.object({
+  typography: z16.object({
+    proseLinkStyle: proseLinkStyleSchema.optional()
+  }).optional(),
+  styles: blockStyleOverridesSchema.optional()
+});
+var typographyScaleSchema = z16.enum([
+  // New intuitive names
+  "compact",
+  // ratio 1.2 (was minorThird)
+  "balanced",
+  // ratio 1.25 (was majorThird)
+  "spacious",
+  // ratio 1.333 (was perfectFourth)
+  // Legacy names (backward compatibility)
+  "minorThird",
+  "majorThird",
+  "perfectFourth"
+]);
+var typographySchema = z16.object({
+  body: bodyTypographyStyleSchema,
+  headings: z16.object({
+    default: headingTypographyStyleSchema,
+    h1: headingTypographyOverridesSchema,
+    h2: headingTypographyOverridesSchema,
+    h3: headingTypographyOverridesSchema,
+    // Allow per-level overrides for additional heading levels
+    h4: headingTypographyOverridesSchema.optional(),
+    h5: headingTypographyOverridesSchema.optional(),
+    h6: headingTypographyOverridesSchema.optional()
+  }),
+  scale: typographyScaleSchema,
+  proseLinkStyle: proseLinkStyleSchema.optional()
+});
+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 = z16.object({
+  width: z16.enum(["none", "hairline", "thin", "thick"]),
+  style: z16.enum(["solid", "dashed"])
+});
+var motion = z16.object({
+  level: z16.enum(["off", "low", "medium", "high"]),
+  easing: z16.enum(["standard", "snappy", "gentle"]).nullable()
+});
+var buttonStyle = z16.object({
+  shape: corners
+  // Used for --radius-control CSS variable
+});
+var cardStyle = z16.object({
+  elevation: z16.enum(["none", "low", "medium", "high"]),
+  border: z16.enum(["none", "subtle", "defined"]),
+  shape: corners,
+  headerStyle: z16.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z16.enum(["square", "rounded", "bleed"]).nullable()
+});
+var inputStyle = z16.object({
+  shape: corners,
+  border: z16.enum(["subtle", "defined", "underline"]),
+  focus: z16.enum(["glow", "ring", "underline"]),
+  label: z16.enum(["inside", "above"])
+});
+var headerVariant = z16.enum(["classic", "centered", "transparent", "floating"]);
+var headerPositioning = z16.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z16.enum([
+  "minimal",
+  "underline",
+  "underline-grow",
+  "capsule",
+  "scale",
+  "frosted",
+  "solid"
+]);
+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: z16.enum(["bottom", "top", "both", "none"]).default("bottom")
+}).optional();
+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 = 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 = z16.object({
+  underlineGradient: z16.boolean().default(false),
+  glow: z16.boolean().default(false),
+  glowColor: z16.string().optional(),
+  neumorphic: z16.boolean().default(false)
+}).optional();
+var dropdownStyleSchema = z16.object({
+  // Container styling
+  background: themeColorTokenSchema.default("surface"),
+  textColor: themeColorTokenSchema.default("text"),
+  borderColor: themeColorTokenSchema.nullable().default("border"),
+  shadow: z16.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z16.enum(["none", "sm", "md", "lg"]).default("md"),
+  // Link hover states (explicit control)
+  hoverBackground: themeColorTokenSchema.nullable().optional(),
+  hoverTextColor: themeColorTokenSchema.nullable().optional(),
+  // Typography
+  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: z16.enum(["xs", "sm", "base", "lg"]).optional()
+  // optional = no override (browser default)
+}).optional();
+var headerCtaGapSchema = z16.enum([
+  "none",
+  "tight",
+  "compact",
+  "default",
+  "relaxed",
+  "spacious"
+]);
+var headerCtaTreatmentSchema = z16.enum([
+  "default",
+  "primary",
+  "secondary",
+  "inverted",
+  "outline",
+  "ghost"
+]);
+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 = z16.object({
+  type: z16.enum(["color", "gradient", "image"]),
+  color: tokenOrCssColorValueSchema.nullable().optional(),
+  gradient: gradientConfigSchema.nullable().optional(),
+  image: mediaSchema.nullable().optional(),
+  textColor: tokenOrCssColorValueSchema.nullable().optional()
+});
+var headerSchema = z16.object({
+  variant: headerVariant,
+  positioning: headerPositioning,
+  shrinkOnScroll: z16.boolean(),
+  maxWidth: headerMaxWidth,
+  logoOverride: mediaSchema.nullable().optional(),
+  background: headerBackgroundSchema.default({
+    type: "color",
+    color: "surface"
+  }),
+  textColor: themeColorTokenSchema.nullable().optional(),
+  navStyle: headerNavStyle,
+  navColor: themeColorTokenSchema.nullable().optional(),
+  navWeight: navFontWeight.default("medium"),
+  // New fields for header system enhancement
+  container: headerContainerSchema,
+  border: headerBorderSchema,
+  shadow: componentShadowSchema.optional(),
+  // defaults to 'sm' for sticky in CSS generator
+  logo: logoStyleSchema,
+  logoText: headerLogoTextSchema,
+  navEffects: navEffectsSchema,
+  navContainer: navContainerSchema,
+  // Full nav link customization (overrides navStyle if set)
+  navLinkStyle: navLinkStyleSchema.optional(),
+  // CTA button spacing (desktop left margin)
+  ctaGap: headerCtaGapSchema.optional(),
+  // Semantic CTA treatment for header/nav CTA buttons. The Theme V2 compiler
+  // materializes this to ctaVariant against the active button personality.
+  ctaTreatment: headerCtaTreatmentSchema.optional(),
+  // Optional theme-level CTA variant for header/nav CTA buttons.
+  // Internal runtime bridge for the block renderer; prefer ctaTreatment in
+  // authored Theme V2 concepts.
+  ctaVariant: z16.string().min(1).optional(),
+  // Dropdown menu styling (nav dropdowns and mobile drawer)
+  dropdownStyle: dropdownStyleSchema
+});
+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: themeColorTokenSchema.optional(),
+  hoverColorToken: themeColorTokenSchema.nullable().optional(),
+  decorationColorToken: themeColorTokenSchema.nullable().optional(),
+  underline: z16.boolean().optional()
+});
+var footerBottomBarSchema = z16.object({
+  enabled: z16.boolean().optional(),
+  fullBleed: z16.boolean().optional(),
+  background: headerBackgroundSchema.optional(),
+  textColor: themeColorTokenSchema.nullable().optional(),
+  textAlign: z16.enum(["left", "center", "right"]).optional(),
+  paddingY: footerSpacing.optional(),
+  paddingX: footerSpacing.optional(),
+  borderTop: z16.object({
+    colorToken: themeColorTokenSchema.nullable().optional(),
+    width: z16.enum(["none", "thin", "medium", "thick"]).optional()
+  }).optional()
+});
+var footerNavLayoutSchema = z16.object({
+  layout: footerNavLayoutMode.optional(),
+  align: footerNavLayoutAlign.optional(),
+  gapX: footerSpacing.optional(),
+  gapY: footerSpacing.optional(),
+  columns: z16.number().int().min(1).max(6).optional()
+});
+var footerLogoSchema = z16.object({
+  showLogo: z16.boolean().default(true),
+  showLogoText: z16.boolean().optional(),
+  placement: footerLogoPlacement.optional(),
+  size: footerLogoSize.optional(),
+  maxHeight: footerLogoMaxHeight.optional(),
+  align: z16.enum(["start", "center", "end"]).optional()
+});
+var footerSchema = z16.object({
+  /**
+   * SDK-only footer rendering mode.
+   *
+   * Backwards compatible: missing/undefined behaves as 'default'.
+   */
+  mode: footerMode.optional(),
+  variant: footerVariant,
+  maxWidth: footerMaxWidth,
+  showLogoText: z16.boolean().optional(),
+  background: headerBackgroundSchema.default({
+    type: "color",
+    color: "surface"
+  }),
+  // Footer nav styling (independent from header)
+  navStyle: headerNavStyle.default("minimal"),
+  navColor: themeColorTokenSchema.nullable().optional(),
+  navWeight: navFontWeight.default("medium"),
+  // Full nav link customization (overrides navStyle if set)
+  navLinkStyle: navLinkStyleSchema.optional(),
+  // Footer bottom rich-text link styling (scoped to footer prose links)
+  bottomTextLinkStyle: footerBottomTextLinkStyleSchema.optional(),
+  // Footer layout controls
+  navLayout: footerNavLayoutSchema.optional(),
+  logo: footerLogoSchema.optional(),
+  bottomBar: footerBottomBarSchema.optional()
+});
+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 = z16.enum([
+  "sm",
+  "base",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl",
+  "4xl",
+  "5xl",
+  "6xl",
+  "editorial"
+]);
+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 = z16.object({
+  headlineSize: heroTypographySizeSchema.optional(),
+  headlineLineHeight: heroTypographyLineHeightSchema.optional(),
+  subheadlineSize: heroTypographySizeSchema.optional(),
+  subheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+  microHeadlineSize: heroTypographySizeSchema.optional(),
+  microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+  microSubheadlineSize: heroTypographySizeSchema.optional(),
+  microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
+  responsive: z16.object({
+    tablet: heroResponsiveTypographySchema.optional(),
+    mobile: heroResponsiveTypographySchema.optional()
+  }).optional()
+});
+var heroSchema = z16.object({
+  typography: heroTypographySchema.optional()
+}).optional();
+var bodyTextIntroTypographySizeSchema = z16.enum(["default", "editorial"]);
+var bodyTextSchema = z16.object({
+  intro: z16.object({
+    paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
+    headingSize: bodyTextIntroTypographySizeSchema.optional()
+  }).optional()
+}).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,
+  space: spaceSchema,
+  border,
+  shadow,
+  motion,
+  corners,
+  gradients: gradientsSchema.optional(),
+  layout: layoutSchema,
+  hero: heroSchema,
+  bodyText: bodyTextSchema,
+  header: headerSchema,
+  footer: footerSchema,
+  buttons: buttonSystemSchema.optional(),
+  // New button system (optional for backwards compatibility)
+  cards: cardSystemSchema.optional(),
+  // Card variant system (optional for backwards compatibility)
+  accordions: accordionSystemSchema.optional(),
+  // Accordion system (optional - generated if not provided)
+  inputs: inputSystemSchema.optional(),
+  // Input system (optional - generated if not provided)
+  inputStyle: inputStyle.optional(),
+  // Simple input styling API (drives InputSystem defaults)
+  // Block-specific customization (Tier 3)
+  // blockCustomVars: Per-block CSS variable overrides as bare values
+  // Example: { "event-registration": { "--step-color": "#6d28d9" } }
+  blockCustomVars: z16.record(
+    z16.string(),
+    // block kind (matches data-block attribute)
+    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: z16.record(z16.string(), blockThemeOverrideSchema).optional(),
+  // Structured custom CSS rules
+  // Validated, scoped, and safe by construction - no @import, remote url(), or global selectors
+  customCssRules: customCssRulesSchema,
+  // Structured block-specific CSS rules
+  blockCustomCssRules: blockCustomCssRulesSchema,
+  // Structured CSS at-rules (@keyframes, @media, @font-face, etc.)
+  // @keyframes and @font-face are global; @media/@supports have scoped selectors
+  customCssAtRules: customCssAtRulesSchema,
+  /**
+   * Style groups define named visual presets that content authors can apply to blocks.
+   *
+   * Unlike variants (which change block structure/layout), style groups only affect
+   * CSS styling. The selected style group is rendered as a `data-style-group` attribute
+   * on the block wrapper, which can be targeted in `blockCustomCssRules`.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   styleGroups: {
+   *     hero: ['bold', 'minimal', 'featured'],
+   *     'body-text': ['intro', 'compact'],
+   *   },
+   *   blockCustomCssRules: [
+   *     {
+   *       id: 'hero-bold-headline',
+   *       blockKind: 'hero',
+   *       selector: '&[data-style-group="bold"] .hero-headline',
+   *       declarations: { fontWeight: '800', fontSize: '3rem' }
+   *     }
+   *   ]
+   * }
+   * ```
+   */
+  styleGroups: 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 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" }
+  ]
+});
+var brandLedBurgundyGold = definePaletteVariant({
+  id: "brand-led-burgundy-gold",
+  name: "Brand-led \u2014 Burgundy Gold",
+  description: "Deep burgundy with warm gold accents and soft neutral grounds.",
+  tags: { tone: "bold", energy: "vibrant", era: "modern" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#7c2e38" },
+    { name: "secondary", hex: "#d4af37" },
+    { name: "accent", hex: "#b8e19a" },
+    { name: "success", hex: "#10b981" },
+    { name: "warning", hex: "#f59e0b" },
+    { name: "destructive", hex: "#ef4444" },
+    { name: "background", hex: "#f1dfd0" },
+    { name: "surface", hex: "#f5e6db" },
+    { name: "surfaceAlt", hex: "#f8ece3" },
+    { name: "muted", hex: "#c9b8a8" },
+    { name: "text", hex: "#400000" },
+    { name: "primaryForeground", hex: "#ffffff" },
+    { name: "border", hex: "#c9b8a8" }
+  ]
+});
+
+// ../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 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/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" }
+  ]
+});
+var warmNeutralSoftEarth = definePaletteVariant({
+  id: "warm-neutral-soft-earth",
+  name: "Warm Neutral \u2014 Soft Earth",
+  description: "Cream ground with terracotta primary, clay accents, and olive depth.",
+  tags: { tone: "classic", energy: "calm", era: "organic" },
+  mode: "light",
+  colors: [
+    { name: "primary", hex: "#a8573d" },
+    { name: "secondary", hex: "#72765c" },
+    { name: "accent", hex: "#c87557" },
+    { name: "success", hex: "#687854" },
+    { name: "warning", hex: "#b7863e" },
+    { name: "destructive", hex: "#a54b3c" },
+    { name: "background", hex: "#fbf6eb" },
+    { name: "surface", hex: "#fffdf7" },
+    { name: "surfaceAlt", hex: "#f0e4d3" },
+    { name: "muted", hex: "#eadbc6" },
+    { name: "text", hex: "#30281f" },
+    { name: "primaryForeground", hex: "#fffaf3" },
+    { name: "border", hex: "#d9c8b2" }
+  ]
+});
+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,
+  brandLedBurgundyGold,
+  // Warm-neutral family
+  warmNeutralClay,
+  warmNeutralCream,
+  warmNeutralSoftEarth,
+  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/accordions/siteStyleDefaults.ts
+var softEarthAccordionSystem = {
+  background: {
+    type: "solid",
+    colorToken: "background"
+  },
+  spacing: "comfortable",
+  corners: "square",
+  border: null,
+  shadow: null,
+  icon: {
+    style: "plus-minus",
+    position: "right",
+    size: "md",
+    colorToken: "primary"
+  },
+  trigger: {
+    textColorToken: "text",
+    fontWeight: "medium"
+  },
+  hover: {
+    textColorToken: "primary"
+  },
+  content: {
+    textColorToken: "neutral-700"
+  }
+};
+
+// ../theme-core/src/site-styles/headerLooks.ts
+function asHeaderLookId(value) {
+  return value;
+}
+function asHeaderLayoutId(value) {
+  return value;
+}
+function asHeaderStyleId(value) {
+  return value;
+}
+function baseHeader(theme) {
+  const {
+    navLinkStyle: _navLinkStyle,
+    dropdownStyle: _dropdownStyle,
+    ctaVariant: _ctaVariant,
+    navContainer: _navContainer,
+    container: _container,
+    shadow: _shadow,
+    logo: _logo,
+    logoText: _logoText,
+    border: _border,
+    ...header
+  } = theme.header;
+  return {
+    ...header,
+    navContainer: { type: "none", tint: null, opacity: 0.15 }
+  };
+}
+var headerLayoutCatalog = [
+  {
+    id: asHeaderLayoutId("classic"),
+    label: "Classic",
+    description: "Logo and navigation in one practical horizontal row.",
+    structure: "inline-classic",
+    variant: "classic",
+    defaultPositioning: "sticky",
+    shrinkOnScroll: false
+  },
+  {
+    id: asHeaderLayoutId("centered"),
+    label: "Centered",
+    description: "Logo centered above a balanced navigation row.",
+    structure: "centered-stack",
+    variant: "centered",
+    defaultPositioning: "static",
+    shrinkOnScroll: false,
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal", "square"]
+  },
+  {
+    id: asHeaderLayoutId("floating"),
+    label: "Floating",
+    description: "Detached header chrome that sits over the opening section.",
+    structure: "floating-shell",
+    variant: "floating",
+    defaultPositioning: "sticky",
+    shrinkOnScroll: true,
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal"]
+  }
+];
+function supportedLayouts(ids) {
+  return ids.map(asHeaderLayoutId);
+}
+var headerStyleCatalog = [
+  {
+    id: asHeaderStyleId("minimal"),
+    label: "Minimal",
+    description: "Quiet surface with simple color-change navigation.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "color-change",
+    surface: "neutral",
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["calm", "professional", "editorial"]
+  },
+  {
+    id: asHeaderStyleId("fine-line"),
+    label: "Fine Line",
+    description: "Light surface with a crisp lower rule and underline hover.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "underline-grow",
+    surface: "bordered",
+    defaultDepth: "line",
+    navTypography: "plain",
+    moods: ["calm", "professional", "editorial"]
+  },
+  {
+    id: asHeaderStyleId("soft-bar"),
+    label: "Soft Bar",
+    description: "Soft tinted surface with gentle pill hover states.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "pill-background",
+    surface: "soft",
+    defaultDepth: "line",
+    navTypography: "plain",
+    moods: ["calm", "professional"]
+  },
+  {
+    id: asHeaderStyleId("pill-nav"),
+    label: "Pill Nav",
+    description: "A calm pill navigation rail over a neutral header.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "pill-background",
+    surface: "soft",
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["calm"]
+  },
+  {
+    id: asHeaderStyleId("brand-bar"),
+    label: "Brand Bar",
+    description: "Solid brand surface with high-contrast navigation.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "color-change",
+    surface: "brand-solid",
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["professional", "expressive", "utility"]
+  },
+  {
+    id: asHeaderStyleId("brand-underline"),
+    label: "Brand Underline",
+    description: "Brand surface with underline-grow navigation.",
+    supportedLayoutIds: supportedLayouts(["classic"]),
+    navInteraction: "underline-grow",
+    surface: "brand-solid",
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["expressive"]
+  },
+  {
+    id: asHeaderStyleId("brand-pill"),
+    label: "Brand Pill",
+    description: "Solid brand surface with rounded active and hover states.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered", "floating"]),
+    navInteraction: "pill-background",
+    surface: "brand-solid",
+    defaultDepth: "none",
+    navTypography: "brand-caps",
+    moods: ["expressive"]
+  },
+  {
+    id: asHeaderStyleId("serif-line"),
+    label: "Serif Line",
+    description: "Typographic logo treatment with understated underline navigation.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "underline-grow",
+    surface: "bordered",
+    defaultDepth: "line",
+    navTypography: "heading",
+    moods: ["editorial", "calm"]
+  },
+  {
+    id: asHeaderStyleId("flat-tabs"),
+    label: "Flat Tabs",
+    description: "Flat block hover and active states with a Swiss utility feel.",
+    supportedLayoutIds: supportedLayouts(["classic", "centered"]),
+    navInteraction: "flat-block",
+    surface: "bordered",
+    defaultDepth: "shadow",
+    navTypography: "quiet-caps",
+    moods: ["professional", "utility", "expressive"]
+  },
+  {
+    id: asHeaderStyleId("glass"),
+    label: "Glass",
+    description: "Translucent chrome with frosted navigation backing.",
+    supportedLayoutIds: supportedLayouts(["floating"]),
+    navInteraction: "glass-backed",
+    surface: "floating",
+    defaultDepth: "shadow",
+    navTypography: "plain",
+    moods: ["expressive", "calm"]
+  },
+  {
+    id: asHeaderStyleId("minimal-surface"),
+    label: "Clear Split",
+    description: "Floating logo with transparent navigation and no shared shell.",
+    supportedLayoutIds: supportedLayouts(["floating"]),
+    navInteraction: "color-change",
+    surface: "floating",
+    defaultDepth: "none",
+    navTypography: "plain",
+    moods: ["editorial", "calm"]
+  },
+  {
+    id: asHeaderStyleId("soft-shell"),
+    label: "Soft Shell",
+    description: "Floating rounded shell with soft pill navigation states.",
+    supportedLayoutIds: supportedLayouts(["floating"]),
+    navInteraction: "pill-background",
+    surface: "floating",
+    defaultDepth: "shadow",
+    navTypography: "plain",
+    moods: ["calm", "professional"]
+  },
+  {
+    id: asHeaderStyleId("split-glass"),
+    label: "Split Glass",
+    description: "Logo floats independently while the navigation sits in a glass rail.",
+    supportedLayoutIds: supportedLayouts(["floating"]),
+    navInteraction: "glass-backed",
+    surface: "floating",
+    defaultDepth: "shadow",
+    navTypography: "quiet-caps",
+    moods: ["expressive"]
+  },
+  {
+    id: asHeaderStyleId("split-pill"),
+    label: "Split Pill",
+    description: "Logo floats independently with a soft pill-backed navigation rail.",
+    supportedLayoutIds: supportedLayouts(["floating"]),
+    navInteraction: "pill-background",
+    surface: "floating",
+    defaultDepth: "shadow",
+    navTypography: "heading",
+    moods: ["calm", "editorial"]
+  }
+];
+var headerLayoutsById = new Map(
+  headerLayoutCatalog.map((layout) => [layout.id, layout])
+);
+var headerStylesById = new Map(
+  headerStyleCatalog.map((style) => [style.id, style])
+);
+var headerStyleCompatibilityOrder = /* @__PURE__ */ new Map([
+  [
+    asHeaderLayoutId("classic"),
+    headerStyleRepairChain([
+      "minimal",
+      "fine-line",
+      "soft-bar",
+      "pill-nav",
+      "brand-bar",
+      "brand-underline",
+      "brand-pill",
+      "serif-line",
+      "flat-tabs"
+    ])
+  ],
+  [
+    asHeaderLayoutId("centered"),
+    headerStyleRepairChain([
+      "minimal",
+      "fine-line",
+      "soft-bar",
+      "pill-nav",
+      "brand-bar",
+      "brand-pill",
+      "serif-line",
+      "flat-tabs"
+    ])
+  ],
+  [
+    asHeaderLayoutId("floating"),
+    headerStyleRepairChain([
+      "glass",
+      "minimal-surface",
+      "split-glass",
+      "split-pill",
+      "soft-shell",
+      "brand-pill"
+    ])
+  ]
+]);
+function headerStyleRepairChain(values) {
+  return values.map(asHeaderStyleId);
+}
+var headerStyleRepairOrder = /* @__PURE__ */ new Map(
+  [
+    [
+      asHeaderStyleId("brand-bar"),
+      headerStyleRepairChain(["brand-bar", "brand-pill", "minimal"])
+    ],
+    [
+      asHeaderStyleId("brand-underline"),
+      headerStyleRepairChain(["serif-line", "fine-line", "minimal"])
+    ],
+    [
+      asHeaderStyleId("brand-pill"),
+      headerStyleRepairChain(["brand-pill", "brand-bar", "minimal"])
+    ],
+    [
+      asHeaderStyleId("pill-nav"),
+      headerStyleRepairChain(["pill-nav", "soft-bar", "minimal"])
+    ],
+    [
+      asHeaderStyleId("flat-tabs"),
+      headerStyleRepairChain(["flat-tabs", "pill-nav", "minimal"])
+    ],
+    [
+      asHeaderStyleId("serif-line"),
+      headerStyleRepairChain(["serif-line", "fine-line", "minimal"])
+    ],
+    [
+      asHeaderStyleId("glass"),
+      headerStyleRepairChain([
+        "glass",
+        "soft-shell",
+        "fine-line",
+        "minimal-surface",
+        "minimal"
+      ])
+    ],
+    [
+      asHeaderStyleId("soft-shell"),
+      headerStyleRepairChain(["soft-shell", "soft-bar", "minimal"])
+    ],
+    [
+      asHeaderStyleId("minimal-surface"),
+      headerStyleRepairChain(["minimal-surface", "minimal"])
+    ],
+    [
+      asHeaderStyleId("split-glass"),
+      headerStyleRepairChain(["split-glass", "glass", "minimal-surface"])
+    ],
+    [
+      asHeaderStyleId("split-pill"),
+      headerStyleRepairChain(["split-pill", "soft-shell", "brand-pill"])
+    ],
+    [
+      asHeaderStyleId("fine-line"),
+      headerStyleRepairChain(["fine-line", "minimal"])
+    ],
+    [
+      asHeaderStyleId("soft-bar"),
+      headerStyleRepairChain(["soft-bar", "minimal"])
+    ],
+    [asHeaderStyleId("minimal"), headerStyleRepairChain(["minimal"])]
+  ]
+);
+var legacyHeaderLookAliases = [
+  {
+    lookId: asHeaderLookId("clean-base"),
+    selection: {
+      layoutId: asHeaderLayoutId("classic"),
+      styleId: asHeaderStyleId("minimal")
+    }
+  },
+  {
+    lookId: asHeaderLookId("brand-solid"),
+    selection: {
+      layoutId: asHeaderLayoutId("classic"),
+      styleId: asHeaderStyleId("brand-bar")
+    }
+  },
+  {
+    lookId: asHeaderLookId("serif-line"),
+    selection: {
+      layoutId: asHeaderLayoutId("centered"),
+      styleId: asHeaderStyleId("serif-line")
+    }
+  },
+  {
+    lookId: asHeaderLookId("centered-calm"),
+    selection: {
+      layoutId: asHeaderLayoutId("centered"),
+      styleId: asHeaderStyleId("minimal")
+    }
+  },
+  {
+    lookId: asHeaderLookId("practical-utility"),
+    selection: {
+      layoutId: asHeaderLayoutId("classic"),
+      styleId: asHeaderStyleId("flat-tabs")
+    }
+  },
+  {
+    lookId: asHeaderLookId("minimal-transparent"),
+    selection: {
+      layoutId: asHeaderLayoutId("classic"),
+      styleId: asHeaderStyleId("minimal")
+    }
+  },
+  {
+    lookId: asHeaderLookId("transparent-overlay"),
+    selection: {
+      layoutId: asHeaderLayoutId("floating"),
+      styleId: asHeaderStyleId("glass")
+    }
+  },
+  {
+    lookId: asHeaderLookId("floating-glass"),
+    selection: {
+      layoutId: asHeaderLayoutId("floating"),
+      styleId: asHeaderStyleId("glass")
+    }
+  }
+];
+var legacyHeaderLookAliasesById = new Map(legacyHeaderLookAliases.map((alias) => [alias.lookId, alias]));
+function getHeaderStyle(id) {
+  return headerStylesById.get(id) ?? null;
+}
+function isHeaderStyleCompatibleWithLayout(style, layoutId) {
+  return style.supportedLayoutIds.includes(layoutId);
+}
+function getHeaderStyleOrThrow(id) {
+  const style = getHeaderStyle(id);
+  if (!style) {
+    throw new Error(`Unknown Theme V2 header style: ${id}`);
+  }
+  return style;
+}
+function resolveLegacyHeaderLookAlias(lookId) {
+  return legacyHeaderLookAliasesById.get(lookId)?.selection ?? null;
+}
+function getCompatibleHeaderStyleIds(layoutId) {
+  return (headerStyleCompatibilityOrder.get(layoutId) ?? []).filter(
+    (styleId) => {
+      const style = getHeaderStyleOrThrow(styleId);
+      return isHeaderStyleCompatibleWithLayout(style, layoutId);
+    }
+  );
+}
+function themedHeaderShadow(theme) {
+  switch (theme.shadow.elevation) {
+    case "none":
+      return void 0;
+    case "low":
+      return { elevation: "sm" };
+    case "medium":
+      return { elevation: "md" };
+    case "high":
+      return { elevation: "lg" };
+    default:
+      return assertNever3(
+        theme.shadow.elevation,
+        "Unhandled theme shadow elevation"
+      );
+  }
+}
+function solidBrandHeader(theme) {
+  const ctaVariant = resolveHeaderCtaVariant(theme, "inverted");
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "primary"
+    },
+    textColor: "primaryForeground",
+    navColor: "primaryForeground",
+    navStyle: "underline-grow",
+    navWeight: "bold",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "bold",
+      textTransform: "uppercase",
+      italic: false,
+      colorToken: "primaryForeground",
+      hoverColorToken: "secondary",
+      textSize: "sm",
+      letterSpacing: "wider",
+      padding: "compact",
+      paddingX: "compact",
+      borderRadius: "none",
+      effects: {
+        hover: [
+          {
+            effectId: "text-color-change",
+            options: { hoverColorToken: "secondary" }
+          },
+          {
+            effectId: "nav-underline",
+            options: { style: "grow", colorToken: "secondary" }
+          }
+        ]
+      }
+    },
+    dropdownStyle: {
+      background: "primary-700",
+      textColor: "primaryForeground",
+      borderColor: null,
+      shadow: "md",
+      borderRadius: "md",
+      hoverBackground: "primary-900",
+      hoverTextColor: "secondary",
+      textTransform: "uppercase",
+      letterSpacing: "wider",
+      fontWeight: "bold",
+      textSize: "sm"
+    },
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    logoText: {
+      hideOnShrink: true,
+      mobileMaxWidth: "sm",
+      mobileWrapLines: 2
+    },
+    ctaGap: "compact",
+    ctaTreatment: "inverted",
+    ...ctaVariant ? { ctaVariant } : {}
+  };
+}
+function cleanBaseHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "minimal",
+    navWeight: "medium",
+    border: {
+      style: "solid",
+      width: "thin",
+      position: "bottom",
+      colorToken: "border"
+    },
+    ctaTreatment: "default",
+    ctaGap: "default"
+  };
+}
+function serifLineHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "centered",
+    positioning: "sticky",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "background"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "underline-grow",
+    navWeight: "medium",
+    logo: {
+      fontFamily: "heading",
+      letterSpacing: "wide",
+      gradient: false
+    },
+    ctaTreatment: "outline",
+    ctaVariant: resolveHeaderCtaVariant(theme, "outline"),
+    ctaGap: "relaxed"
+  };
+}
+function centeredCalmHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "centered",
+    positioning: "static",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "minimal",
+    navWeight: "medium",
+    ctaTreatment: "ghost",
+    ctaVariant: resolveHeaderCtaVariant(theme, "ghost"),
+    ctaGap: "none"
+  };
+}
+function practicalUtilityHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "sticky",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "solid",
+    navWeight: "semibold",
+    shadow: themedHeaderShadow(theme),
+    border: {
+      style: "solid",
+      width: "thin",
+      position: "bottom",
+      colorToken: "border"
+    },
+    ctaTreatment: "primary",
+    ctaVariant: resolveHeaderCtaVariant(theme, "primary"),
+    ctaGap: "compact",
+    logoText: {
+      mobileMaxWidth: "sm",
+      mobileWrapLines: 1,
+      hideOnShrink: false
+    }
+  };
+}
+function minimalTransparentHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "classic",
+    positioning: "static",
+    shrinkOnScroll: false,
+    background: {
+      type: "color",
+      color: "transparent"
+    },
+    textColor: "text",
+    navColor: "text",
+    navStyle: "underline",
+    navWeight: "medium",
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    ctaTreatment: "outline",
+    ctaVariant: resolveHeaderCtaVariant(theme, "outline"),
+    ctaGap: "default"
+  };
+}
+function transparentOverlayHeader(theme) {
+  return {
+    ...baseHeader(theme),
+    variant: "transparent",
+    positioning: "fixed",
+    shrinkOnScroll: true,
+    background: {
+      type: "color",
+      color: "transparent"
+    },
+    textColor: "background",
+    navColor: "background",
+    navStyle: "frosted",
+    navWeight: "semibold",
+    border: {
+      style: "solid",
+      width: "none",
+      position: "none"
+    },
+    ctaTreatment: "inverted",
+    ctaVariant: resolveHeaderCtaVariant(theme, "inverted"),
+    ctaGap: "compact"
+  };
+}
+function floatingGlassHeader(theme) {
+  return {
+    ...transparentOverlayHeader(theme),
+    variant: "floating",
+    positioning: "sticky",
+    navStyle: "frosted",
+    navContainer: {
+      type: "glass",
+      tint: "text",
+      opacity: 0.16
+    },
+    container: {
+      rounded: "2xl",
+      border: true,
+      shadow: true,
+      padding: "sm",
+      tint: "background",
+      opacity: 0.12
+    }
+  };
+}
+var headerLookCatalog = [
+  {
+    id: asHeaderLookId("clean-base"),
+    label: "Clean base",
+    visualTreatment: "solid-neutral",
+    layoutBehavior: "sticky",
+    configuration: {
+      structure: "inline-classic",
+      treatment: "solid-neutral",
+      behavior: "sticky"
+    },
+    openingRequirement: "none",
+    compile: cleanBaseHeader
+  },
+  {
+    id: asHeaderLookId("brand-solid"),
+    label: "Brand solid",
+    visualTreatment: "solid-brand",
+    layoutBehavior: "sticky-shrink",
+    configuration: {
+      structure: "inline-classic",
+      treatment: "solid-brand",
+      behavior: "sticky-shrink"
+    },
+    openingRequirement: "none",
+    compile: solidBrandHeader
+  },
+  {
+    id: asHeaderLookId("serif-line"),
+    label: "Serif line",
+    visualTreatment: "light-serif",
+    layoutBehavior: "sticky",
+    configuration: {
+      structure: "centered-stack",
+      treatment: "light-serif",
+      behavior: "sticky"
+    },
+    openingRequirement: "none",
+    maxRecommendedNavItems: 6,
+    compile: serifLineHeader
+  },
+  {
+    id: asHeaderLookId("centered-calm"),
+    label: "Centered calm",
+    visualTreatment: "light-serif",
+    layoutBehavior: "normal-flow",
+    configuration: {
+      structure: "centered-stack",
+      treatment: "light-serif",
+      behavior: "normal-flow"
+    },
+    openingRequirement: "none",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal", "square"],
+    compile: centeredCalmHeader
+  },
+  {
+    id: asHeaderLookId("practical-utility"),
+    label: "Practical utility",
+    visualTreatment: "solid-neutral",
+    layoutBehavior: "sticky-shrink",
+    configuration: {
+      structure: "inline-classic",
+      treatment: "solid-neutral",
+      behavior: "sticky-shrink"
+    },
+    openingRequirement: "none",
+    requiresProminentCta: true,
+    compile: practicalUtilityHeader
+  },
+  {
+    id: asHeaderLookId("minimal-transparent"),
+    label: "Minimal transparent",
+    visualTreatment: "minimal-transparent",
+    layoutBehavior: "normal-flow",
+    configuration: {
+      structure: "inline-classic",
+      treatment: "minimal-transparent",
+      behavior: "normal-flow"
+    },
+    openingRequirement: "reserved-space-ok",
+    compile: minimalTransparentHeader
+  },
+  {
+    id: asHeaderLookId("transparent-overlay"),
+    label: "Transparent overlay",
+    visualTreatment: "transparent-overlay",
+    layoutBehavior: "fixed-overlay",
+    configuration: {
+      structure: "inline-classic",
+      treatment: "transparent-overlay",
+      behavior: "fixed-overlay"
+    },
+    openingRequirement: "requires-image-hero-with-contrast-overlay",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal"],
+    compile: transparentOverlayHeader
+  },
+  {
+    id: asHeaderLookId("floating-glass"),
+    label: "Floating glass",
+    visualTreatment: "floating-glass",
+    layoutBehavior: "fixed-floating",
+    configuration: {
+      structure: "floating-shell",
+      treatment: "floating-glass",
+      behavior: "fixed-floating"
+    },
+    openingRequirement: "requires-image-hero-with-contrast-overlay",
+    maxRecommendedNavItems: 5,
+    allowedLogoShapes: ["none", "text-only", "horizontal"],
+    compile: floatingGlassHeader
+  }
+];
+var guaranteedFallbackHeaderLookId = asHeaderLookId("clean-base");
+var guaranteedFallbackHeaderLayoutId = asHeaderLayoutId("classic");
+var guaranteedFallbackHeaderStyleId = asHeaderStyleId("minimal");
+var allowedHeaderConfigurationKeys = new Set(
+  headerLookCatalog.map((look) => headerConfigurationKey(look.configuration))
+);
+var headerLooksById = new Map(
+  headerLookCatalog.map((look) => [look.id, look])
+);
+function headerConfigurationKey(configuration) {
+  return `${configuration.structure}:${configuration.treatment}:${configuration.behavior}`;
+}
+
+// ../theme-core/src/site-styles/footerLooks.ts
+function asFooterLookId(value) {
+  return value;
+}
+var guaranteedFallbackFooterLookId = asFooterLookId("footer-muted-grounding");
+function mutedGroundingFooter(theme) {
+  return theme.footer;
+}
+function brandTwoBandFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "split",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "primary-800"
+    },
+    navStyle: "minimal",
+    navWeight: "medium",
+    navColor: "primaryForeground",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "medium",
+      textTransform: "none",
+      italic: false,
+      colorToken: "primaryForeground",
+      hoverColorToken: "secondary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    bottomTextLinkStyle: {
+      colorToken: "secondary",
+      decorationColorToken: "secondary"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "default",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: false,
+      placement: "left",
+      size: "sm",
+      align: "start"
+    },
+    bottomBar: {
+      enabled: true,
+      fullBleed: true,
+      background: {
+        type: "color",
+        color: "primary-900"
+      },
+      textColor: "primaryForeground",
+      textAlign: "center",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "none"
+      }
+    }
+  };
+}
+var footerLookCatalog = [
+  {
+    id: asFooterLookId("footer-muted-grounding"),
+    label: "Muted grounding footer",
+    compile: mutedGroundingFooter
+  },
+  {
+    id: asFooterLookId("site-footer-brand-two-band"),
+    label: "Two-band brand footer",
+    maxRecommendedNavDensity: "balanced",
+    allowedContentPresence: ["default-footer", "default-and-blocks"],
+    compile: brandTwoBandFooter
+  }
+];
+var footerLooksById = new Map(
+  footerLookCatalog.map((look) => [look.id, look])
+);
+
+// ../theme-core/src/site-styles/sourceCatalogs.ts
+var generatedContentFrames = [
+  plainFrame,
+  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", "brand-depth-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/typographyPresets.ts
+var bodyReadablePolicy = {
+  recommendedCategories: ["sans-serif", "serif"],
+  allowedCategories: ["sans-serif", "serif"],
+  requiresItalicForBody: true,
+  requiresBoldForBody: true
+};
+var headingFlexiblePolicy = {
+  recommendedCategories: ["sans-serif", "serif", "display"],
+  allowedCategories: ["sans-serif", "serif", "display"]
+};
+var displayHeadingPolicy = {
+  recommendedCategories: ["display", "sans-serif", "serif"],
+  allowedCategories: ["display", "sans-serif", "serif"]
+};
+function asTypographyPresetId(value) {
+  if (!value.startsWith("typography-preset:")) {
+    throw new Error(`TypographyPresetId must start with "typography-preset:". Received: ${value}`);
+  }
+  return value;
+}
+function defineTypographyPreset(preset) {
+  return {
+    ...preset,
+    id: asTypographyPresetId(preset.id)
+  };
+}
+var modernSansTypography = {
+  body: {
+    family: "Inter, system-ui, sans-serif",
+    size: "md",
+    weight: "regular",
+    lineHeight: "relaxed",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: "Inter, system-ui, sans-serif",
+      weight: "semibold",
+      lineHeight: "normal",
+      letterSpacing: "tight",
+      italic: null,
+      case: null
+    },
+    h1: { size: "xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h2: { size: "lg", weight: "semibold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h3: { size: "md", weight: "semibold", lineHeight: "normal", letterSpacing: "normal", italic: null }
+  },
+  scale: "balanced"
+};
+var warmRoundedTypography = {
+  body: {
+    family: "Nunito Sans, system-ui, sans-serif",
+    size: "lg",
+    weight: "regular",
+    lineHeight: "relaxed",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: "Nunito Sans, system-ui, sans-serif",
+      weight: "bold",
+      lineHeight: "normal",
+      letterSpacing: "normal",
+      italic: null,
+      case: null
+    },
+    h1: { size: "xl", weight: "bold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h2: { size: "lg", weight: "bold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h3: { size: "md", weight: "semibold", lineHeight: "relaxed", letterSpacing: "normal", italic: null }
+  },
+  scale: "balanced"
+};
+var editorialSerifTypography = {
+  body: {
+    family: "Lora, Georgia, serif",
+    size: "lg",
+    weight: "regular",
+    lineHeight: "loose",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: "Playfair Display, Georgia, serif",
+      weight: "semibold",
+      lineHeight: "normal",
+      letterSpacing: "tight",
+      italic: null,
+      case: null
+    },
+    h1: { size: "2xl", weight: "semibold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h2: { size: "xl", weight: "semibold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h3: { size: "md", weight: "semibold", lineHeight: "relaxed", letterSpacing: "normal", italic: true }
+  },
+  scale: "spacious"
+};
+var classicSerifTypography = {
+  body: {
+    family: "Libre Baskerville, Georgia, serif",
+    size: "md",
+    weight: "regular",
+    lineHeight: "relaxed",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: "Cormorant Garamond, Georgia, serif",
+      weight: "semibold",
+      lineHeight: "normal",
+      letterSpacing: "normal",
+      italic: null,
+      case: null
+    },
+    h1: { size: "2xl", weight: "semibold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h2: { size: "xl", weight: "semibold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h3: { size: "md", weight: "medium", lineHeight: "relaxed", letterSpacing: "normal", italic: null }
+  },
+  scale: "balanced"
+};
+var luxeContrastTypography = {
+  body: {
+    family: "Manrope, system-ui, sans-serif",
+    size: "md",
+    weight: "regular",
+    lineHeight: "relaxed",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: "Cormorant Garamond, Georgia, serif",
+      weight: "semibold",
+      lineHeight: "normal",
+      letterSpacing: "tight",
+      italic: null,
+      case: null
+    },
+    h1: { size: "2xl", weight: "semibold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h2: { size: "xl", weight: "semibold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h3: { size: "md", weight: "medium", lineHeight: "relaxed", letterSpacing: "normal", italic: null }
+  },
+  scale: "spacious"
+};
+var boldDisplayTypography = {
+  body: {
+    family: "Manrope, system-ui, sans-serif",
+    size: "lg",
+    weight: "regular",
+    lineHeight: "relaxed",
+    letterSpacing: "normal"
+  },
+  headings: {
+    default: {
+      family: '"TAN - PEARL", sans-serif',
+      weight: "bold",
+      lineHeight: "normal",
+      letterSpacing: "tight",
+      colorToken: "primary",
+      italic: null,
+      case: null
+    },
+    h1: { size: "xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
+    h2: { size: "lg", weight: "bold", lineHeight: "normal", letterSpacing: "normal", italic: null },
+    h3: { size: "md", weight: "bold", lineHeight: "normal", letterSpacing: "normal", italic: null }
+  },
+  scale: "balanced"
+};
+var typographyPresets = [
+  defineTypographyPreset({
+    id: "typography-preset:modern-sans",
+    name: "Modern Sans",
+    description: "Crisp, neutral type for clear service pages and practical editorial structure.",
+    defaultFonts: { body: "Inter, system-ui, sans-serif", heading: "Inter, system-ui, sans-serif" },
+    recommendedFonts: {
+      body: ["Inter", "Source Sans 3", "IBM Plex Sans"],
+      heading: ["Inter", "Manrope", "Source Sans 3"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: headingFlexiblePolicy },
+    typography: modernSansTypography
+  }),
+  defineTypographyPreset({
+    id: "typography-preset:warm-rounded",
+    name: "Warm Rounded",
+    description: "Soft, friendly type for welcoming studios, classes, and community businesses.",
+    defaultFonts: { body: "Nunito Sans, system-ui, sans-serif", heading: "Nunito Sans, system-ui, sans-serif" },
+    recommendedFonts: {
+      body: ["Nunito Sans", "Atkinson Hyperlegible", "Lato"],
+      heading: ["Nunito Sans", "Quicksand", "Manrope"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: headingFlexiblePolicy },
+    typography: warmRoundedTypography
+  }),
+  defineTypographyPreset({
+    id: "typography-preset:editorial-serif",
+    name: "Editorial Serif",
+    description: "Story-led type with warm reading rhythm and expressive headings.",
+    defaultFonts: { body: "Lora, Georgia, serif", heading: "Playfair Display, Georgia, serif" },
+    recommendedFonts: {
+      body: ["Lora", "Source Serif 4", "Libre Baskerville"],
+      heading: ["Playfair Display", "Cormorant Garamond", "Fraunces"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+    typography: editorialSerifTypography
+  }),
+  defineTypographyPreset({
+    id: "typography-preset:classic-serif",
+    name: "Classic Serif",
+    description: "Measured, polished type for premium and established offers.",
+    defaultFonts: { body: "Libre Baskerville, Georgia, serif", heading: "Cormorant Garamond, Georgia, serif" },
+    recommendedFonts: {
+      body: ["Libre Baskerville", "Source Serif 4", "Lora"],
+      heading: ["Cormorant Garamond", "Playfair Display", "Libre Baskerville"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+    typography: classicSerifTypography
+  }),
+  defineTypographyPreset({
+    id: "typography-preset:luxe-contrast",
+    name: "Luxe Contrast",
+    description: "A restrained sans body paired with elegant high-contrast headings.",
+    defaultFonts: { body: "Manrope, system-ui, sans-serif", heading: "Cormorant Garamond, Georgia, serif" },
+    recommendedFonts: {
+      body: ["Manrope", "Inter", "Source Sans 3"],
+      heading: ["Cormorant Garamond", "Playfair Display", "Bodoni Moda"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+    typography: luxeContrastTypography
+  }),
+  defineTypographyPreset({
+    id: "typography-preset:bold-display",
+    name: "Bold Display",
+    description: "Punchy display headings with readable sans body copy for branded launches.",
+    defaultFonts: { body: "Manrope, system-ui, sans-serif", heading: '"TAN - PEARL", sans-serif' },
+    recommendedFonts: {
+      body: ["Manrope", "Inter", "Space Grotesk"],
+      heading: ["Anton", "Bebas Neue", "Archivo Black"]
+    },
+    slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+    typography: boldDisplayTypography,
+    heroTypography: {
+      headlineSize: "6xl",
+      headlineLineHeight: "tight",
+      subheadlineSize: "2xl",
+      subheadlineLineHeight: "normal",
+      microHeadlineSize: "6xl",
+      microHeadlineLineHeight: "tight",
+      microSubheadlineSize: "xl",
+      microSubheadlineLineHeight: "normal",
+      responsive: {
+        tablet: { headlineSize: "5xl" },
+        mobile: { headlineSize: "4xl", subheadlineSize: "xl" }
+      }
+    }
+  })
+];
+var typographyPresetsById = new Map(
+  typographyPresets.map((preset) => [preset.id, preset])
+);
+
+// ../theme-core/src/site-styles/curatedSiteStyles.ts
+var SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
+var SOFT_EARTH_SITE_STYLE_ID = asSiteStyleId(SOFT_EARTH_SITE_STYLE_ID_VALUE);
+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"
+};
+var expressiveUnderlineInputs = {
+  base: {
+    background: { type: "transparent" },
+    textColorToken: "text",
+    border: {
+      widthClass: "border-2",
+      colorToken: "border",
+      style: "underline"
+    },
+    corners: "square",
+    shadow: null,
+    spacing: "compact",
+    fontSize: "base"
+  },
+  label: {
+    textColorToken: "primary",
+    fontWeight: "black",
+    fontSize: "xs",
+    textTransform: "uppercase",
+    letterSpacing: "widest",
+    opacity: 1
+  },
+  focus: {
+    ringColorToken: "secondary",
+    ringWidth: "0",
+    borderColorToken: "secondary"
+  },
+  error: {
+    borderColorToken: "destructive",
+    textColorToken: "destructive"
+  },
+  disabled: {
+    backgroundColorToken: "surface",
+    textColorToken: "text",
+    opacity: 0.6
+  }
+};
+function uniqueContentFrameKinds() {
+  const kinds = [
+    ...new Set(
+      generatedDesignOptionCatalog.contentFrames.map((frame) => frame.kind)
+    )
+  ];
+  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) {
+  const legacyHeaderLookIds = input.recommendedHeaderLookIds ?? ["clean-base"];
+  const inferredHeaderCuration = inferHeaderCurationFromLegacyLooks(
+    legacyHeaderLookIds,
+    input.tokenRecipes
+  );
+  const typographyPresetChoices = input.typographyPresetChoices ?? defaultTypographyPresetChoicesForRecipe(input.tokenRecipes.typography);
+  const defaultTypographyPresetId = input.defaultTypographyPresetId ? asTypographyPresetId(input.defaultTypographyPresetId) : typographyPresetChoices[0].id;
+  if (!typographyPresetChoices.some(
+    (choice) => choice.id === defaultTypographyPresetId
+  )) {
+    throw new Error(
+      `Default typography preset ${defaultTypographyPresetId} is not curated for site style ${input.id}.`
+    );
+  }
+  return {
+    id: asSiteStyleId(input.id),
+    name: input.name,
+    description: input.description,
+    generationBrief: input.generationBrief,
+    selectionKeywordRules: input.selectionKeywordRules ?? [],
+    siteCreatorSelection: input.siteCreatorSelection ?? {
+      kind: "explicit_only"
+    },
+    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
+    },
+    ...input.themeOverrides ? { themeOverrides: input.themeOverrides } : {},
+    ...input.defaultBlockVariants ? { defaultBlockVariants: input.defaultBlockVariants } : {},
+    recommendedAppearancePresetIds: (input.recommendedAppearancePresetIds ?? []).map(asAppearancePresetId),
+    defaultHeaderSelection: input.defaultHeaderSelection ? {
+      layoutId: asHeaderLayoutId(input.defaultHeaderSelection.layoutId),
+      styleId: asHeaderStyleId(input.defaultHeaderSelection.styleId)
+    } : inferredHeaderCuration.defaultHeaderSelection,
+    recommendedHeaderLayoutChoices: input.recommendedHeaderLayoutChoices ?? inferredHeaderCuration.recommendedHeaderLayoutChoices,
+    recommendedHeaderStyleChoicesByLayout: input.recommendedHeaderStyleChoicesByLayout ?? inferredHeaderCuration.recommendedHeaderStyleChoicesByLayout,
+    discouragedHeaderSelections: input.discouragedHeaderSelections?.map(
+      (selection) => ({
+        layoutId: asHeaderLayoutId(selection.layoutId),
+        styleId: asHeaderStyleId(selection.styleId)
+      })
+    ),
+    recommendedHeaderLookIds: legacyHeaderLookIds.map(asHeaderLookId),
+    // Empty is intentional: resolveFooterLook always appends its guaranteed fallback.
+    recommendedFooterLookIds: (input.recommendedFooterLookIds ?? []).map(
+      asFooterLookId
+    ),
+    buttonPersonalityChoices: input.buttonPersonalityChoices,
+    paletteVariantChoices: input.paletteVariantChoices,
+    typographyPresetChoices,
+    defaultTypographyPresetId
+  };
+}
+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) };
+}
+function headerLayoutChoice(id, note) {
+  return note ? { id: asHeaderLayoutId(id), note } : { id: asHeaderLayoutId(id) };
+}
+function headerStyleChoice(id, note) {
+  return note ? { id: asHeaderStyleId(id), note } : { id: asHeaderStyleId(id) };
+}
+function unbrandHeaderLayoutId(id) {
+  return id;
+}
+function uniqueHeaderLayoutChoices(choices) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = choices.filter((choice) => {
+    if (seen.has(choice.id)) return false;
+    seen.add(choice.id);
     return true;
+  });
+  const first = unique[0];
+  if (!first) {
+    throw new Error("Expected at least one curated header layout choice.");
   }
-  const parts = normalized.split(",");
-  for (const part of parts) {
-    if (isForbiddenSelectorPart(part)) {
-      return true;
-    }
-  }
-  return false;
+  return [first, ...unique.slice(1)];
 }
-var selectorSchema = z9.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" }
-);
-function containsRemoteUrl(value) {
-  return REMOTE_URL_PATTERN.test(value);
+function nonEmptyHeaderStyleChoices(choices, fallbackLayoutId) {
+  const first = choices[0] ?? {
+    id: getCompatibleHeaderStyleIds(fallbackLayoutId)[0] ?? asHeaderStyleId("minimal")
+  };
+  return [first, ...choices.slice(1)];
+}
+function uniqueCompatibleHeaderStyleChoices(choices, fallbackLayoutId) {
+  const compatible = new Set(getCompatibleHeaderStyleIds(fallbackLayoutId));
+  const seen = /* @__PURE__ */ new Set();
+  const unique = choices.filter((choice) => {
+    if (!compatible.has(choice.id)) return false;
+    if (seen.has(choice.id)) return false;
+    seen.add(choice.id);
+    return true;
+  });
+  return nonEmptyHeaderStyleChoices(unique, fallbackLayoutId);
+}
+function inferredHeaderStyleValuesForRecipes(layoutId, recipes) {
+  switch (layoutId) {
+    case "classic":
+      if (isExpressiveRecipe(recipes)) {
+        return [
+          "brand-bar",
+          "brand-underline",
+          "flat-tabs",
+          "brand-pill",
+          "fine-line"
+        ];
+      }
+      if (recipes.spacing === "compact") {
+        return ["flat-tabs", "fine-line", "minimal", "brand-bar"];
+      }
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["serif-line", "fine-line", "minimal", "soft-bar"];
+      }
+      if (recipes.radius === "rounded" || recipes.radius === "pill") {
+        return ["soft-bar", "pill-nav", "fine-line", "minimal"];
+      }
+      return ["fine-line", "minimal", "soft-bar", "brand-bar"];
+    case "centered":
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["serif-line", "fine-line", "minimal", "soft-bar"];
+      }
+      if (isExpressiveRecipe(recipes)) {
+        return ["brand-pill", "flat-tabs", "brand-bar", "fine-line"];
+      }
+      if (recipes.radius === "rounded" || recipes.radius === "pill") {
+        return ["soft-bar", "pill-nav", "fine-line", "minimal"];
+      }
+      return ["minimal", "fine-line", "soft-bar"];
+    case "floating":
+      if (isExpressiveRecipe(recipes)) {
+        return ["glass", "split-glass", "brand-pill", "soft-shell"];
+      }
+      if (isSerifTypographyRecipe(recipes)) {
+        return ["split-pill", "minimal-surface", "soft-shell"];
+      }
+      return ["soft-shell", "minimal-surface", "glass"];
+    default:
+      return [];
+  }
 }
-function containsJavascriptUrl(value) {
-  return JAVASCRIPT_URL_PATTERN.test(value);
+function isExpressiveRecipe(recipes) {
+  return recipes.contrast === "maximum" || recipes.shadow === "layered" || recipes.motion === "expressive";
 }
-var declarationValueSchema = z9.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 = z9.record(
-  z9.string().min(1).max(100),
-  // property name
-  declarationValueSchema
-  // property value
-);
-var customCssRuleSchema = z9.object({
-  id: z9.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
-  selector: selectorSchema,
-  declarations: declarationsSchema
-});
-var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z9.string().min(1, "Block kind is required").max(50, "Block kind too long")
-});
-var customCssRulesSchema = z9.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z9.array(blockCustomCssRuleSchema).optional();
-
-// ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z10 } 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 = z10.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z10.object({
-  selector: selectorSchema,
-  declarations: declarationsSchema
-});
-function isValidKeyframeOffset(offset) {
-  const trimmed = offset.trim().toLowerCase();
-  if (trimmed === "from" || trimmed === "to") return true;
-  const match = trimmed.match(/^(\d{1,3})%$/);
-  if (!match || match[1] === void 0) return false;
-  const value = parseInt(match[1], 10);
-  return value >= 0 && value <= 100;
+function isSerifTypographyRecipe(recipes) {
+  return recipes.typography === "serif-editorial" || recipes.typography === "classic-serif";
 }
-var keyframeOffsetSchema = z10.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 = z10.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 = z10.object({
-  offset: keyframeOffsetSchema,
-  declarations: declarationsSchema
-});
-var keyframesAtRuleSchema = z10.object({
-  id: ruleIdSchema,
-  type: z10.literal("keyframes"),
-  name: animationNameSchema,
-  frames: z10.array(keyframeSchema).min(1, "At least one keyframe is required")
-});
-var fontFaceDeclarationsSchema = z10.record(z10.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 = z10.object({
-  id: ruleIdSchema,
-  type: z10.literal("font-face"),
-  declarations: fontFaceDeclarationsSchema
-});
-var mediaQuerySchema = z10.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z10.object({
-  id: ruleIdSchema,
-  type: z10.literal("media"),
-  query: mediaQuerySchema,
-  rules: z10.array(nestedRuleSchema).min(1, "At least one rule is required")
-});
-var supportsConditionSchema = z10.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z10.object({
-  id: ruleIdSchema,
-  type: z10.literal("supports"),
-  condition: supportsConditionSchema,
-  rules: z10.array(nestedRuleSchema).min(1, "At least one rule is required")
-});
-function containsBlockedAtRule(css) {
-  return BLOCKED_AT_RULE_PATTERN.test(css);
+function inferHeaderCurationFromLegacyLooks(lookIds, recipes) {
+  const selections = lookIds.map((lookId) => resolveLegacyHeaderLookAlias(asHeaderLookId(lookId))).filter(
+    (selection) => Boolean(selection)
+  );
+  const defaultHeaderSelection = selections[0] ?? {
+    layoutId: asHeaderLayoutId("classic"),
+    styleId: asHeaderStyleId("minimal")
+  };
+  const layoutChoices = uniqueHeaderLayoutChoices(
+    selections.map((selection) => headerLayoutChoice(selection.layoutId))
+  );
+  const stylesByLayout = {};
+  for (const layoutChoice of layoutChoices) {
+    const legacyStyleChoices = selections.filter((selection) => selection.layoutId === layoutChoice.id).map((selection) => headerStyleChoice(selection.styleId));
+    const inferredStyleChoices = inferredHeaderStyleValuesForRecipes(
+      layoutChoice.id,
+      recipes
+    ).map((styleId) => headerStyleChoice(styleId));
+    stylesByLayout[unbrandHeaderLayoutId(layoutChoice.id)] = uniqueCompatibleHeaderStyleChoices(
+      [...legacyStyleChoices, ...inferredStyleChoices],
+      layoutChoice.id
+    );
+  }
+  return {
+    defaultHeaderSelection,
+    recommendedHeaderLayoutChoices: layoutChoices,
+    recommendedHeaderStyleChoicesByLayout: stylesByLayout
+  };
 }
-var rawCssSchema = z10.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.` }
+function typographyChoice(id, note) {
+  return note ? { id: asTypographyPresetId(id), note } : { id: asTypographyPresetId(id) };
+}
+function defaultTypographyPresetChoicesForRecipe(recipe) {
+  switch (recipe) {
+    case "clean-sans":
+      return [
+        typographyChoice("typography-preset:modern-sans"),
+        typographyChoice("typography-preset:luxe-contrast"),
+        typographyChoice("typography-preset:bold-display")
+      ];
+    case "friendly-sans":
+      return [
+        typographyChoice("typography-preset:warm-rounded"),
+        typographyChoice("typography-preset:modern-sans"),
+        typographyChoice("typography-preset:editorial-serif")
+      ];
+    case "serif-editorial":
+      return [
+        typographyChoice("typography-preset:editorial-serif"),
+        typographyChoice("typography-preset:classic-serif"),
+        typographyChoice("typography-preset:warm-rounded")
+      ];
+    case "classic-serif":
+      return [
+        typographyChoice("typography-preset:classic-serif"),
+        typographyChoice("typography-preset:luxe-contrast"),
+        typographyChoice("typography-preset:editorial-serif")
+      ];
+  }
+}
+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,
+    recommendedHeaderLookIds: [
+      "centered-calm",
+      "minimal-transparent",
+      "clean-base"
+    ],
+    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,
+    recommendedHeaderLookIds: [
+      "practical-utility",
+      "brand-solid",
+      "clean-base"
+    ],
+    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,
+    recommendedHeaderLookIds: [
+      "serif-line",
+      "minimal-transparent",
+      "centered-calm"
+    ],
+    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,
+    recommendedHeaderLookIds: [
+      "brand-solid",
+      "practical-utility",
+      "clean-base"
+    ],
+    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.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 20
+    },
+    selectionKeywordRules: [
+      { kind: "word", value: "luxury" },
+      { kind: "word", value: "premium" },
+      { kind: "word", value: "boutique" },
+      { kind: "word", value: "bespoke" },
+      { kind: "word", value: "exclusive" }
+    ],
+    tokenRecipes: {
+      palette: "high-contrast",
+      contrast: "strong",
+      radius: "square",
+      shadow: "none",
+      typography: "classic-serif",
+      spacing: "airy",
+      motion: "none"
+    },
+    compositionBudget: quietBudget,
+    recommendedHeaderLookIds: [
+      "minimal-transparent",
+      "serif-line",
+      "clean-base"
+    ],
+    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.",
+    siteCreatorSelection: { kind: "primary_goal_support" },
+    selectionKeywordRules: [
+      { kind: "word", value: "repair" },
+      { kind: "substring", value: "plumb" },
+      { kind: "substring", value: "electric" },
+      { kind: "word", value: "cleaning" },
+      { kind: "substring", value: "landscap" },
+      { kind: "substring", value: "contractor" }
+    ],
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "maximum",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "compact",
+      motion: "none"
+    },
+    compositionBudget: quietBudget,
+    recommendedHeaderLookIds: [
+      "practical-utility",
+      "brand-solid",
+      "clean-base"
+    ],
+    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,
+    recommendedHeaderLookIds: [
+      "centered-calm",
+      "minimal-transparent",
+      "clean-base"
+    ],
+    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:quiet-practice",
+    name: "Quiet Practice",
+    description: "Grounded, calm, and practical for small appointment-first practices.",
+    generationBrief: "Make services, practitioner trust, preparation notes, and booking routes easy to scan. Keep the tone warm and specific, with quiet confidence rather than spa cliches or medical claims.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 30
+    },
+    selectionKeywordRules: [
+      { kind: "substring", value: "massage" },
+      { kind: "word", value: "bodywork" },
+      { kind: "phrase", value: "appointment practice" },
+      { kind: "phrase", value: "appointment-first" },
+      { kind: "substring", value: "practitioner" },
+      { kind: "substring", value: "therap" },
+      { kind: "substring", value: "clinic" },
+      { kind: "phrase", value: "wellness practice" }
+    ],
+    tokenRecipes: {
+      palette: "soft-natural",
+      contrast: "standard",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "regular",
+      motion: "subtle"
+    },
+    compositionBudget: quietBudget,
+    recommendedHeaderLookIds: [
+      "practical-utility",
+      "clean-base",
+      "centered-calm"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("pebble"),
+      buttonChoice("soft-pill"),
+      buttonChoice("editorial-link")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("soft-natural-stone"),
+      paletteChoice("soft-natural-sage"),
+      paletteChoice("warm-neutral-clay")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:personal-retreat-journal",
+    name: "Personal Retreat Journal",
+    description: "Warm, story-led, and readable for solo practitioners with mixed offers.",
+    generationBrief: "Center the practitioner as the guide, then make private sessions, classes, retreats, and resources feel like clear pathways. Keep retreat copy grounded and practical, with enough editorial warmth for longer reading.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 40
+    },
+    selectionKeywordRules: [
+      { kind: "substring", value: "retreat" },
+      { kind: "phrase", value: "solo practitioner" },
+      { kind: "phrase", value: "personal brand" },
+      { kind: "substring", value: "teacher" },
+      { kind: "substring", value: "coach" },
+      { kind: "phrase", value: "retreat resources" },
+      { kind: "substring", value: "journal" }
+    ],
+    tokenRecipes: {
+      palette: "warm-neutral",
+      contrast: "standard",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "serif-editorial",
+      spacing: "airy",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: [
+      "serif-line",
+      "centered-calm",
+      "minimal-transparent"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("editorial-link"),
+      buttonChoice("soft-pill"),
+      buttonChoice("brushed-wash")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("warm-neutral-forest"),
+      paletteChoice("warm-neutral-clay"),
+      paletteChoice("soft-natural-stone")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:tactile-workshop",
+    name: "Tactile Workshop",
+    description: "Bright, hands-on, and image-led for maker studios, workshops, and creative classes.",
+    generationBrief: "Lead with objects, materials, studio process, and practical booking detail. Keep the tone warm and direct, with useful mess, clear dates, and enough gallery rhythm to feel like a real creative studio.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 50
+    },
+    selectionKeywordRules: [
+      { kind: "substring", value: "ceramic" },
+      { kind: "word", value: "pottery" },
+      { kind: "phrase", value: "maker studio" },
+      { kind: "phrase", value: "craft class" },
+      { kind: "phrase", value: "craft workshop" },
+      { kind: "word", value: "clay" },
+      { kind: "word", value: "kiln" }
+    ],
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "standard",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "friendly-sans",
+      spacing: "regular",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    recommendedHeaderLookIds: [
+      "brand-solid",
+      "practical-utility",
+      "clean-base"
+    ],
+    recommendedFooterLookIds: [
+      "site-footer-brand-two-band",
+      "footer-muted-grounding"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("pebble"),
+      buttonChoice("confident-chip"),
+      buttonChoice("ink-stamp"),
+      buttonChoice("editorial-link")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("brand-led-warm"),
+      paletteChoice("brand-led-cool"),
+      paletteChoice("soft-natural-watercolor"),
+      paletteChoice("warm-neutral-clay")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: SOFT_EARTH_SITE_STYLE_ID,
+    name: "Soft Earth",
+    description: "Warm, grounded, and editorial for yoga studios, retreats, and wellbeing communities.",
+    generationBrief: "Use cream space, terracotta CTAs, olive quote bands, natural imagery, generous but composed spacing, and editorial serif headings. Prefer a real intro section, image-led offering cards, warm community quotes, and an FAQ with a full-width intro above two columns of questions when content allows.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 45
+    },
+    selectionKeywordRules: [
+      { kind: "word", value: "meditation" },
+      { kind: "word", value: "wellbeing" },
+      { kind: "substring", value: "retreat" },
+      { kind: "phrase", value: "yoga studio" },
+      { kind: "phrase", value: "mindful movement" }
+    ],
+    tokenRecipes: {
+      palette: "warm-neutral",
+      contrast: "standard",
+      radius: "soft",
+      shadow: "subtle",
+      typography: "serif-editorial",
+      spacing: "airy",
+      motion: "subtle"
+    },
+    compositionBudget: balancedBudget,
+    themeOverrides: {
+      typography: {
+        body: {
+          family: "Inter, system-ui, sans-serif",
+          size: "md",
+          weight: "regular",
+          lineHeight: "relaxed",
+          letterSpacing: "normal"
+        },
+        headings: {
+          default: {
+            family: '"Cormorant Garamond", Georgia, serif',
+            weight: "regular",
+            lineHeight: "normal",
+            letterSpacing: "normal",
+            colorToken: "text",
+            italic: null,
+            case: null
+          },
+          h1: {
+            size: "xl",
+            weight: "regular",
+            lineHeight: "normal",
+            letterSpacing: "normal",
+            italic: null
+          },
+          h2: {
+            size: "lg",
+            weight: "regular",
+            lineHeight: "normal",
+            letterSpacing: "normal",
+            italic: null
+          },
+          h3: {
+            size: "md",
+            weight: "regular",
+            lineHeight: "normal",
+            letterSpacing: "normal",
+            italic: null
+          }
+        },
+        scale: "majorThird"
+      },
+      bodyText: {
+        intro: {
+          paragraphSize: "default",
+          headingSize: "editorial"
+        }
+      },
+      accordions: softEarthAccordionSystem
+    },
+    defaultBlockVariants: {
+      "block.faq": "question-columns"
+    },
+    recommendedAppearancePresetIds: [
+      "hero-brand-scrim",
+      "intro-organic-statement",
+      "feature-cards-raised-rule",
+      "events-lined-panel",
+      "testimonials-brand-background-quotes",
+      "contact-form-panel"
+    ],
+    recommendedHeaderLookIds: [
+      "centered-calm",
+      "minimal-transparent",
+      "serif-line"
+    ],
+    recommendedFooterLookIds: [
+      "footer-muted-grounding",
+      "site-footer-brand-two-band"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("earth-pill"),
+      buttonChoice("soft-pill"),
+      buttonChoice("pebble"),
+      buttonChoice("editorial-link")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("warm-neutral-soft-earth"),
+      paletteChoice("warm-neutral-clay"),
+      paletteChoice("warm-neutral-forest"),
+      paletteChoice("soft-natural-sage")
+    ]
+  }),
+  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.",
+    siteCreatorSelection: {
+      kind: "site_creator_keyword_heuristic",
+      priority: 10
+    },
+    selectionKeywordRules: [
+      { kind: "substring", value: "launch" },
+      { kind: "substring", value: "campaign" },
+      { kind: "word", value: "preorder" },
+      { kind: "phrase", value: "pre-order" },
+      { kind: "substring", value: "waitlist" },
+      { kind: "word", value: "drop" }
+    ],
+    tokenRecipes: {
+      palette: "high-contrast",
+      contrast: "maximum",
+      radius: "pill",
+      shadow: "layered",
+      typography: "clean-sans",
+      spacing: "regular",
+      motion: "expressive"
+    },
+    compositionBudget: expressiveBudget,
+    recommendedHeaderLookIds: [
+      "transparent-overlay",
+      "floating-glass",
+      "brand-solid"
+    ],
+    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")
+    ]
+  }),
+  defineCuratedSiteStyle({
+    id: "site-style:south-west-twerk-school",
+    name: "South West Twerk School",
+    description: "Energetic, editorial, and high-contrast for a branded dance school presence.",
+    generationBrief: "Use confident rhythm, bold burgundy-and-gold accents, large editorial intro copy, strong booking routes, and dark feature sections where proof or forms need emphasis.",
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "maximum",
+      radius: "soft",
+      shadow: "layered",
+      typography: "clean-sans",
+      spacing: "airy",
+      motion: "expressive"
+    },
+    compositionBudget: expressiveBudget,
+    typographyPresetChoices: [
+      typographyChoice("typography-preset:bold-display"),
+      typographyChoice("typography-preset:modern-sans"),
+      typographyChoice("typography-preset:luxe-contrast")
+    ],
+    defaultTypographyPresetId: "typography-preset:bold-display",
+    themeOverrides: {
+      bodyText: {
+        intro: {
+          paragraphSize: "editorial",
+          headingSize: "editorial"
+        }
+      },
+      inputs: expressiveUnderlineInputs
+    },
+    recommendedAppearancePresetIds: [
+      "hero-brand-scrim-fixed-frame",
+      "body-text-editorial-intro",
+      "schedule-details-brand-depth",
+      "testimonials-accent-quote-cards",
+      "contact-form-brand-depth-card"
+    ],
+    recommendedHeaderLookIds: [
+      "brand-solid",
+      "transparent-overlay",
+      "practical-utility"
+    ],
+    recommendedFooterLookIds: [
+      "site-footer-brand-two-band",
+      "footer-muted-grounding"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("showtime-pill"),
+      buttonChoice("confident-chip"),
+      buttonChoice("ink-stamp"),
+      buttonChoice("brushed-wash")
+    ],
+    paletteVariantChoices: [
+      paletteChoice("brand-led-burgundy-gold"),
+      paletteChoice("brand-led-jewel"),
+      paletteChoice("brand-led-warm"),
+      paletteChoice("high-contrast-ink")
+    ]
+  })
+];
+var curatedSiteStylesById = new Map(
+  curatedSiteStyles.map((style) => [style.id, style])
 );
-var rawAtRuleSchema = z10.object({
-  id: ruleIdSchema,
-  type: z10.literal("raw"),
-  css: rawCssSchema
-});
-var customCssAtRuleSchema = z10.discriminatedUnion("type", [
-  keyframesAtRuleSchema,
-  fontFaceAtRuleSchema,
-  mediaAtRuleSchema,
-  supportsAtRuleSchema,
-  rawAtRuleSchema
-]);
-var customCssAtRulesSchema = z10.array(customCssAtRuleSchema).optional();
-
-// ../theme-core/src/shared/componentStyles.ts
-import { z as z11 } from "zod";
-var componentBorderSchema = z11.object({
-  width: z11.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z11.enum(["solid", "dashed"]).default("solid"),
-  colorToken: themeColorTokenSchema.optional()
-  // defaults to "border" if not set
-});
-var componentShadowSchema = z11.object({
-  elevation: z11.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
-});
 
 // ../theme-core/src/responsive/breakpoints.ts
 var BREAKPOINT_SM = 640;
@@ -6299,8 +9640,8 @@ function AltchaWidget({
       }));
       containerRef.current.appendChild(widget);
       setIsLoaded(true);
-    }).catch((err2) => {
-      console.error("Failed to load ALTCHA widget:", err2);
+    }).catch((err) => {
+      console.error("Failed to load ALTCHA widget:", err);
     });
     return () => {
       if (widget && containerRef.current) {
@@ -6540,10 +9881,10 @@ function useAvailableDates({
           start: append && prev ? prev.start : data.startDate,
           end: data.endDate
         }));
-      } catch (err2) {
+      } catch (err) {
         if (requestId !== requestIdRef.current) return;
         setError(
-          err2 instanceof Error ? err2.message : "Failed to load available dates"
+          err instanceof Error ? err.message : "Failed to load available dates"
         );
       } finally {
         if (mode === "refresh" && requestId === requestIdRef.current) {
@@ -6572,7 +9913,7 @@ function useAvailableDates({
     const endDate = formatLocalScheduleDate(
       addLocalScheduleDays(parseBookingLocalDate(today), initialDays)
     );
-    fetchDates(today, endDate, false);
+    void fetchDates(today, endDate, false);
   }, [serviceId, fetchDates, initialDays]);
   useVisibleTabPolling({
     enabled: Boolean(serviceId && loadedRange),
@@ -6592,7 +9933,7 @@ function useAvailableDates({
         BOOKING_FETCH_CHUNK_DAYS
       )
     );
-    fetchDates(start, end, true);
+    void fetchDates(start, end, true);
   }, [fetchDates, isLoading]);
   return {
     availableDates,
@@ -6655,14 +9996,14 @@ function useAvailableSlots({
         setSlots(
           result.slots.map((slot) => ({
             ...slot,
-            resourceId: asAppointmentResourceId(slot.resourceId)
+            resourceId: unsafeAsAppointmentResourceId(slot.resourceId)
           }))
         );
         setHasLoaded(true);
-      } catch (err2) {
+      } catch (err) {
         if (requestId !== requestIdRef.current) return;
         setError(
-          err2 instanceof Error ? err2.message : "Failed to load available times"
+          err instanceof Error ? err.message : "Failed to load available times"
         );
       } finally {
         if (mode === "refresh" && requestId === requestIdRef.current) {
@@ -6701,28 +10042,24 @@ function bookingSubmissionReducer(state, action) {
   switch (action.type) {
     case "submission-started":
       return {
-        ...state,
-        status: { tag: "submitting" },
-        feedback: { tag: "idle" }
+        ...clearWorkflowFeedback(state),
+        status: { tag: "submitting" }
       };
     case "submission-succeeded":
       return {
         status: { tag: "idle" },
-        feedback: { tag: "success", message: action.message }
+        feedback: reportWorkflowSuccess(state, action.message).feedback
       };
     case "submission-failed":
     case "issue-reported":
       return {
         status: { tag: "idle" },
-        feedback: { tag: "error", message: action.message }
+        feedback: reportWorkflowError(state, action.message).feedback
       };
     case "feedback-cleared":
-      return {
-        ...state,
-        feedback: { tag: "idle" }
-      };
+      return clearWorkflowFeedback(state);
     default:
-      return assertNever3(action);
+      return assertNever11(action);
   }
 }
 function selectIsSubmitting(state) {
@@ -6766,7 +10103,7 @@ function useBookingSubmission(_siteId) {
         type: "submission-succeeded",
         message: response.type === "checkout_redirect" ? "Redirecting to secure checkout..." : "Booking submitted successfully."
       });
-      return okWith(response);
+      return okWith2(response);
     } catch (error) {
       console.error("Booking submission error:", error);
       const message = error instanceof Error ? error.message : "Failed to book appointment";
@@ -6774,7 +10111,7 @@ function useBookingSubmission(_siteId) {
         type: "submission-failed",
         message
       });
-      return err(message);
+      return err2(message);
     }
   };
   return {
@@ -6832,7 +10169,7 @@ function useDiscountCodeUi(options) {
         if (!cancelled) setDiscountsAvailableLoading(false);
       }
     }
-    checkDiscountAvailability();
+    void checkDiscountAvailability();
     return () => {
       cancelled = true;
     };
@@ -7031,7 +10368,7 @@ function buildBookingPaymentOptionViewModel(input) {
       };
     }
     default:
-      return assertNever3(input.option);
+      return assertNever11(input.option);
   }
 }
 function buildInstalmentSchedulePreview(input) {
@@ -7088,7 +10425,7 @@ function buildInstalmentSchedulePreview(input) {
       })));
     }
     default:
-      return assertNever3(input.option.plan);
+      return assertNever11(input.option.plan);
   }
 }
 function getPaymentCadenceLabel(plan) {
@@ -7108,7 +10445,7 @@ function formatScheduleDate(isoString, locale) {
 }
 
 // ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
-var asBookingFieldId = (id) => id;
+var unsafeAsBookingFieldId = (id) => id;
 function createEmptyBookingValidationErrors() {
   return { formError: null, fieldErrors: {} };
 }
@@ -7178,16 +10515,16 @@ function toOptionalBrandedId(value, brand) {
   return trimmed ? brand(trimmed) : void 0;
 }
 function toOptionalFormId(value) {
-  return toOptionalBrandedId(value, asFormId);
+  return toOptionalBrandedId(value, unsafeAsFormId);
 }
 function toOptionalAppointmentServiceId(value) {
-  return toOptionalBrandedId(value, asAppointmentServiceId);
+  return toOptionalBrandedId(value, unsafeAsAppointmentServiceId);
 }
 function toOptionalAppointmentResourceId(value) {
-  return toOptionalBrandedId(value, asAppointmentResourceId);
+  return toOptionalBrandedId(value, unsafeAsAppointmentResourceId);
 }
 function toOptionalCustomerPassId(value) {
-  return toOptionalBrandedId(value, asCustomerPassId);
+  return toOptionalBrandedId(value, unsafeAsCustomerPassId);
 }
 function isBookingFieldValue(value) {
   return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
@@ -7315,7 +10652,7 @@ function bookingFlowReducer(state, event) {
     case "reset":
       return event.initial;
     default:
-      return assertNever3(event);
+      return assertNever11(event);
   }
 }
 function clearAvailabilityFeedback(feedback) {
@@ -7341,7 +10678,7 @@ function toBookingSlotView(slot) {
     key: `${slot.startAt}|${slot.endAt}|${slot.resourceId}`,
     startAt: slot.startAt,
     endAt: slot.endAt,
-    resourceId: asAppointmentResourceId(slot.resourceId),
+    resourceId: unsafeAsAppointmentResourceId(slot.resourceId),
     ...slot.resourceName ? { resourceName: slot.resourceName } : {},
     ...slot.label ? { label: slot.label } : {}
   };
@@ -7444,7 +10781,7 @@ function validateBookingStep(input) {
       return Object.keys(errors).length > 0 ? { ok: false, errors: createFieldBookingValidationErrors(errors) } : { ok: true };
     }
     default:
-      return assertNever3(input.stepId);
+      return assertNever11(input.stepId);
   }
 }
 function validateBookingFields(input) {
@@ -7463,31 +10800,30 @@ function validateBookingField(field, value) {
   }
   if (isBlankFieldValue(value)) return null;
   const strValue = typeof value === "string" ? value : String(value);
-  switch (field.type) {
-    case "email":
-      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue) ? null : "Please enter a valid email address";
-    case "url":
-      try {
-        new URL(strValue);
-        return null;
-      } catch {
-        return "Please enter a valid URL";
-      }
-    case "tel":
-      return /^[+\d\s\-()]+$/.test(strValue) ? null : "Please enter a valid phone number";
-    case "number": {
-      const num = Number(value);
-      if (Number.isNaN(num)) return "Please enter a valid number";
-      if (field.min !== void 0 && num < field.min) {
-        return `Value must be at least ${field.min}`;
-      }
-      if (field.max !== void 0 && num > field.max) {
-        return `Value must be at most ${field.max}`;
-      }
+  if (field.type === "email") {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue) ? null : "Please enter a valid email address";
+  }
+  if (field.type === "url") {
+    try {
+      new URL(strValue);
       return null;
+    } catch {
+      return "Please enter a valid URL";
     }
-    default:
-      break;
+  }
+  if (field.type === "tel") {
+    return /^[+\d\s\-()]+$/.test(strValue) ? null : "Please enter a valid phone number";
+  }
+  if (field.type === "number") {
+    const num = Number(value);
+    if (Number.isNaN(num)) return "Please enter a valid number";
+    if (field.min !== void 0 && num < field.min) {
+      return `Value must be at least ${field.min}`;
+    }
+    if (field.max !== void 0 && num > field.max) {
+      return `Value must be at most ${field.max}`;
+    }
+    return null;
   }
   if (typeof value === "string") {
     if (field.minLength && value.length < field.minLength) {
@@ -7587,7 +10923,7 @@ function buildBookingAvailabilityQuery(input) {
 }
 function deriveBookingFieldViews(input) {
   return (input.form?.schema?.fields ?? []).map((field) => {
-    const fieldId = asBookingFieldId(field.id);
+    const fieldId = unsafeAsBookingFieldId(field.id);
     const inputId = `${input.idPrefix}-${fieldId}`;
     const helpTextId = field.helpText ? `${inputId}-help` : null;
     const fieldValue = input.values[field.id] ?? null;
@@ -7710,7 +11046,7 @@ function getAppointmentBookingOverrideInput(props) {
   return {
     ok: true,
     value: {
-      siteId: asSiteId(props.siteId),
+      siteId: unsafeAsSiteId(props.siteId),
       apiBaseUrl: props.apiBaseUrl,
       portalToken: props.portalToken ?? null,
       formId,
@@ -7806,14 +11142,14 @@ function resolveAppointmentPackagesModel(input) {
       };
     }
     default:
-      return assertNever3(input.state);
+      return assertNever11(input.state);
   }
 }
 function toHeadlessEligibleAppointmentPackage(appointmentPackage) {
   return {
     ...appointmentPackage,
-    customerPassId: asCustomerPassId(appointmentPackage.customerPassId),
-    passId: asPassId(appointmentPackage.passId)
+    customerPassId: unsafeAsCustomerPassId(appointmentPackage.customerPassId),
+    passId: unsafeAsPassId(appointmentPackage.passId)
   };
 }
 function resolveHeadlessBookingStatus(input) {
@@ -7896,7 +11232,7 @@ function HeadlessBookingProvider({
 }
 function useHeadlessBookingFlow(options) {
   const viewerTimeZone = options.viewerTimeZone ?? getRuntimeTimeZone();
-  const formKey = asFormId(options.formId);
+  const formKey = unsafeAsFormId(options.formId);
   const defaultServiceId = toOptionalAppointmentServiceId(
     options.initialServiceId ?? resolveDefaultBookingServiceId(options.form, options.services) ?? void 0
   );
@@ -8062,7 +11398,7 @@ function useHeadlessBookingFlow(options) {
       setResourcesState({
         tag: "loaded",
         value: (result.options ?? []).map((option) => ({
-          id: asAppointmentResourceId(option.id),
+          id: unsafeAsAppointmentResourceId(option.id),
           label: option.label
         }))
       });
@@ -8278,11 +11614,11 @@ function useHeadlessBookingFlow(options) {
     () => ({
       selectService: (serviceId) => dispatch({
         type: "service-selected",
-        serviceId: asAppointmentServiceId(serviceId)
+        serviceId: unsafeAsAppointmentServiceId(serviceId)
       }),
       selectResource: (resourceId) => dispatch({
         type: "resource-selected",
-        resourceId: resourceId ? asAppointmentResourceId(resourceId) : null
+        resourceId: resourceId ? unsafeAsAppointmentResourceId(resourceId) : null
       }),
       selectDate: (date) => dispatch({ type: "date-selected", date }),
       selectSlot: (slot) => dispatch({
@@ -8291,14 +11627,14 @@ function useHeadlessBookingFlow(options) {
       }),
       updateField: (fieldId, value) => dispatch({
         type: "field-updated",
-        fieldId: asBookingFieldId(fieldId),
+        fieldId: unsafeAsBookingFieldId(fieldId),
         value
       }),
-      markFieldTouched: (fieldId) => dispatch({ type: "field-touched", fieldId: asBookingFieldId(fieldId) }),
+      markFieldTouched: (fieldId) => dispatch({ type: "field-touched", fieldId: unsafeAsBookingFieldId(fieldId) }),
       selectPaymentOption: (kind) => dispatch({ type: "payment-option-selected", kind }),
       selectAppointmentPackage: (packageId) => dispatch({
         type: "appointment-package-selected",
-        packageId: packageId ? asCustomerPassId(packageId) : null
+        packageId: packageId ? unsafeAsCustomerPassId(packageId) : null
       }),
       setDiscountCode: (code) => {
         dispatch({ type: "discount-code-changed", code });
@@ -8545,7 +11881,7 @@ function pollingReducer(state, action) {
         case "timeout":
           return state;
         default:
-          return assertNever3(state);
+          return assertNever11(state);
       }
     case "polling-timed-out":
       return {
@@ -8554,7 +11890,7 @@ function pollingReducer(state, action) {
         error: new Error("Polling timed out")
       };
     default:
-      return assertNever3(action);
+      return assertNever11(action);
   }
 }
 
@@ -8619,13 +11955,13 @@ function usePolling(config) {
       dispatch({ type: "polling-progressed", result: data });
       isPollingRef.current = false;
       return false;
-    } catch (err2) {
+    } catch (err) {
       if (generation !== generationRef.current || !isActiveRef.current) {
         isPollingRef.current = false;
         return true;
       }
-      if (err2 instanceof Error) {
-        dispatch({ type: "polling-request-failed", error: err2 });
+      if (err instanceof Error) {
+        dispatch({ type: "polling-request-failed", error: err });
       }
       isPollingRef.current = false;
       return false;
@@ -8641,7 +11977,7 @@ function usePolling(config) {
         timeoutRef.current = setTimeout(doPoll, pollInterval);
       }
     };
-    doPoll();
+    void doPoll();
   }, [poll]);
   useEffect7(() => {
     if (!config) {
@@ -8799,32 +12135,130 @@ var TimeSlotSelector = ({
   ] });
 };
 
-// ../blocks/src/system/runtime/nodes/course-registration/DiscountCodeSection.tsx
+// ../blocks/src/system/runtime/shared/components/DiscountCodeDisclosure.tsx
+import { useId } from "react";
 import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-function DiscountCodeSection({
+var BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES = {
+  "course-registration": {
+    root: "cr-discount",
+    toggle: "cr-discount__toggle",
+    form: "cr-discount__form",
+    label: "cr-discount__label",
+    row: "cr-discount__row",
+    input: "cr-discount__input",
+    apply: "cr-discount__apply",
+    remove: "cr-discount__remove",
+    hint: "cr-discount__hint",
+    feedback: "cr-discount__feedback"
+  },
+  "event-registration": {
+    root: "er-discount",
+    toggle: "er-discount__toggle",
+    form: "er-discount__form",
+    label: "er-discount__label",
+    row: "er-discount__row",
+    input: "er-discount__input",
+    apply: "er-discount__apply",
+    remove: "er-discount__remove",
+    hint: "er-discount__hint",
+    feedback: "er-discount__feedback"
+  }
+};
+var textLinkButtonClassName = ["button", "link"].join("-");
+var themeFormClasses = {
+  root: "rb-flex rb-flex-col rb-gap-2 rb-mb-4",
+  toggle: `${textLinkButtonClassName} rb-self-start`,
+  form: "rb-flex rb-flex-col rb-gap-2",
+  label: "form-label",
+  row: "rb-flex rb-flex-col rb-gap-2 rb-sm-flex-row",
+  input: "form-input",
+  apply: themeButtonClassName({ variant: "secondary", size: "sm" }),
+  remove: themeButtonClassName({ variant: "secondary", size: "sm" }),
+  hint: "rb-caption status-muted",
+  feedback: "rb-caption"
+};
+function getDiscountCodeDisclosureClasses(surface) {
+  if (surface === "theme-form") return themeFormClasses;
+  return BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES[surface];
+}
+function DiscountCodeDisclosure({
+  surface,
   isOpen,
   code,
   onOpen,
   onChange,
-  onRemove
+  onRemove,
+  onApply,
+  id,
+  toggleLabel = "Have a discount code?",
+  label = "Discount code",
+  placeholder = "Enter code",
+  applyLabel = "Apply",
+  removeLabel = "Remove",
+  hint = "Applied at checkout.",
+  feedback = null,
+  isApplying = false,
+  applyDisabled = false,
+  disabled = false
 }) {
-  return /* @__PURE__ */ jsx8("div", { className: "cr-discount", children: !isOpen ? /* @__PURE__ */ jsx8("button", { type: "button", className: "cr-discount__toggle", onClick: onOpen, children: "Have a discount code?" }) : /* @__PURE__ */ jsxs6("div", { className: "cr-discount__form", children: [
-    /* @__PURE__ */ jsx8("label", { htmlFor: "cr-discount-code", className: "cr-discount__label", children: "Discount code" }),
-    /* @__PURE__ */ jsxs6("div", { className: "cr-discount__row", children: [
+  const generatedId = useId();
+  const inputId = id ?? `discount-code-${generatedId}`;
+  const classes = getDiscountCodeDisclosureClasses(surface);
+  const handleChange = (event) => {
+    onChange(event.target.value);
+  };
+  const handleKeyDown = (event) => {
+    if (!onApply || event.key !== "Enter") return;
+    event.preventDefault();
+    onApply();
+  };
+  const feedbackClassName = feedback ? `${classes.feedback} status-${feedback.tone}` : classes.feedback;
+  return /* @__PURE__ */ jsx8("div", { className: classes.root, children: !isOpen ? /* @__PURE__ */ jsx8("button", { type: "button", className: classes.toggle, onClick: onOpen, children: toggleLabel }) : /* @__PURE__ */ jsxs6("div", { className: classes.form, children: [
+    /* @__PURE__ */ jsx8("label", { htmlFor: inputId, className: classes.label, children: label }),
+    /* @__PURE__ */ jsxs6("div", { className: classes.row, children: [
       /* @__PURE__ */ jsx8(
         "input",
         {
-          id: "cr-discount-code",
-          className: "cr-discount__input",
+          id: inputId,
+          className: classes.input,
           value: code,
-          onChange: (e) => onChange(e.target.value),
-          placeholder: "Enter code",
-          autoComplete: "off"
+          onChange: handleChange,
+          onKeyDown: handleKeyDown,
+          placeholder,
+          autoComplete: "off",
+          disabled: disabled || isApplying
         }
       ),
-      /* @__PURE__ */ jsx8("button", { type: "button", className: "cr-discount__remove", onClick: onRemove, children: "Remove" })
+      onApply ? /* @__PURE__ */ jsx8(
+        "button",
+        {
+          type: "button",
+          className: classes.apply,
+          onClick: onApply,
+          disabled: disabled || isApplying || applyDisabled,
+          children: isApplying ? "Applying..." : applyLabel
+        }
+      ) : null,
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          type: "button",
+          className: classes.remove,
+          onClick: onRemove,
+          disabled: disabled || isApplying,
+          children: removeLabel
+        }
+      )
     ] }),
-    /* @__PURE__ */ jsx8("p", { className: "cr-discount__hint", children: "Applied at checkout." })
+    /* @__PURE__ */ jsx8("p", { className: classes.hint, children: hint }),
+    feedback ? /* @__PURE__ */ jsx8(
+      "p",
+      {
+        className: feedbackClassName,
+        role: feedback.tone === "error" ? "alert" : "status",
+        children: feedback.message
+      }
+    ) : null
   ] }) });
 }
 
@@ -8998,7 +12432,7 @@ function DefaultBookingStepContent({
     case "custom-fields":
       return /* @__PURE__ */ jsx10(DefaultDynamicFields, { fields: booking.fields.items, booking });
     default:
-      return assertNever3(stepId);
+      return assertNever11(stepId);
   }
 }
 function DefaultServiceSelectionStep({
@@ -9392,7 +12826,7 @@ function DefaultFieldInput({
       ] }, option.value)) });
     case "checkbox":
       if (field.field.options && field.field.options.length > 1) {
-        const checkedValues = Array.isArray(value) ? value : [];
+        const checkedValues = toStringArray(value);
         return /* @__PURE__ */ jsx10("div", { className: "rb-space-y-2", children: field.field.options.map((option) => /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
           /* @__PURE__ */ jsx10(
             "input",
@@ -9487,7 +12921,10 @@ function DefaultFieldInput({
           className: "form-input"
         }
       );
-    default:
+    case "text":
+    case "email":
+    case "tel":
+    case "url":
       return /* @__PURE__ */ jsx10(
         "input",
         {
@@ -9504,6 +12941,9 @@ function DefaultFieldInput({
       );
   }
 }
+function toStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
 function DefaultBookingDiscount({
   booking
 }) {
@@ -9511,8 +12951,9 @@ function DefaultBookingDiscount({
   if (!shouldShowDiscountSection) return null;
   return /* @__PURE__ */ jsxs7("div", { className: "rb-mt-6", children: [
     booking.discount.manualCodeEntryAllowed ? /* @__PURE__ */ jsx10(
-      DiscountCodeSection,
+      DiscountCodeDisclosure,
       {
+        surface: "theme-form",
         isOpen: booking.discount.isOpen,
         code: booking.discount.code,
         onOpen: () => booking.discount.setOpen(true),
@@ -9594,7 +13035,7 @@ function collapseHeadlessSlotsForDisplay(input) {
     visibleSlots.push({
       startAt: slot.startAt,
       endAt: slot.endAt,
-      resourceId: asAppointmentResourceId(slot.resourceId)
+      resourceId: unsafeAsAppointmentResourceId(slot.resourceId)
     });
   }
   return visibleSlots;
@@ -10208,6 +13649,15 @@ ${root} {
 `;
 }
 
+// ../theme-core/src/runtime/themeCssVarNames.ts
+var THEME_RADIUS_CSS_VARS = {
+  block: "--rb-block-radius",
+  button: "--rb-button-radius",
+  input: "--rb-input-radius",
+  legacyCard: "--radius-card",
+  legacyControl: "--radius-control"
+};
+
 // ../theme-core/src/blocks/vars/customer-portal.ts
 function generateCustomerPortalVars({
   themeId
@@ -10221,6 +13671,11 @@ ${root} {
   --cp-muted: rgb(var(--tb-mutedText));
   --cp-border: rgb(var(--tb-border));
   --cp-shadow: var(--shadow-elev);
+  --cp-primary: rgb(var(--tb-primary));
+  --cp-primary-hover: rgb(var(--tb-primary-700, var(--tb-primary)));
+  --cp-error: rgb(var(--tb-destructive));
+  --cp-card-radius: var(${THEME_RADIUS_CSS_VARS.block}, var(${THEME_RADIUS_CSS_VARS.legacyCard}, 0.75rem));
+  --cp-control-radius: var(${THEME_RADIUS_CSS_VARS.input}, var(${THEME_RADIUS_CSS_VARS.legacyControl}, 0.5rem));
 
   /* Shared tab bar (underline style) */
   --rb-tab-border-width: 1px;
@@ -10271,7 +13726,7 @@ ${root} {
   --rb-modal-bg: var(--cp-card-bg);
   --rb-modal-border: var(--cp-card-border);
   --rb-modal-shadow: var(--shadow-lg, var(--shadow-elev));
-  --rb-modal-radius: var(--radius-card);
+  --rb-modal-radius: var(--cp-card-radius);
   --rb-modal-max-width: 560px;
 
   /* Header */
@@ -10491,8 +13946,8 @@ function useBookingFormConfig(siteId, formId) {
           } catch {
           }
         }
-      } catch (err2) {
-        console.error("Failed to load form:", err2);
+      } catch (err) {
+        console.error("Failed to load form:", err);
         if (mounted) {
           setError("Failed to load booking form. Please try again later.");
         }
@@ -10502,7 +13957,7 @@ function useBookingFormConfig(siteId, formId) {
         }
       }
     }
-    loadFormAndServices();
+    void loadFormAndServices();
     return () => {
       mounted = false;
     };