@riverbankcms/sdk 0.60.1 → 0.60.3

package/dist/client/bookings.mjs

@@ -86,7 +86,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z2(e) {
+function z3(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, z2(mt);
+  en(We), We.__change = ui, z3(mt);
   var Ut = we(mt, 2), wi = X(Ut);
   {
     var pi = (n) => {
       var u = na(), _ = Gr(u), y = X(_);
-      Ge(y, () => c(re).verified), z2(_);
+      Ge(y, () => c(re).verified), z3(_);
       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), z2(E), ne(T, E);
+          Ge(p, () => c(re).verifying), z3(E), ne(T, E);
         }, y = (T) => {
           var E = oa(), p = X(E);
-          Ge(p, () => c(re).label), z2(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
+          Ge(p, () => c(re).label), z3(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);
     });
   }
-  z2(Ut);
+  z3(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n) => {
       var u = aa(), _ = X(u);
-      se(_, "href", sr), z2(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
+      se(_, "href", sr), z3(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
     };
     $e(yi, (n) => {
       (N() !== true || c(Dt)) && n(Ei);
     });
   }
-  z2(Mt);
+  z3(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), z2(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).expired), z3(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         }, T = (E) => {
           var p = sa(), x = X(p);
-          Ge(x, () => c(re).error), z2(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).error), z3(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         };
         $e(_, (E) => {
           c(C) === b.EXPIRED ? E(y) : E(T, false);
         });
       }
-      z2(u), ne(n, u);
+      z3(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), z2(_), z2(u), ne(n, u);
+      Ge(y, () => c(re).footer), z3(_), z3(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 z2(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
+  return z3(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");
     },
@@ -2806,6 +2806,156 @@ function clsx() {
 }
 var clsx_default = clsx;
 
+// ../theme-core/src/buttons/types.ts
+import { z } from "zod";
+var VARIANT_ROLES = [
+  "primary",
+  "secondary",
+  "outline",
+  "ghost",
+  "link",
+  "tertiary",
+  "accent"
+];
+var cornerStyleSchema = z.enum(["square", "rounded", "pill"]);
+var shadowSizeSchema = z.enum(["none", "low", "medium", "high"]);
+var textTransformSchema = z.enum(["none", "uppercase", "lowercase", "capitalize"]);
+var fontWeightSchema = z.union([z.literal(500), z.literal(600), z.literal(700)]);
+var buttonTypographySchema = z.enum(["body", "heading"]);
+var letterSpacingSchema = z.enum(["tight", "normal", "loose"]);
+var hoverTransformSchema = z.enum(["none", "lift", "scale", "press"]);
+var hoverColorSchema = z.enum(["none", "brighten", "darken", "saturate", "token"]);
+var buttonPaddingPresetSchema = z.enum(["compact", "default", "spacious"]);
+var gradientStyleSchema = z.enum(["linear", "radial", "conic"]);
+var gradientSharpnessSchema = z.enum(["smooth", "medium", "hard"]);
+var prioritySchema = z.union([z.literal(1), z.literal(2), z.literal(3)]);
+var variantRoleSchema = z.enum(VARIANT_ROLES);
+var buttonSizeNameSchema = z.enum(["sm", "md", "lg", "xl"]);
+var PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
+var paddingShorthandSchema = z.string().refine(
+  (value) => {
+    const parts = value.split(/\s+/).filter(Boolean);
+    return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
+  },
+  {
+    message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
+  }
+);
+var buttonSizeConfigSchema = z.object({
+  padding: paddingShorthandSchema,
+  fontSize: z.string().optional()
+});
+var buttonSizesSchema = z.object({
+  sm: buttonSizeConfigSchema,
+  md: buttonSizeConfigSchema,
+  lg: buttonSizeConfigSchema,
+  xl: buttonSizeConfigSchema.optional()
+}).transform(({ sm, md, lg, xl }) => ({
+  sm,
+  md,
+  lg,
+  xl: xl ?? lg
+}));
+var buttonGlobalSettingsSchema = z.object({
+  cornerStyle: cornerStyleSchema,
+  cornerRadius: z.number().min(0).max(24).optional(),
+  shadow: shadowSizeSchema,
+  textTransform: textTransformSchema,
+  fontWeight: fontWeightSchema,
+  /**
+   * @deprecated Set per-variant via `variant.border.widthClass` instead.
+   * Schema field is preserved so existing presets parse; the value is unread
+   * by the current generator and will be removed once the legacy
+   * `primitives/content/components/Button.tsx` slot exports are deleted.
+   */
+  borderWidth: z.union([z.literal(1), z.literal(2), z.literal(3)]),
+  // === Family-level typography ===
+  // Typography source (body or heading) — selects which theme typography pool to inherit
+  typography: buttonTypographySchema.optional(),
+  // Font size for all variants in the family (Tailwind token, e.g. "text-xs", "text-sm")
+  // Sized variants get this as default; fixed variants inherit unless they override.
+  // Size class CSS may still override at run time for sized variants.
+  fontSize: z.string().optional(),
+  // Letter spacing applied to all variants
+  letterSpacing: letterSpacingSchema.optional(),
+  // Italic style
+  italic: z.boolean().optional(),
+  // Padding preset (applies to sized variants without a sizes config)
+  paddingPreset: buttonPaddingPresetSchema.optional(),
+  hoverTransform: hoverTransformSchema,
+  hoverColor: hoverColorSchema,
+  // When hoverColor is 'token', this specifies which token to use
+  hoverColorToken: z.string().optional(),
+  // Gradient settings (if any variant uses gradients)
+  gradientStyle: gradientStyleSchema.optional(),
+  gradientAngle: z.number().min(0).max(360).optional(),
+  gradientSharpness: gradientSharpnessSchema.optional()
+});
+var gradientDirectionSchema = z.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var buttonBackgroundSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("solid"), colorToken: z.string() }),
+  z.object({
+    type: z.literal("gradient"),
+    stops: z.array(z.string()).min(2),
+    direction: gradientDirectionSchema
+  }),
+  z.object({ type: z.literal("transparent") })
+]);
+var effectApplicationSchema = z.object({
+  effectId: z.string(),
+  options: z.record(z.string(), z.any()).optional()
+});
+var buttonBorderSchema = z.object({
+  widthClass: z.string(),
+  colorToken: z.string()
+});
+var variantShadowSchema = z.object({
+  elevation: z.enum(["none", "low", "medium", "high"]),
+  softness: z.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z.enum(["bottom", "bottom-right"]).default("bottom")
+});
+var variantEffectsSchema = z.object({
+  base: z.array(effectApplicationSchema).optional(),
+  hover: z.array(effectApplicationSchema).optional(),
+  active: z.array(effectApplicationSchema).optional(),
+  focus: z.array(effectApplicationSchema).optional()
+});
+var variantSizeOverridesSchema = z.object({
+  sm: buttonSizeConfigSchema.optional(),
+  md: buttonSizeConfigSchema.optional(),
+  lg: buttonSizeConfigSchema.optional(),
+  xl: buttonSizeConfigSchema.optional()
+});
+var buttonVariantSchema = z.object({
+  id: z.string(),
+  name: z.string().min(1).max(20),
+  enabled: z.boolean(),
+  priority: prioritySchema,
+  // Base appearance (token-based)
+  background: buttonBackgroundSchema,
+  textColorToken: z.string(),
+  /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
+  borderRadius: z.string().optional(),
+  // Optional shadow override (uses theme.shadow if not specified)
+  shadow: variantShadowSchema.optional(),
+  // Border (optional)
+  border: buttonBorderSchema.optional(),
+  // Hover background token (per-variant override, takes precedence over global hoverColorToken)
+  hoverBackgroundToken: z.string().optional(),
+  // Effect composition
+  effects: variantEffectsSchema.optional(),
+  // Per-variant size overrides — see VariantSizeOverrides
+  sizes: variantSizeOverridesSchema.optional()
+});
+var buttonSystemSchema = z.object({
+  global: buttonGlobalSettingsSchema,
+  variants: z.array(buttonVariantSchema).min(1).max(6),
+  sizes: buttonSizesSchema.optional()
+});
+
+// ../theme-core/src/buttons/generateButtonCss.ts
+var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
+
 // ../core/src/branded.ts
 var asAppointmentResourceId = (id) => id;
 
@@ -3016,8 +3166,8 @@ function addLocalScheduleDays(date, days) {
 }
 
 // ../theme-core/src/accordions/types.ts
-import { z } from "zod";
-var accordionIconSchema = z.enum([
+import { z as z2 } from "zod";
+var accordionIconSchema = z2.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -3029,49 +3179,49 @@ var accordionIconSchema = z.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z.object({
+var accordionSystemSchema = z2.object({
   // Visual styling (solid color only - gradients can be added later if needed)
-  background: z.object({
-    type: z.literal("solid"),
-    colorToken: z.string()
+  background: z2.object({
+    type: z2.literal("solid"),
+    colorToken: z2.string()
   }),
   // Spacing (padding inside items)
-  spacing: z.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z2.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z2.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z.object({
-    widthClass: z.string(),
+  border: z2.object({
+    widthClass: z2.string(),
     // e.g., 'border', 'border-2', 'border-0'
-    colorToken: z.string()
+    colorToken: z2.string()
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z.object({
-    elevation: z.enum(["none", "low", "medium", "high"]),
-    softness: z.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z.enum(["bottom", "bottom-right"])
+  shadow: z2.object({
+    elevation: z2.enum(["none", "low", "medium", "high"]),
+    softness: z2.enum(["soft", "crisp", "hard"]).nullable(),
+    position: z2.enum(["bottom", "bottom-right"])
   }).nullable(),
   // Icon style and animation
-  icon: z.object({
+  icon: z2.object({
     style: accordionIconSchema,
-    position: z.enum(["left", "right"]),
-    size: z.enum(["sm", "md", "lg"])
+    position: z2.enum(["left", "right"]),
+    size: z2.enum(["sm", "md", "lg"])
   }),
   // Trigger (question) styling
-  trigger: z.object({
-    textColorToken: z.string(),
-    fontWeight: z.enum(["regular", "medium", "semibold", "bold"]).nullable()
+  trigger: z2.object({
+    textColorToken: z2.string(),
+    fontWeight: z2.enum(["regular", "medium", "semibold", "bold"]).nullable()
     // null = inherit from theme
   }),
   // Hover state styling
-  hover: z.object({
-    backgroundColorToken: z.string().optional(),
-    textColorToken: z.string().optional(),
-    borderColorToken: z.string().optional()
+  hover: z2.object({
+    backgroundColorToken: z2.string().optional(),
+    textColorToken: z2.string().optional(),
+    borderColorToken: z2.string().optional()
   }),
   // Content (answer) styling
-  content: z.object({
-    textColorToken: z.string()
+  content: z2.object({
+    textColorToken: z2.string()
   })
 });
 
@@ -6573,116 +6723,116 @@ var BookingFormClient = ({
 import { useMemo as useMemo6 } from "react";
 
 // ../theme-core/src/inputs/types.ts
-import { z as z3 } from "zod";
-var inputSystemSchema = z3.object({
+import { z as z4 } from "zod";
+var inputSystemSchema = z4.object({
   // Base styling (applied to all inputs)
-  base: z3.object({
-    background: z3.union([
-      z3.object({
-        type: z3.literal("solid"),
-        colorToken: z3.string()
+  base: z4.object({
+    background: z4.union([
+      z4.object({
+        type: z4.literal("solid"),
+        colorToken: z4.string()
       }),
-      z3.object({
-        type: z3.literal("transparent")
+      z4.object({
+        type: z4.literal("transparent")
       })
     ]),
-    textColorToken: z3.string(),
-    border: z3.object({
-      widthClass: z3.string(),
+    textColorToken: z4.string(),
+    border: z4.object({
+      widthClass: z4.string(),
       // e.g., 'border', 'border-2'
-      colorToken: z3.string(),
-      style: z3.enum(["all", "underline"]).optional()
+      colorToken: z4.string(),
+      style: z4.enum(["all", "underline"]).optional()
     }),
-    corners: z3.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z4.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z3.object({
-      elevation: z3.enum(["none", "low", "medium"]),
-      softness: z3.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z4.object({
+      elevation: z4.enum(["none", "low", "medium"]),
+      softness: z4.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z3.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z4.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z3.enum(["sm", "base", "lg"])
+    fontSize: z4.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z3.object({
-    textColorToken: z3.string(),
-    fontWeight: z3.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z3.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z3.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z3.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z3.number().min(0.2).max(1).optional()
+  label: z4.object({
+    textColorToken: z4.string(),
+    fontWeight: z4.enum(["regular", "medium", "semibold", "bold", "black"]),
+    fontSize: z4.enum(["2xs", "xs", "sm", "base"]),
+    textTransform: z4.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+    letterSpacing: z4.enum(["normal", "wide", "wider", "widest"]).optional(),
+    opacity: z4.number().min(0.2).max(1).optional()
   }),
   // Focus state
-  focus: z3.object({
-    ringColorToken: z3.string(),
-    ringWidth: z3.enum(["0", "1", "2", "3"]),
-    borderColorToken: z3.string().optional()
+  focus: z4.object({
+    ringColorToken: z4.string(),
+    ringWidth: z4.enum(["0", "1", "2", "3"]),
+    borderColorToken: z4.string().optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z3.object({
-    borderColorToken: z3.string(),
-    textColorToken: z3.string()
+  error: z4.object({
+    borderColorToken: z4.string(),
+    textColorToken: z4.string()
   }),
   // Disabled state
-  disabled: z3.object({
-    backgroundColorToken: z3.string(),
-    textColorToken: z3.string(),
-    opacity: z3.number().min(0.3).max(0.7)
+  disabled: z4.object({
+    backgroundColorToken: z4.string(),
+    textColorToken: z4.string(),
+    opacity: z4.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z4 } from "zod";
-var interactiveTypographySchema = z4.object({
+import { z as z5 } from "zod";
+var interactiveTypographySchema = z5.object({
   /** Font family source */
-  typography: z4.enum(["body", "heading"]).default("body"),
+  typography: z5.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z4.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z5.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z4.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z5.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z4.boolean().default(false)
+  italic: z5.boolean().default(false)
 });
-var effectApplicationSchema = z4.object({
+var effectApplicationSchema2 = z5.object({
   /** Effect preset ID */
-  effectId: z4.string(),
+  effectId: z5.string(),
   /** User-provided customization options */
-  options: z4.record(z4.string(), z4.any()).optional()
+  options: z5.record(z5.string(), z5.any()).optional()
 });
-var effectCompositionSchema = z4.object({
+var effectCompositionSchema = z5.object({
   /** Effects always applied */
-  base: z4.array(effectApplicationSchema).optional(),
+  base: z5.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z4.array(effectApplicationSchema).optional(),
+  hover: z5.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z4.array(effectApplicationSchema).optional(),
+  active: z5.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z4.array(effectApplicationSchema).optional()
+  focus: z5.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z5.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z5.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z5.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z5.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z5.enum(["normal", "wide", "wider", "widest"]);
-var navLinkStyleSchema = z5.object({
+var navLinkPaddingSchema = z6.enum(["none", "compact", "default"]);
+var navLinkPaddingXSchema = z6.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navLinkBorderRadiusSchema = z6.enum(["none", "sm", "md", "full"]);
+var navLinkTextSizeSchema = z6.enum(["xs", "sm", "base", "lg"]);
+var navLinkLetterSpacingSchema = z6.enum(["normal", "wide", "wider", "widest"]);
+var navLinkStyleSchema = z6.object({
   /** Display name for the style */
-  name: z5.string().min(1).max(30).optional(),
+  name: z6.string().min(1).max(30).optional(),
   /** Typography settings (inherited from interactive base) */
   ...interactiveTypographySchema.shape,
   /** Text color token */
-  colorToken: z5.string().default("text"),
+  colorToken: z6.string().default("text"),
   /** Optional text size override */
   textSize: navLinkTextSizeSchema.optional(),
   /** Optional letter spacing override */
   letterSpacing: navLinkLetterSpacingSchema.optional(),
   /** Hover/active color token (for color-change effects) */
-  hoverColorToken: z5.string().nullable().optional(),
+  hoverColorToken: z6.string().nullable().optional(),
   /** Padding preset */
   padding: navLinkPaddingSchema.default("compact"),
   /** Horizontal padding override (overrides horizontal component of padding preset) */
@@ -6838,15 +6988,15 @@ var NAV_LINK_PRESETS = {
 var NAV_LINK_PRESET_IDS = Object.keys(NAV_LINK_PRESETS);
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z6 } from "zod";
-var componentBorderSchema = z6.object({
-  width: z6.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z6.enum(["solid", "dashed"]).default("solid"),
-  colorToken: z6.string().optional()
+import { z as z7 } from "zod";
+var componentBorderSchema = z7.object({
+  width: z7.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z7.enum(["solid", "dashed"]).default("solid"),
+  colorToken: z7.string().optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z6.object({
-  elevation: z6.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+var componentShadowSchema = z7.object({
+  elevation: z7.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
 });
 
 // ../theme-core/src/blocks/vars/event-registration.ts
@@ -7300,7 +7450,7 @@ blockVarRegistry.set("course-details", generateCourseDetailsVars);
 blockVarRegistry.set("course-registration", generateCourseRegistrationVars);
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var FORBIDDEN_SELECTORS = [":root", "html", "body"];
 var UNIVERSAL_SELECTOR = "*";
 var REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
@@ -7342,7 +7492,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z7.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
+var selectorSchema = z8.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" }
 );
@@ -7352,38 +7502,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z7.string().max(500, "Declaration value too long (max 500 characters)").refine(
+var declarationValueSchema = z8.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 = z7.record(
-  z7.string().min(1).max(100),
+var declarationsSchema = z8.record(
+  z8.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z7.object({
-  id: z7.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+var customCssRuleSchema = z8.object({
+  id: z8.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
   selector: selectorSchema,
   declarations: declarationsSchema
 });
 var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z7.string().min(1, "Block kind is required").max(50, "Block kind too long")
+  blockKind: z8.string().min(1, "Block kind is required").max(50, "Block kind too long")
 });
-var customCssRulesSchema = z7.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z7.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z8.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z8.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z8 } from "zod";
+import { z as z9 } 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 = z8.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z8.object({
+var ruleIdSchema = z9.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z9.object({
   selector: selectorSchema,
   declarations: declarationsSchema
 });
@@ -7395,73 +7545,73 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z8.string().transform((offset) => offset.trim()).refine(
+var keyframeOffsetSchema = z9.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 = z8.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
+var animationNameSchema = z9.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 = z8.object({
+var keyframeSchema = z9.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z8.object({
+var keyframesAtRuleSchema = z9.object({
   id: ruleIdSchema,
-  type: z8.literal("keyframes"),
+  type: z9.literal("keyframes"),
   name: animationNameSchema,
-  frames: z8.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z9.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z8.record(z8.string().min(1).max(100), declarationValueSchema).refine(
+var fontFaceDeclarationsSchema = z9.record(z9.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 = z8.object({
+var fontFaceAtRuleSchema = z9.object({
   id: ruleIdSchema,
-  type: z8.literal("font-face"),
+  type: z9.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z8.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z8.object({
+var mediaQuerySchema = z9.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z9.object({
   id: ruleIdSchema,
-  type: z8.literal("media"),
+  type: z9.literal("media"),
   query: mediaQuerySchema,
-  rules: z8.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z9.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z8.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z8.object({
+var supportsConditionSchema = z9.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z9.object({
   id: ruleIdSchema,
-  type: z8.literal("supports"),
+  type: z9.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z8.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z9.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 function containsBlockedAtRule(css) {
   return BLOCKED_AT_RULE_PATTERN.test(css);
 }
-var rawCssSchema = z8.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
+var rawCssSchema = z9.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 = z8.object({
+var rawAtRuleSchema = z9.object({
   id: ruleIdSchema,
-  type: z8.literal("raw"),
+  type: z9.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z8.discriminatedUnion("type", [
+var customCssAtRuleSchema = z9.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z8.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z9.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/responsiveMode.ts
 var THEME_RESPONSIVE_MODE_ATTR = "data-rb-responsive-mode";