@riverbankcms/sdk 0.60.7 → 0.60.9

package/dist/client/hooks.mjs

@@ -7392,74 +7392,6 @@ function parsePublicProductCategorySelector(value) {
   return void 0;
 }
 
-// ../api/src/aiPlayground.ts
-import { z as z8 } from "zod";
-var Rfc6902PatchOp = z8.discriminatedUnion("op", [
-  // Standard RFC-6902 operations
-  z8.object({
-    op: z8.literal("add"),
-    path: z8.string(),
-    value: z8.unknown()
-  }),
-  z8.object({
-    op: z8.literal("remove"),
-    path: z8.string()
-  }),
-  z8.object({
-    op: z8.literal("replace"),
-    path: z8.string(),
-    value: z8.unknown()
-  }),
-  z8.object({
-    op: z8.literal("move"),
-    from: z8.string(),
-    path: z8.string()
-  }),
-  z8.object({
-    op: z8.literal("copy"),
-    from: z8.string(),
-    path: z8.string()
-  }),
-  // Block-level operations (Phase 2)
-  z8.object({
-    op: z8.literal("add_block"),
-    blockKind: z8.string(),
-    afterBlockId: z8.string().nullable(),
-    content: z8.record(z8.string(), z8.unknown()),
-    rationale: z8.string()
-  }),
-  z8.object({
-    op: z8.literal("delete_block"),
-    blockId: z8.string(),
-    rationale: z8.string()
-  }),
-  z8.object({
-    op: z8.literal("reorder_block"),
-    blockId: z8.string(),
-    afterBlockId: z8.string().nullable(),
-    rationale: z8.string()
-  })
-]);
-var PlaygroundProposeRequest = z8.object({
-  request: z8.string().min(1).max(2e3)
-});
-var MultiPagePatchEnvelope = z8.object({
-  pageId: z8.string(),
-  blockId: z8.string().optional(),
-  // Not present for page-level ops
-  blockKind: z8.string().optional(),
-  blockPurpose: z8.string().optional().nullable(),
-  ops: z8.array(Rfc6902PatchOp),
-  rationale: z8.string(),
-  currentContent: z8.record(z8.string(), z8.unknown()).optional()
-});
-var MultiPageUpdateResponse = z8.object({
-  patches: z8.array(MultiPagePatchEnvelope),
-  assistantMessage: z8.string(),
-  pagesModified: z8.number(),
-  toolCallsUsed: z8.number()
-});
-
 // ../blocks/src/system/manifest/augmentManifest.ts
 function augmentManifest(manifest) {
   let augmentedFields = manifest.fields ?? [];
@@ -7517,14 +7449,6 @@ function registerManifest(manifest) {
   return manifest;
 }
 
-// ../blocks/src/lib/typeGuards.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
 // ../theme-core/src/site-styles/types.ts
 function asDesignBlockId(value) {
   return brandNonEmptyString(value, "DesignBlockId");
@@ -7832,10 +7756,10 @@ function assertUniqueLayoutProfileKeys(profiles) {
 }
 
 // ../theme-core/src/buttons/personalities/types.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
 // ../theme-core/src/buttons/types.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var VARIANT_ROLES = [
   "primary",
   "secondary",
@@ -7845,22 +7769,22 @@ var VARIANT_ROLES = [
   "tertiary",
   "accent"
 ];
-var cornerStyleSchema = z9.enum(["square", "rounded", "pill"]);
-var shadowSizeSchema = z9.enum(["none", "low", "medium", "high"]);
-var textTransformSchema = z9.enum(["none", "uppercase", "lowercase", "capitalize"]);
-var fontWeightSchema = z9.union([z9.literal(500), z9.literal(600), z9.literal(700)]);
-var buttonTypographySchema = z9.enum(["body", "heading"]);
-var letterSpacingSchema = z9.enum(["tight", "normal", "loose"]);
-var hoverTransformSchema = z9.enum(["none", "lift", "scale", "press"]);
-var hoverColorSchema = z9.enum(["none", "brighten", "darken", "saturate", "token"]);
-var buttonPaddingPresetSchema = z9.enum(["compact", "default", "spacious"]);
-var gradientStyleSchema = z9.enum(["linear", "radial", "conic"]);
-var gradientSharpnessSchema = z9.enum(["smooth", "medium", "hard"]);
-var prioritySchema = z9.union([z9.literal(1), z9.literal(2), z9.literal(3)]);
-var variantRoleSchema = z9.enum(VARIANT_ROLES);
-var buttonSizeNameSchema = z9.enum(["sm", "md", "lg", "xl"]);
+var cornerStyleSchema = z8.enum(["square", "rounded", "pill"]);
+var shadowSizeSchema = z8.enum(["none", "low", "medium", "high"]);
+var textTransformSchema = z8.enum(["none", "uppercase", "lowercase", "capitalize"]);
+var fontWeightSchema = z8.union([z8.literal(500), z8.literal(600), z8.literal(700)]);
+var buttonTypographySchema = z8.enum(["body", "heading"]);
+var letterSpacingSchema = z8.enum(["tight", "normal", "loose"]);
+var hoverTransformSchema = z8.enum(["none", "lift", "scale", "press"]);
+var hoverColorSchema = z8.enum(["none", "brighten", "darken", "saturate", "token"]);
+var buttonPaddingPresetSchema = z8.enum(["compact", "default", "spacious"]);
+var gradientStyleSchema = z8.enum(["linear", "radial", "conic"]);
+var gradientSharpnessSchema = z8.enum(["smooth", "medium", "hard"]);
+var prioritySchema = z8.union([z8.literal(1), z8.literal(2), z8.literal(3)]);
+var variantRoleSchema = z8.enum(VARIANT_ROLES);
+var buttonSizeNameSchema = z8.enum(["sm", "md", "lg", "xl"]);
 var PADDING_TOKEN_PATTERN = /^(?:0|\d+(?:\.\d+)?(?:rem|em|px|%))$/;
-var paddingShorthandSchema = z9.string().refine(
+var paddingShorthandSchema = z8.string().refine(
   (value) => {
     const parts = value.split(/\s+/).filter(Boolean);
     return parts.length === 2 && parts.every((token) => PADDING_TOKEN_PATTERN.test(token));
@@ -7869,11 +7793,11 @@ var paddingShorthandSchema = z9.string().refine(
     message: 'Padding must be two space-separated CSS length tokens (e.g. "0.5rem 1rem"). Use `0` for zero.'
   }
 );
-var buttonSizeConfigSchema = z9.object({
+var buttonSizeConfigSchema = z8.object({
   padding: paddingShorthandSchema,
-  fontSize: z9.string().optional()
+  fontSize: z8.string().optional()
 });
-var buttonSizesSchema = z9.object({
+var buttonSizesSchema = z8.object({
   sm: buttonSizeConfigSchema,
   md: buttonSizeConfigSchema,
   lg: buttonSizeConfigSchema,
@@ -7884,9 +7808,9 @@ var buttonSizesSchema = z9.object({
   lg,
   xl: xl ?? lg
 }));
-var buttonGlobalSettingsSchema = z9.object({
+var buttonGlobalSettingsSchema = z8.object({
   cornerStyle: cornerStyleSchema,
-  cornerRadius: z9.number().min(0).max(24).optional(),
+  cornerRadius: z8.number().min(0).max(24).optional(),
   shadow: shadowSizeSchema,
   textTransform: textTransformSchema,
   fontWeight: fontWeightSchema,
@@ -7896,104 +7820,104 @@ var buttonGlobalSettingsSchema = z9.object({
    * by the current generator and will be removed once the legacy
    * `primitives/content/components/Button.tsx` slot exports are deleted.
    */
-  borderWidth: z9.union([z9.literal(1), z9.literal(2), z9.literal(3)]),
+  borderWidth: z8.union([z8.literal(1), z8.literal(2), z8.literal(3)]),
   // === Family-level typography ===
   // Typography source (body or heading) — selects which theme typography pool to inherit
   typography: buttonTypographySchema.optional(),
   // Font size for all variants in the family (Tailwind token, e.g. "text-xs", "text-sm")
   // Sized variants get this as default; fixed variants inherit unless they override.
   // Size class CSS may still override at run time for sized variants.
-  fontSize: z9.string().optional(),
+  fontSize: z8.string().optional(),
   // Letter spacing applied to all variants
   letterSpacing: letterSpacingSchema.optional(),
   // Italic style
-  italic: z9.boolean().optional(),
+  italic: z8.boolean().optional(),
   // Padding preset (applies to sized variants without a sizes config)
   paddingPreset: buttonPaddingPresetSchema.optional(),
   hoverTransform: hoverTransformSchema,
   hoverColor: hoverColorSchema,
   // When hoverColor is 'token', this specifies which token to use
-  hoverColorToken: z9.string().optional(),
+  hoverColorToken: z8.string().optional(),
   // Gradient settings (if any variant uses gradients)
   gradientStyle: gradientStyleSchema.optional(),
-  gradientAngle: z9.number().min(0).max(360).optional(),
+  gradientAngle: z8.number().min(0).max(360).optional(),
   gradientSharpness: gradientSharpnessSchema.optional()
 });
-var gradientDirectionSchema = z9.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var buttonBackgroundSchema = z9.discriminatedUnion("type", [
-  z9.object({ type: z9.literal("solid"), colorToken: z9.string() }),
-  z9.object({
-    type: z9.literal("gradient"),
-    stops: z9.array(z9.string()).min(2),
+var gradientDirectionSchema = z8.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var buttonBackgroundSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("solid"), colorToken: z8.string() }),
+  z8.object({
+    type: z8.literal("gradient"),
+    stops: z8.array(z8.string()).min(2),
     direction: gradientDirectionSchema
   }),
-  z9.object({ type: z9.literal("transparent") })
+  z8.object({ type: z8.literal("transparent") })
 ]);
-var effectApplicationSchema = z9.object({
-  effectId: z9.string(),
-  options: z9.record(z9.string(), z9.any()).optional()
-});
-var buttonBorderSchema = z9.object({
-  widthClass: z9.string(),
-  colorToken: z9.string()
-});
-var variantShadowSchema = z9.object({
-  elevation: z9.enum(["none", "low", "medium", "high"]),
-  softness: z9.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z9.enum(["bottom", "bottom-right"]).default("bottom")
-});
-var variantEffectsSchema = z9.object({
-  base: z9.array(effectApplicationSchema).optional(),
-  hover: z9.array(effectApplicationSchema).optional(),
-  active: z9.array(effectApplicationSchema).optional(),
-  focus: z9.array(effectApplicationSchema).optional()
-});
-var variantSizeOverridesSchema = z9.object({
+var effectApplicationSchema = z8.object({
+  effectId: z8.string(),
+  options: z8.record(z8.string(), z8.any()).optional()
+});
+var buttonBorderSchema = z8.object({
+  widthClass: z8.string(),
+  colorToken: z8.string()
+});
+var variantShadowSchema = z8.object({
+  elevation: z8.enum(["none", "low", "medium", "high"]),
+  softness: z8.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z8.enum(["bottom", "bottom-right"]).default("bottom")
+});
+var variantEffectsSchema = z8.object({
+  base: z8.array(effectApplicationSchema).optional(),
+  hover: z8.array(effectApplicationSchema).optional(),
+  active: z8.array(effectApplicationSchema).optional(),
+  focus: z8.array(effectApplicationSchema).optional()
+});
+var variantSizeOverridesSchema = z8.object({
   sm: buttonSizeConfigSchema.optional(),
   md: buttonSizeConfigSchema.optional(),
   lg: buttonSizeConfigSchema.optional(),
   xl: buttonSizeConfigSchema.optional()
 });
-var buttonVariantSchema = z9.object({
-  id: z9.string(),
-  name: z9.string().min(1).max(20),
-  enabled: z9.boolean(),
+var buttonVariantSchema = z8.object({
+  id: z8.string(),
+  name: z8.string().min(1).max(20),
+  enabled: z8.boolean(),
   priority: prioritySchema,
   // Base appearance (token-based)
   background: buttonBackgroundSchema,
-  textColorToken: z9.string(),
+  textColorToken: z8.string(),
   /** Tailwind radius token (e.g. `'rounded-md'`). Omit to inherit from `global.cornerStyle`. */
-  borderRadius: z9.string().optional(),
+  borderRadius: z8.string().optional(),
   // Optional shadow override (uses theme.shadow if not specified)
   shadow: variantShadowSchema.optional(),
   // Border (optional)
   border: buttonBorderSchema.optional(),
   // Hover background token (per-variant override, takes precedence over global hoverColorToken)
-  hoverBackgroundToken: z9.string().optional(),
+  hoverBackgroundToken: z8.string().optional(),
   // Effect composition
   effects: variantEffectsSchema.optional(),
   // Per-variant size overrides — see VariantSizeOverrides
   sizes: variantSizeOverridesSchema.optional()
 });
-var buttonSystemSchema = z9.object({
+var buttonSystemSchema = z8.object({
   global: buttonGlobalSettingsSchema,
-  variants: z9.array(buttonVariantSchema).min(1).max(6),
+  variants: z8.array(buttonVariantSchema).min(1).max(6),
   sizes: buttonSizesSchema.optional()
 });
 
 // ../theme-core/src/site-styles/styleTags.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var STYLE_AXIS_VALUES = {
   tone: ["minimal", "classic", "bold"],
   energy: ["calm", "vibrant"],
   motion: ["subtle", "standard", "expressive"],
   era: ["editorial", "modern", "organic", "technical", "retro"]
 };
-var styleTagsSchema = z10.object({
-  tone: z10.enum(STYLE_AXIS_VALUES.tone).optional(),
-  energy: z10.enum(STYLE_AXIS_VALUES.energy).optional(),
-  motion: z10.enum(STYLE_AXIS_VALUES.motion).optional(),
-  era: z10.enum(STYLE_AXIS_VALUES.era).optional()
+var styleTagsSchema = z9.object({
+  tone: z9.enum(STYLE_AXIS_VALUES.tone).optional(),
+  energy: z9.enum(STYLE_AXIS_VALUES.energy).optional(),
+  motion: z9.enum(STYLE_AXIS_VALUES.motion).optional(),
+  era: z9.enum(STYLE_AXIS_VALUES.era).optional()
 });
 
 // ../theme-core/src/buttons/personalities/types.ts
@@ -8003,11 +7927,11 @@ function asButtonPersonalityId(value) {
   }
   return value;
 }
-var buttonPersonalityIdSchema = z11.string().min(1).transform((value) => asButtonPersonalityId(value));
-var buttonPersonalitySchema = z11.object({
+var buttonPersonalityIdSchema = z10.string().min(1).transform((value) => asButtonPersonalityId(value));
+var buttonPersonalitySchema = z10.object({
   id: buttonPersonalityIdSchema,
-  name: z11.string().min(1),
-  description: z11.string().min(1),
+  name: z10.string().min(1),
+  description: z10.string().min(1),
   tags: styleTagsSchema,
   buttonSystem: buttonSystemSchema
 });
@@ -8546,51 +8470,51 @@ var personalitiesById = new Map(
 );
 
 // ../theme-core/src/palette/variants/types.ts
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 
 // ../theme-core/src/schema.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 
 // ../theme-core/src/lib/media.ts
-import z12 from "zod";
-var hotspotSchema = z12.object({
-  x: z12.number().min(0).max(1),
-  y: z12.number().min(0).max(1),
-  radius: z12.number().optional()
-});
-var rotationSchema = z12.union([z12.literal(0), z12.literal(90), z12.literal(180), z12.literal(270)]);
-var rectSchema = z12.tuple([z12.number(), z12.number(), z12.number(), z12.number()]);
-var aspectCropSchema = z12.object({
-  aspect: z12.preprocess((value) => value == null ? void 0 : value, z12.string().optional()),
-  rect: z12.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-  hotspot: z12.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-  rotation: z12.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
-});
-var transformSchema = z12.object({
-  aspectCrops: z12.preprocess((value) => {
+import z11 from "zod";
+var hotspotSchema = z11.object({
+  x: z11.number().min(0).max(1),
+  y: z11.number().min(0).max(1),
+  radius: z11.number().optional()
+});
+var rotationSchema = z11.union([z11.literal(0), z11.literal(90), z11.literal(180), z11.literal(270)]);
+var rectSchema = z11.tuple([z11.number(), z11.number(), z11.number(), z11.number()]);
+var aspectCropSchema = z11.object({
+  aspect: z11.preprocess((value) => value == null ? void 0 : value, z11.string().optional()),
+  rect: z11.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+  hotspot: z11.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+  rotation: z11.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+});
+var transformSchema = z11.object({
+  aspectCrops: z11.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z12.record(z12.string(), aspectCropSchema.catch({}))).optional(),
+  }, z11.record(z11.string(), aspectCropSchema.catch({}))).optional(),
   rect: rectSchema.optional(),
   hotspot: hotspotSchema.optional(),
   rotation: rotationSchema.optional()
 });
-var mediaSchema = z12.object({
-  type: z12.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z12.string().optional(),
-  placeholder: z12.boolean().default(true).optional(),
-  assetId: z12.string().optional(),
-  identifier: z12.string().optional(),
-  src: z12.string().optional(),
-  alt: z12.string().optional(),
-  filename: z12.string().optional(),
-  mimeType: z12.string().optional(),
-  width: z12.number().optional(),
-  height: z12.number().optional(),
-  storageBucket: z12.string().optional(),
-  storagePath: z12.string().optional(),
+var mediaSchema = z11.object({
+  type: z11.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+  purpose: z11.string().optional(),
+  placeholder: z11.boolean().default(true).optional(),
+  assetId: z11.string().optional(),
+  identifier: z11.string().optional(),
+  src: z11.string().optional(),
+  alt: z11.string().optional(),
+  filename: z11.string().optional(),
+  mimeType: z11.string().optional(),
+  width: z11.number().optional(),
+  height: z11.number().optional(),
+  storageBucket: z11.string().optional(),
+  storagePath: z11.string().optional(),
   transform: transformSchema.optional()
 });
 
@@ -8598,48 +8522,48 @@ var mediaSchema = z12.object({
 var BUTTON_SIZE_NAMES = buttonSizeNameSchema.options;
 
 // ../theme-core/src/cards/types.ts
-import { z as z13 } from "zod";
-var cardSpacingSchema = z13.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z13.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardBackgroundSchema = z13.discriminatedUnion("type", [
-  z13.object({ type: z13.literal("solid"), colorToken: z13.string() }),
-  z13.object({
-    type: z13.literal("gradient"),
-    fromToken: z13.string(),
-    toToken: z13.string(),
+import { z as z12 } from "zod";
+var cardSpacingSchema = z12.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z12.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardBackgroundSchema = z12.discriminatedUnion("type", [
+  z12.object({ type: z12.literal("solid"), colorToken: z12.string() }),
+  z12.object({
+    type: z12.literal("gradient"),
+    fromToken: z12.string(),
+    toToken: z12.string(),
     direction: gradientDirectionSchema2
   }),
-  z13.object({ type: z13.literal("transparent") })
+  z12.object({ type: z12.literal("transparent") })
 ]);
-var cardBorderSchema = z13.object({
-  widthClass: z13.string(),
-  colorToken: z13.string()
-});
-var cardVariantSchema = z13.object({
-  id: z13.string(),
-  name: z13.string().min(1).max(20),
-  enabled: z13.boolean(),
-  priority: z13.union([z13.literal(1), z13.literal(2), z13.literal(3)]),
+var cardBorderSchema = z12.object({
+  widthClass: z12.string(),
+  colorToken: z12.string()
+});
+var cardVariantSchema = z12.object({
+  id: z12.string(),
+  name: z12.string().min(1).max(20),
+  enabled: z12.boolean(),
+  priority: z12.union([z12.literal(1), z12.literal(2), z12.literal(3)]),
   // Appearance (token-based)
   background: cardBackgroundSchema,
   spacing: cardSpacingSchema,
   // Optional overrides (uses theme defaults if not specified)
-  shadow: z13.object({
-    elevation: z13.enum(["none", "low", "medium", "high"]),
-    softness: z13.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z13.enum(["bottom", "bottom-right"]).default("bottom")
+  shadow: z12.object({
+    elevation: z12.enum(["none", "low", "medium", "high"]),
+    softness: z12.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z12.enum(["bottom", "bottom-right"]).default("bottom")
   }).optional(),
-  corners: z13.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z12.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Border (optional)
   border: cardBorderSchema.optional()
 });
-var cardSystemSchema = z13.object({
-  variants: z13.array(cardVariantSchema).min(1).max(3)
+var cardSystemSchema = z12.object({
+  variants: z12.array(cardVariantSchema).min(1).max(3)
 });
 
 // ../theme-core/src/accordions/types.ts
-import { z as z14 } from "zod";
-var accordionIconSchema = z14.enum([
+import { z as z13 } from "zod";
+var accordionIconSchema = z13.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -8651,180 +8575,180 @@ var accordionIconSchema = z14.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z14.object({
+var accordionSystemSchema = z13.object({
   // Visual styling (solid color only - gradients can be added later if needed)
-  background: z14.object({
-    type: z14.literal("solid"),
-    colorToken: z14.string()
+  background: z13.object({
+    type: z13.literal("solid"),
+    colorToken: z13.string()
   }),
   // Spacing (padding inside items)
-  spacing: z14.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z13.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z14.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z13.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z14.object({
-    widthClass: z14.string(),
+  border: z13.object({
+    widthClass: z13.string(),
     // e.g., 'border', 'border-2', 'border-0'
-    colorToken: z14.string()
+    colorToken: z13.string()
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z14.object({
-    elevation: z14.enum(["none", "low", "medium", "high"]),
-    softness: z14.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z14.enum(["bottom", "bottom-right"])
+  shadow: z13.object({
+    elevation: z13.enum(["none", "low", "medium", "high"]),
+    softness: z13.enum(["soft", "crisp", "hard"]).nullable(),
+    position: z13.enum(["bottom", "bottom-right"])
   }).nullable(),
   // Icon style and animation
-  icon: z14.object({
+  icon: z13.object({
     style: accordionIconSchema,
-    position: z14.enum(["left", "right"]),
-    size: z14.enum(["sm", "md", "lg"])
+    position: z13.enum(["left", "right"]),
+    size: z13.enum(["sm", "md", "lg"])
   }),
   // Trigger (question) styling
-  trigger: z14.object({
-    textColorToken: z14.string(),
-    fontWeight: z14.enum(["regular", "medium", "semibold", "bold"]).nullable()
+  trigger: z13.object({
+    textColorToken: z13.string(),
+    fontWeight: z13.enum(["regular", "medium", "semibold", "bold"]).nullable()
     // null = inherit from theme
   }),
   // Hover state styling
-  hover: z14.object({
-    backgroundColorToken: z14.string().optional(),
-    textColorToken: z14.string().optional(),
-    borderColorToken: z14.string().optional()
+  hover: z13.object({
+    backgroundColorToken: z13.string().optional(),
+    textColorToken: z13.string().optional(),
+    borderColorToken: z13.string().optional()
   }),
   // Content (answer) styling
-  content: z14.object({
-    textColorToken: z14.string()
+  content: z13.object({
+    textColorToken: z13.string()
   })
 });
 
 // ../theme-core/src/inputs/types.ts
-import { z as z15 } from "zod";
-var inputSystemSchema = z15.object({
+import { z as z14 } from "zod";
+var inputSystemSchema = z14.object({
   // Base styling (applied to all inputs)
-  base: z15.object({
-    background: z15.union([
-      z15.object({
-        type: z15.literal("solid"),
-        colorToken: z15.string()
+  base: z14.object({
+    background: z14.union([
+      z14.object({
+        type: z14.literal("solid"),
+        colorToken: z14.string()
       }),
-      z15.object({
-        type: z15.literal("transparent")
+      z14.object({
+        type: z14.literal("transparent")
       })
     ]),
-    textColorToken: z15.string(),
-    border: z15.object({
-      widthClass: z15.string(),
+    textColorToken: z14.string(),
+    border: z14.object({
+      widthClass: z14.string(),
       // e.g., 'border', 'border-2'
-      colorToken: z15.string(),
-      style: z15.enum(["all", "underline"]).optional()
+      colorToken: z14.string(),
+      style: z14.enum(["all", "underline"]).optional()
     }),
-    corners: z15.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z14.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z15.object({
-      elevation: z15.enum(["none", "low", "medium"]),
-      softness: z15.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z14.object({
+      elevation: z14.enum(["none", "low", "medium"]),
+      softness: z14.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z15.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z14.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z15.enum(["sm", "base", "lg"])
+    fontSize: z14.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z15.object({
-    textColorToken: z15.string(),
-    fontWeight: z15.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z15.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z15.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z15.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z15.number().min(0.2).max(1).optional()
+  label: z14.object({
+    textColorToken: z14.string(),
+    fontWeight: z14.enum(["regular", "medium", "semibold", "bold", "black"]),
+    fontSize: z14.enum(["2xs", "xs", "sm", "base"]),
+    textTransform: z14.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+    letterSpacing: z14.enum(["normal", "wide", "wider", "widest"]).optional(),
+    opacity: z14.number().min(0.2).max(1).optional()
   }),
   // Focus state
-  focus: z15.object({
-    ringColorToken: z15.string(),
-    ringWidth: z15.enum(["0", "1", "2", "3"]),
-    borderColorToken: z15.string().optional()
+  focus: z14.object({
+    ringColorToken: z14.string(),
+    ringWidth: z14.enum(["0", "1", "2", "3"]),
+    borderColorToken: z14.string().optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z15.object({
-    borderColorToken: z15.string(),
-    textColorToken: z15.string()
+  error: z14.object({
+    borderColorToken: z14.string(),
+    textColorToken: z14.string()
   }),
   // Disabled state
-  disabled: z15.object({
-    backgroundColorToken: z15.string(),
-    textColorToken: z15.string(),
-    opacity: z15.number().min(0.3).max(0.7)
+  disabled: z14.object({
+    backgroundColorToken: z14.string(),
+    textColorToken: z14.string(),
+    opacity: z14.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/gradients/types.ts
-import { z as z16 } from "zod";
-var gradientStopSchema = z16.object({
-  color: z16.string(),
+import { z as z15 } from "zod";
+var gradientStopSchema = z15.object({
+  color: z15.string(),
   // Theme color token name (e.g., 'primary-500')
-  position: z16.number().min(0).max(100)
+  position: z15.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z16.object({
-  type: z16.enum(["linear", "radial"]),
-  angle: z16.number().min(0).max(360).optional(),
+var gradientConfigSchema = z15.object({
+  type: z15.enum(["linear", "radial"]),
+  angle: z15.number().min(0).max(360).optional(),
   // For linear gradients (degrees)
-  position: z16.string().optional(),
+  position: z15.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z16.array(gradientStopSchema).min(2)
+  stops: z15.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z17 } from "zod";
-var interactiveTypographySchema = z17.object({
+import { z as z16 } from "zod";
+var interactiveTypographySchema = z16.object({
   /** Font family source */
-  typography: z17.enum(["body", "heading"]).default("body"),
+  typography: z16.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z17.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z16.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z17.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z16.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z17.boolean().default(false)
+  italic: z16.boolean().default(false)
 });
-var effectApplicationSchema2 = z17.object({
+var effectApplicationSchema2 = z16.object({
   /** Effect preset ID */
-  effectId: z17.string(),
+  effectId: z16.string(),
   /** User-provided customization options */
-  options: z17.record(z17.string(), z17.any()).optional()
+  options: z16.record(z16.string(), z16.any()).optional()
 });
-var effectCompositionSchema = z17.object({
+var effectCompositionSchema = z16.object({
   /** Effects always applied */
-  base: z17.array(effectApplicationSchema2).optional(),
+  base: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z17.array(effectApplicationSchema2).optional(),
+  hover: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z17.array(effectApplicationSchema2).optional(),
+  active: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z17.array(effectApplicationSchema2).optional()
+  focus: z16.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z18.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z18.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z18.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z18.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z18.enum(["normal", "wide", "wider", "widest"]);
-var navLinkStyleSchema = z18.object({
+var navLinkPaddingSchema = z17.enum(["none", "compact", "default"]);
+var navLinkPaddingXSchema = z17.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navLinkBorderRadiusSchema = z17.enum(["none", "sm", "md", "full"]);
+var navLinkTextSizeSchema = z17.enum(["xs", "sm", "base", "lg"]);
+var navLinkLetterSpacingSchema = z17.enum(["normal", "wide", "wider", "widest"]);
+var navLinkStyleSchema = z17.object({
   /** Display name for the style */
-  name: z18.string().min(1).max(30).optional(),
+  name: z17.string().min(1).max(30).optional(),
   /** Typography settings (inherited from interactive base) */
   ...interactiveTypographySchema.shape,
   /** Text color token */
-  colorToken: z18.string().default("text"),
+  colorToken: z17.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: z18.string().nullable().optional(),
+  hoverColorToken: z17.string().nullable().optional(),
   /** Padding preset */
   padding: navLinkPaddingSchema.default("compact"),
   /** Horizontal padding override (overrides horizontal component of padding preset) */
@@ -8836,7 +8760,7 @@ var navLinkStyleSchema = z18.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 var FORBIDDEN_SELECTORS = [":root", "html", "body"];
 var UNIVERSAL_SELECTOR = "*";
 var REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
@@ -8878,7 +8802,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z19.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
+var selectorSchema = z18.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" }
 );
@@ -8888,38 +8812,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z19.string().max(500, "Declaration value too long (max 500 characters)").refine(
+var declarationValueSchema = z18.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 = z19.record(
-  z19.string().min(1).max(100),
+var declarationsSchema = z18.record(
+  z18.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z19.object({
-  id: z19.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+var customCssRuleSchema = z18.object({
+  id: z18.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
   selector: selectorSchema,
   declarations: declarationsSchema
 });
 var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z19.string().min(1, "Block kind is required").max(50, "Block kind too long")
+  blockKind: z18.string().min(1, "Block kind is required").max(50, "Block kind too long")
 });
-var customCssRulesSchema = z19.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z19.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z18.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z18.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z20 } from "zod";
+import { z as z19 } 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 = z20.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z20.object({
+var ruleIdSchema = z19.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z19.object({
   selector: selectorSchema,
   declarations: declarationsSchema
 });
@@ -8931,146 +8855,146 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z20.string().transform((offset) => offset.trim()).refine(
+var keyframeOffsetSchema = z19.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 = z20.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
+var animationNameSchema = z19.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 = z20.object({
+var keyframeSchema = z19.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z20.object({
+var keyframesAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z20.literal("keyframes"),
+  type: z19.literal("keyframes"),
   name: animationNameSchema,
-  frames: z20.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z19.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z20.record(z20.string().min(1).max(100), declarationValueSchema).refine(
+var fontFaceDeclarationsSchema = z19.record(z19.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 = z20.object({
+var fontFaceAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z20.literal("font-face"),
+  type: z19.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z20.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z20.object({
+var mediaQuerySchema = z19.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z20.literal("media"),
+  type: z19.literal("media"),
   query: mediaQuerySchema,
-  rules: z20.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z19.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z20.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z20.object({
+var supportsConditionSchema = z19.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z20.literal("supports"),
+  type: z19.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z20.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z19.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 function containsBlockedAtRule(css) {
   return BLOCKED_AT_RULE_PATTERN.test(css);
 }
-var rawCssSchema = z20.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
+var rawCssSchema = z19.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 = z20.object({
+var rawAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z20.literal("raw"),
+  type: z19.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z20.discriminatedUnion("type", [
+var customCssAtRuleSchema = z19.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z20.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z19.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z21 } from "zod";
-var componentBorderSchema = z21.object({
-  width: z21.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z21.enum(["solid", "dashed"]).default("solid"),
-  colorToken: z21.string().optional()
+import { z as z20 } from "zod";
+var componentBorderSchema = z20.object({
+  width: z20.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z20.enum(["solid", "dashed"]).default("solid"),
+  colorToken: z20.string().optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z21.object({
-  elevation: z21.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+var componentShadowSchema = z20.object({
+  elevation: z20.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
 });
 
 // ../theme-core/src/schema.ts
-var axesSchema = z22.object({
-  tone: z22.enum(["minimal", "classic", "bold"]),
-  energy: z22.enum(["calm", "vibrant"]),
-  density: z22.enum(["airy", "regular", "compact"]),
-  mediaBias: z22.enum(["text", "media", "mixed"]),
-  conversionBias: z22.enum(["low", "med", "high"]),
-  motion: z22.enum(["subtle", "standard", "expressive"])
-});
-var colourHexString = z22.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z22.object({
-  name: z22.string().min(1),
+var axesSchema = z21.object({
+  tone: z21.enum(["minimal", "classic", "bold"]),
+  energy: z21.enum(["calm", "vibrant"]),
+  density: z21.enum(["airy", "regular", "compact"]),
+  mediaBias: z21.enum(["text", "media", "mixed"]),
+  conversionBias: z21.enum(["low", "med", "high"]),
+  motion: z21.enum(["subtle", "standard", "expressive"])
+});
+var colourHexString = z21.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z21.object({
+  name: z21.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z22.object({
-  mode: z22.enum(["light", "dark"])
+var paletteMetaSchema = z21.object({
+  mode: z21.enum(["light", "dark"])
 });
-var paletteSchema = z22.object({
-  colors: z22.array(paletteColorSchema),
+var paletteSchema = z21.object({
+  colors: z21.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z22.object({
-  family: z22.string().min(1),
-  weight: z22.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z22.enum(["tight", "normal", "loose"]),
-  lineHeight: z22.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z21.object({
+  family: z21.string().min(1),
+  weight: z21.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z21.enum(["tight", "normal", "loose"]),
+  lineHeight: z21.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z22.enum(["md", "lg", "xl"])
+  size: z21.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z22.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z22.object({
-  weight: z22.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z22.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z21.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z21.object({
+  weight: z21.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z21.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z22.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z22.boolean().nullable().optional(),
-  colorToken: z22.string().min(1).nullable().optional()
+  lineHeight: z21.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z21.boolean().nullable().optional(),
+  colorToken: z21.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z22.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z22.boolean().nullable(),
-  colorToken: z22.string().min(1).nullable().optional()
+  case: z21.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z21.boolean().nullable(),
+  colorToken: z21.string().min(1).nullable().optional()
   // Palette token name for heading color
 });
-var proseLinkUnderlineStyleSchema = z22.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z22.enum(["auto", "fromFont", "thin", "medium", "thick"]);
-var proseLinkUnderlineOffsetSchema = z22.enum(["auto", "tight", "normal", "loose"]);
-var proseLinkStyleSchema = z22.object({
-  colorToken: z22.string().min(1).optional(),
-  hoverColorToken: z22.string().min(1).optional(),
-  underline: z22.boolean().optional(),
-  decorationColorToken: z22.string().min(1).optional(),
-  hoverDecorationColorToken: z22.string().min(1).optional(),
+var proseLinkUnderlineStyleSchema = z21.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z21.enum(["auto", "fromFont", "thin", "medium", "thick"]);
+var proseLinkUnderlineOffsetSchema = z21.enum(["auto", "tight", "normal", "loose"]);
+var proseLinkStyleSchema = z21.object({
+  colorToken: z21.string().min(1).optional(),
+  hoverColorToken: z21.string().min(1).optional(),
+  underline: z21.boolean().optional(),
+  decorationColorToken: z21.string().min(1).optional(),
+  hoverDecorationColorToken: z21.string().min(1).optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z22.enum([
+var semanticSpacingSchema = z21.enum([
   "none",
   "compact",
   "cozy",
@@ -9078,62 +9002,62 @@ var semanticSpacingSchema = z22.enum([
   "comfortable",
   "spacious"
 ]);
-var boxRoundedSchema = z22.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z22.object({
-  type: z22.enum(["none", "color", "gradient"]).nullable().optional(),
-  color: z22.string().nullable().optional(),
-  gradient: z22.string().nullable().optional(),
-  opacity: z22.number().min(0).max(1).nullable().optional()
-});
-var boxBackgroundSchema = z22.object({
-  type: z22.enum(["color", "gradient", "image"]).optional(),
-  color: z22.string().nullable().optional(),
-  gradient: z22.string().nullable().optional(),
+var boxRoundedSchema = z21.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z21.object({
+  type: z21.enum(["none", "color", "gradient"]).nullable().optional(),
+  color: z21.string().nullable().optional(),
+  gradient: z21.string().nullable().optional(),
+  opacity: z21.number().min(0).max(1).nullable().optional()
+});
+var boxBackgroundSchema = z21.object({
+  type: z21.enum(["color", "gradient", "image"]).optional(),
+  color: z21.string().nullable().optional(),
+  gradient: z21.string().nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  objectFit: z22.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z22.string().nullable().optional(),
-  position: z22.string().nullable().optional(),
-  opacity: z22.number().min(0).max(1).nullable().optional(),
+  objectFit: z21.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z21.string().nullable().optional(),
+  position: z21.string().nullable().optional(),
+  opacity: z21.number().min(0).max(1).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
-  textColor: z22.string().nullable().optional(),
-  headingColor: z22.string().nullable().optional()
+  textColor: z21.string().nullable().optional(),
+  headingColor: z21.string().nullable().optional()
 });
-var sectionStylesOverrideSchema = z22.object({
+var sectionStylesOverrideSchema = z21.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z22.enum(["none", "hero", "immersive"]).nullable().optional()
+  minHeight: z21.enum(["none", "hero", "immersive"]).nullable().optional()
 });
-var containerStylesOverrideSchema = z22.object({
+var containerStylesOverrideSchema = z21.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z22.boolean().nullable().optional(),
+  raised: z21.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z22.boolean().nullable().optional()
+  fullWidth: z21.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z22.object({
-  enabled: z22.boolean().nullable().optional(),
-  width: z22.enum(["none", "1", "2", "3"]).nullable().optional(),
-  colorToken: z22.string().nullable().optional()
+var cardBorderOverrideSchema = z21.object({
+  enabled: z21.boolean().nullable().optional(),
+  width: z21.enum(["none", "1", "2", "3"]).nullable().optional(),
+  colorToken: z21.string().nullable().optional()
 });
-var cardStylesOverrideSchema = z22.object({
+var cardStylesOverrideSchema = z21.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z22.boolean().nullable().optional(),
+  raised: z21.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional()
 });
-var blockStyleOverridesSchema = z22.object({
+var blockStyleOverridesSchema = z21.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z22.object({
-  typography: z22.object({
+var blockThemeOverrideSchema = z21.object({
+  typography: z21.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z22.enum([
+var typographyScaleSchema = z21.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -9146,9 +9070,9 @@ var typographyScaleSchema = z22.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z22.object({
+var typographySchema = z21.object({
   body: bodyTypographyStyleSchema,
-  headings: z22.object({
+  headings: z21.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -9161,41 +9085,41 @@ var typographySchema = z22.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z22.enum(["comfortable", "standard", "dense"]);
-var corners = z22.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z22.object({
-  elevation: z22.enum(["none", "low", "medium", "high"]),
-  softness: z22.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z22.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z21.enum(["comfortable", "standard", "dense"]);
+var corners = z21.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z21.object({
+  elevation: z21.enum(["none", "low", "medium", "high"]),
+  softness: z21.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z21.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z22.object({
-  width: z22.enum(["none", "hairline", "thin", "thick"]),
-  style: z22.enum(["solid", "dashed"])
+var border = z21.object({
+  width: z21.enum(["none", "hairline", "thin", "thick"]),
+  style: z21.enum(["solid", "dashed"])
 });
-var motion = z22.object({
-  level: z22.enum(["off", "low", "medium", "high"]),
-  easing: z22.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z21.object({
+  level: z21.enum(["off", "low", "medium", "high"]),
+  easing: z21.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z22.object({
+var buttonStyle = z21.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z22.object({
-  elevation: z22.enum(["none", "low", "medium", "high"]),
-  border: z22.enum(["none", "subtle", "defined"]),
+var cardStyle = z21.object({
+  elevation: z21.enum(["none", "low", "medium", "high"]),
+  border: z21.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z22.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z22.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z21.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z21.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z22.object({
+var inputStyle = z21.object({
   shape: corners,
-  border: z22.enum(["subtle", "defined", "underline"]),
-  focus: z22.enum(["glow", "ring", "underline"]),
-  label: z22.enum(["inside", "above"])
+  border: z21.enum(["subtle", "defined", "underline"]),
+  focus: z21.enum(["glow", "ring", "underline"]),
+  label: z21.enum(["inside", "above"])
 });
-var headerVariant = z22.enum(["classic", "centered", "transparent", "floating", "editorial"]);
-var headerPositioning = z22.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z22.enum([
+var headerVariant = z21.enum(["classic", "centered", "transparent", "floating", "editorial"]);
+var headerPositioning = z21.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z21.enum([
   "minimal",
   "underline",
   "underline-grow",
@@ -9204,82 +9128,82 @@ var headerNavStyle = z22.enum([
   "frosted",
   "solid"
 ]);
-var navFontWeight = z22.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z22.enum(["container", "full"]);
-var headerContainerSchema = z22.object({
-  rounded: z22.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z22.boolean().default(true),
-  shadow: z22.boolean().default(true),
-  padding: z22.enum(["sm", "md", "lg"]).default("md"),
-  tint: z22.string().nullable().optional(),
-  opacity: z22.number().min(0).max(1).default(0.12)
+var navFontWeight = z21.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z21.enum(["container", "full"]);
+var headerContainerSchema = z21.object({
+  rounded: z21.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z21.boolean().default(true),
+  shadow: z21.boolean().default(true),
+  padding: z21.enum(["sm", "md", "lg"]).default("md"),
+  tint: z21.string().nullable().optional(),
+  opacity: z21.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z22.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z21.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z22.object({
-  fontFamily: z22.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z22.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z22.boolean().default(false)
+var logoStyleSchema = z21.object({
+  fontFamily: z21.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z21.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z21.boolean().default(false)
 }).optional();
-var headerLogoTextSchema = z22.object({
-  mobileWrapLines: z22.union([z22.literal(1), z22.literal(2)]).optional(),
-  mobileMaxWidth: z22.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z22.boolean().optional()
+var headerLogoTextSchema = z21.object({
+  mobileWrapLines: z21.union([z21.literal(1), z21.literal(2)]).optional(),
+  mobileMaxWidth: z21.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z21.boolean().optional()
 }).optional();
-var navEffectsSchema = z22.object({
-  underlineGradient: z22.boolean().default(false),
-  glow: z22.boolean().default(false),
-  glowColor: z22.string().optional(),
-  neumorphic: z22.boolean().default(false)
+var navEffectsSchema = z21.object({
+  underlineGradient: z21.boolean().default(false),
+  glow: z21.boolean().default(false),
+  glowColor: z21.string().optional(),
+  neumorphic: z21.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z22.object({
+var dropdownStyleSchema = z21.object({
   // Container styling
-  background: z22.string().default("surface"),
+  background: z21.string().default("surface"),
   // color token
-  textColor: z22.string().default("text"),
+  textColor: z21.string().default("text"),
   // color token
-  borderColor: z22.string().nullable().default("border"),
+  borderColor: z21.string().nullable().default("border"),
   // null = no border
-  shadow: z22.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z22.enum(["none", "sm", "md", "lg"]).default("md"),
+  shadow: z21.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z21.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
-  hoverBackground: z22.string().nullable().optional(),
+  hoverBackground: z21.string().nullable().optional(),
   // color token, null = transparent
-  hoverTextColor: z22.string().nullable().optional(),
+  hoverTextColor: z21.string().nullable().optional(),
   // color token, null = inherit
   // Typography
-  textTransform: z22.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z22.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z22.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z21.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z21.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z21.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z22.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z21.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z22.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navContainerSchema = z22.object({
-  type: z22.enum(["none", "pill", "glass"]).default("none"),
-  tint: z22.string().nullable().optional(),
-  opacity: z22.number().min(0).max(1).default(0.15)
+var headerCtaGapSchema = z21.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navContainerSchema = z21.object({
+  type: z21.enum(["none", "pill", "glass"]).default("none"),
+  tint: z21.string().nullable().optional(),
+  opacity: z21.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z22.object({
-  type: z22.enum(["color", "gradient", "image"]),
-  color: z22.string().nullable().optional(),
+var headerBackgroundSchema = z21.object({
+  type: z21.enum(["color", "gradient", "image"]),
+  color: z21.string().nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
   image: mediaSchema.nullable().optional(),
-  textColor: z22.string().nullable().optional()
+  textColor: z21.string().nullable().optional()
 });
-var headerSchema = z22.object({
+var headerSchema = z21.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z22.boolean(),
+  shrinkOnScroll: z21.boolean(),
   maxWidth: headerMaxWidth,
   logoOverride: mediaSchema.nullable().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
-  textColor: z22.string().nullable().optional(),
+  textColor: z21.string().nullable().optional(),
   // Site title and general header text
   navStyle: headerNavStyle,
-  navColor: z22.string().nullable().optional(),
+  navColor: z21.string().nullable().optional(),
   // Nav links (inherits textColor if not set)
   navWeight: navFontWeight.default("medium"),
   // New fields for header system enhancement
@@ -9298,50 +9222,50 @@ var headerSchema = z22.object({
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z22.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z22.enum(["container", "full"]);
-var footerMode = z22.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z22.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z22.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z22.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var footerLogoPlacement = z22.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z22.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z22.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z22.object({
-  colorToken: z22.string().optional(),
-  hoverColorToken: z22.string().nullable().optional(),
-  decorationColorToken: z22.string().nullable().optional(),
-  underline: z22.boolean().optional()
-});
-var footerBottomBarSchema = z22.object({
-  enabled: z22.boolean().optional(),
-  fullBleed: z22.boolean().optional(),
+var footerVariant = z21.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z21.enum(["container", "full"]);
+var footerMode = z21.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z21.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z21.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z21.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var footerLogoPlacement = z21.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z21.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z21.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z21.object({
+  colorToken: z21.string().optional(),
+  hoverColorToken: z21.string().nullable().optional(),
+  decorationColorToken: z21.string().nullable().optional(),
+  underline: z21.boolean().optional()
+});
+var footerBottomBarSchema = z21.object({
+  enabled: z21.boolean().optional(),
+  fullBleed: z21.boolean().optional(),
   background: headerBackgroundSchema.optional(),
-  textColor: z22.string().nullable().optional(),
-  textAlign: z22.enum(["left", "center", "right"]).optional(),
+  textColor: z21.string().nullable().optional(),
+  textAlign: z21.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z22.object({
-    colorToken: z22.string().nullable().optional(),
-    width: z22.enum(["none", "thin", "medium", "thick"]).optional()
+  borderTop: z21.object({
+    colorToken: z21.string().nullable().optional(),
+    width: z21.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z22.object({
+var footerNavLayoutSchema = z21.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z22.number().int().min(1).max(6).optional()
+  columns: z21.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z22.object({
-  showLogo: z22.boolean().default(true),
-  showLogoText: z22.boolean().optional(),
+var footerLogoSchema = z21.object({
+  showLogo: z21.boolean().default(true),
+  showLogoText: z21.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z22.enum(["start", "center", "end"]).optional()
+  align: z21.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z22.object({
+var footerSchema = z21.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -9350,11 +9274,11 @@ var footerSchema = z22.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z22.boolean().optional(),
+  showLogoText: z21.boolean().optional(),
   background: headerBackgroundSchema.default({ type: "color", color: "surface" }),
   // Footer nav styling (independent from header)
   navStyle: headerNavStyle.default("minimal"),
-  navColor: z22.string().nullable().optional(),
+  navColor: z21.string().nullable().optional(),
   navWeight: navFontWeight.default("medium"),
   // Full nav link customization (overrides navStyle if set)
   navLinkStyle: navLinkStyleSchema.optional(),
@@ -9365,15 +9289,15 @@ var footerSchema = z22.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z22.enum(["tight", "compact", "default", "relaxed"]);
-var layoutSchema = z22.object({
-  containerPadding: z22.object({
+var containerPaddingPresetSchema = z21.enum(["tight", "compact", "default", "relaxed"]);
+var layoutSchema = z21.object({
+  containerPadding: z21.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z22.enum([
+var heroTypographySizeSchema = z21.enum([
   "sm",
   "base",
   "lg",
@@ -9384,14 +9308,14 @@ var heroTypographySizeSchema = z22.enum([
   "5xl",
   "6xl"
 ]);
-var heroTypographyLineHeightSchema = z22.enum(["tight", "snug", "normal", "relaxed"]);
-var heroResponsiveTypographySchema = z22.object({
+var heroTypographyLineHeightSchema = z21.enum(["tight", "snug", "normal", "relaxed"]);
+var heroResponsiveTypographySchema = z21.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z22.object({
+var heroTypographySchema = z21.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -9400,24 +9324,24 @@ var heroTypographySchema = z22.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z22.object({
+  responsive: z21.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z22.object({
+var heroSchema = z21.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var gradientsSchema = z22.object({
-  button: z22.string().min(1).nullable().optional(),
-  hero: z22.string().min(1).nullable().optional(),
-  background: z22.string().min(1).nullable().optional()
-});
-var themeSchema = z22.object({
-  name: z22.string().min(1).max(30),
-  description: z22.string().min(1).max(400),
-  rationale: z22.string().min(1).max(400),
-  siteStyleId: z22.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var gradientsSchema = z21.object({
+  button: z21.string().min(1).nullable().optional(),
+  hero: z21.string().min(1).nullable().optional(),
+  background: z21.string().min(1).nullable().optional()
+});
+var themeSchema = z21.object({
+  name: z21.string().min(1).max(30),
+  description: z21.string().min(1).max(400),
+  rationale: z21.string().min(1).max(400),
+  siteStyleId: z21.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -9444,16 +9368,16 @@ var themeSchema = z22.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z22.record(
-    z22.string(),
+  blockCustomVars: z21.record(
+    z21.string(),
     // block kind (matches data-block attribute)
-    z22.record(z22.string(), z22.string())
+    z21.record(z21.string(), z21.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: z22.record(
-    z22.string(),
+  blockOverrides: z21.record(
+    z21.string(),
     blockThemeOverrideSchema
   ).optional(),
   // Structured custom CSS rules
@@ -9489,11 +9413,11 @@ var themeSchema = z22.object({
    * }
    * ```
    */
-  styleGroups: z22.record(z22.string(), z22.array(z22.string())).optional()
+  styleGroups: z21.record(z21.string(), z21.array(z21.string())).optional()
 });
-var themesTurnSchema = z22.object({
-  message: z22.string().min(1),
-  themes: z22.array(themeSchema).length(3)
+var themesTurnSchema = z21.object({
+  message: z21.string().min(1),
+  themes: z21.array(themeSchema).length(3)
 });
 
 // ../theme-core/src/palette/variants/types.ts
@@ -9503,7 +9427,7 @@ function asPaletteVariantId(value) {
   }
   return value;
 }
-var paletteVariantIdSchema = z23.string().min(1).transform((value) => asPaletteVariantId(value));
+var paletteVariantIdSchema = z22.string().min(1).transform((value) => asPaletteVariantId(value));
 var PALETTE_TOKEN_NAMES = [
   "primary",
   "primaryForeground",
@@ -9519,19 +9443,19 @@ var PALETTE_TOKEN_NAMES = [
   "text",
   "border"
 ];
-var paletteTokenNameSchema = z23.enum(PALETTE_TOKEN_NAMES);
+var paletteTokenNameSchema = z22.enum(PALETTE_TOKEN_NAMES);
 var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z23.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var hexColorSchema = z22.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
 var variantPaletteColorSchema = paletteColorSchema.extend({
   name: paletteTokenNameSchema
 });
-var paletteVariantSchema = z23.object({
+var paletteVariantSchema = z22.object({
   id: paletteVariantIdSchema,
-  name: z23.string().min(1),
-  description: z23.string().min(1),
+  name: z22.string().min(1),
+  description: z22.string().min(1),
   tags: styleTagsSchema,
-  mode: z23.enum(["light", "dark"]),
-  colors: z23.array(variantPaletteColorSchema).min(1)
+  mode: z22.enum(["light", "dark"]),
+  colors: z22.array(variantPaletteColorSchema).min(1)
 });
 function definePaletteVariant(input) {
   return {
@@ -9543,7 +9467,7 @@ function definePaletteVariant(input) {
     colors: input.colors
   };
 }
-var paletteOverridesSchema = z23.object({
+var paletteOverridesSchema = z22.object({
   primary: hexColorSchema.optional(),
   primaryForeground: hexColorSchema.optional(),
   secondary: hexColorSchema.optional(),
@@ -10220,7 +10144,7 @@ var curatedSiteStylesById = new Map(
 );
 
 // ../theme-core/src/site-styles/designState.ts
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 
 // ../theme-core/src/site-styles/rawStyleFields.ts
 var themeV2RuntimeStyleFieldNames = [
@@ -10246,13 +10170,13 @@ var themeV2NormalEditorRawStyleFieldNameSet = new Set(
 
 // ../theme-core/src/site-styles/designState.ts
 var themeV2DesignStateSchemaVersion = 1;
-var designResolutionPolicySchema = z24.enum(["generated", "user", "admin", "sdk"]);
-var runtimeStyleFieldNameSchema = z24.enum(themeV2RuntimeStyleFieldNames);
-var nonEmptyRuntimeStyleFieldNamesSchema = z24.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
+var designResolutionPolicySchema = z23.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z23.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z23.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
   fields3[0],
   ...fields3.slice(1)
 ]);
-var heroLegibilityStrategySchema = z24.enum([
+var heroLegibilityStrategySchema = z23.enum([
   "none",
   "scrim-gradient",
   "solid-panel"
@@ -10274,66 +10198,66 @@ var userFlushTreatments = uniqueNonEmpty(
 var userFlushBleeds = uniqueNonEmpty(
   userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var contentFrameIntentSchema = z24.discriminatedUnion("kind", [
-  z24.object({ kind: z24.literal("plain") }).strict(),
-  z24.object({
-    kind: z24.literal("panel"),
-    treatment: z24.enum(userPanelTreatments)
+var contentFrameIntentSchema = z23.discriminatedUnion("kind", [
+  z23.object({ kind: z23.literal("plain") }).strict(),
+  z23.object({
+    kind: z23.literal("panel"),
+    treatment: z23.enum(userPanelTreatments)
   }).strict(),
-  z24.object({
-    kind: z24.literal("flush-panel"),
-    treatment: z24.enum(userFlushTreatments),
-    bleed: z24.enum(userFlushBleeds)
+  z23.object({
+    kind: z23.literal("flush-panel"),
+    treatment: z23.enum(userFlushTreatments),
+    bleed: z23.enum(userFlushBleeds)
   }).strict()
 ]);
-var blockDesignPlanSchema = z24.object({
-  blockId: z24.string().min(1).transform(asDesignBlockId),
-  blockKind: z24.string().min(1),
-  purpose: z24.string().min(1),
-  sectionSurface: z24.enum(userDesignOptionCatalog.sectionSurfaces),
+var blockDesignPlanSchema = z23.object({
+  blockId: z23.string().min(1).transform(asDesignBlockId),
+  blockKind: z23.string().min(1),
+  purpose: z23.string().min(1),
+  sectionSurface: z23.enum(userDesignOptionCatalog.sectionSurfaces),
   contentFrame: contentFrameIntentSchema,
-  itemSurface: z24.enum(userDesignOptionCatalog.itemSurfaces),
-  transitionAfter: z24.enum(userDesignOptionCatalog.transitions),
-  emphasis: z24.enum(userDesignOptionCatalog.emphases),
+  itemSurface: z23.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z23.enum(userDesignOptionCatalog.transitions),
+  emphasis: z23.enum(userDesignOptionCatalog.emphases),
   heroLegibility: heroLegibilityStrategySchema.optional()
 }).strict();
-var styleAuthoritySchema = z24.discriminatedUnion("kind", [
-  z24.object({
-    kind: z24.literal("theme-v2"),
+var styleAuthoritySchema = z23.discriminatedUnion("kind", [
+  z23.object({
+    kind: z23.literal("theme-v2"),
     source: designResolutionPolicySchema,
-    siteStyleId: z24.string().min(1).transform(asSiteStyleId),
-    templateId: z24.string().min(1).transform(asDesignSystemTemplateId),
-    templateVersion: z24.number().int().nonnegative(),
-    resolverVersion: z24.number().int().nonnegative()
+    siteStyleId: z23.string().min(1).transform(asSiteStyleId),
+    templateId: z23.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z23.number().int().nonnegative(),
+    resolverVersion: z23.number().int().nonnegative()
   }).strict(),
-  z24.object({
-    kind: z24.literal("legacy-raw"),
-    reason: z24.enum(["pre-theme-v2", "manual-runtime-fields"])
+  z23.object({
+    kind: z23.literal("legacy-raw"),
+    reason: z23.enum(["pre-theme-v2", "manual-runtime-fields"])
   }).strict(),
-  z24.object({
-    kind: z24.literal("advanced-detached"),
-    reason: z24.literal("detached-custom-runtime-fields")
+  z23.object({
+    kind: z23.literal("advanced-detached"),
+    reason: z23.literal("detached-custom-runtime-fields")
   }).strict()
 ]);
-var blockRuntimeStyleAuthoritySchema = z24.object({
-  unit: z24.literal("block-runtime-fields"),
-  blockId: z24.string().min(1).transform(asDesignBlockId),
+var blockRuntimeStyleAuthoritySchema = z23.object({
+  unit: z23.literal("block-runtime-fields"),
+  blockId: z23.string().min(1).transform(asDesignBlockId),
   fields: nonEmptyRuntimeStyleFieldNamesSchema,
   authority: styleAuthoritySchema
 }).strict();
-var persistedPageDesignStateV1Schema = z24.object({
-  schemaVersion: z24.literal(themeV2DesignStateSchemaVersion),
-  siteStyleId: z24.string().min(1).transform(asSiteStyleId),
-  templateId: z24.string().min(1).transform(asDesignSystemTemplateId),
-  templateVersion: z24.number().int().nonnegative(),
-  resolverVersion: z24.number().int().nonnegative(),
-  rhythmPresetId: z24.string().min(1),
-  blocks: z24.array(blockDesignPlanSchema),
-  styleAuthorities: z24.array(blockRuntimeStyleAuthoritySchema)
+var persistedPageDesignStateV1Schema = z23.object({
+  schemaVersion: z23.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z23.string().min(1).transform(asSiteStyleId),
+  templateId: z23.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z23.number().int().nonnegative(),
+  resolverVersion: z23.number().int().nonnegative(),
+  rhythmPresetId: z23.string().min(1),
+  blocks: z23.array(blockDesignPlanSchema),
+  styleAuthorities: z23.array(blockRuntimeStyleAuthoritySchema)
 }).strict();
 
 // ../theme-core/src/site-styles/generatedSchemas.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 function uniqueNonEmpty2(values) {
   const uniqueValues = [...new Set(values)];
   const firstValue = uniqueValues[0];
@@ -10351,105 +10275,105 @@ var generatedFlushTreatments = uniqueNonEmpty2(
 var generatedFlushBleeds = uniqueNonEmpty2(
   generatedDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
 );
-var generatedPanelFrameSchema = z25.object({
-  kind: z25.literal("panel"),
-  treatment: z25.enum(generatedPanelTreatments)
+var generatedPanelFrameSchema = z24.object({
+  kind: z24.literal("panel"),
+  treatment: z24.enum(generatedPanelTreatments)
 }).strict();
-var generatedFlushPanelFrameSchema = z25.object({
-  kind: z25.literal("flush-panel"),
-  treatment: z25.enum(generatedFlushTreatments),
-  bleed: z25.enum(generatedFlushBleeds)
+var generatedFlushPanelFrameSchema = z24.object({
+  kind: z24.literal("flush-panel"),
+  treatment: z24.enum(generatedFlushTreatments),
+  bleed: z24.enum(generatedFlushBleeds)
 }).strict();
-var generatedContentFrameIntentSchema = z25.discriminatedUnion("kind", [
-  z25.object({ kind: z25.literal("plain") }).strict(),
+var generatedContentFrameIntentSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("plain") }).strict(),
   generatedPanelFrameSchema,
   generatedFlushPanelFrameSchema
 ]);
-var generatedSiteStyleIdSchema = z25.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
+var generatedSiteStyleIdSchema = z24.enum(curatedSiteStyleIdValues).transform(asSiteStyleId);
 function generatedChoiceSchema(valueSchema) {
-  return z25.discriminatedUnion("kind", [
-    z25.object({
-      source: z25.literal("generated"),
-      kind: z25.literal("auto")
+  return z24.discriminatedUnion("kind", [
+    z24.object({
+      source: z24.literal("generated"),
+      kind: z24.literal("auto")
     }).strict(),
-    z25.object({
-      source: z25.literal("generated"),
-      kind: z25.literal("explicit"),
+    z24.object({
+      source: z24.literal("generated"),
+      kind: z24.literal("explicit"),
       value: valueSchema
     }).strict()
   ]);
 }
-var generatedBlockDesignIntentSchema = z25.object({
+var generatedBlockDesignIntentSchema = z24.object({
   sectionSurface: generatedChoiceSchema(
-    z25.enum(generatedDesignOptionCatalog.sectionSurfaces)
+    z24.enum(generatedDesignOptionCatalog.sectionSurfaces)
   ),
   contentFrame: generatedChoiceSchema(generatedContentFrameIntentSchema),
   itemSurface: generatedChoiceSchema(
-    z25.enum(generatedDesignOptionCatalog.itemSurfaces)
+    z24.enum(generatedDesignOptionCatalog.itemSurfaces)
   ),
   transitionAfter: generatedChoiceSchema(
-    z25.enum(generatedDesignOptionCatalog.transitions)
+    z24.enum(generatedDesignOptionCatalog.transitions)
   ),
   emphasis: generatedChoiceSchema(
-    z25.enum(generatedDesignOptionCatalog.emphases)
+    z24.enum(generatedDesignOptionCatalog.emphases)
   )
 }).strict();
-var generatedMediaCompositionIntentSchema = z25.enum([
+var generatedMediaCompositionIntentSchema = z24.enum([
   "none",
   "supporting",
   "dominant"
 ]);
-var generatedDecorativeCompositionIntentSchema = z25.enum([
+var generatedDecorativeCompositionIntentSchema = z24.enum([
   "none",
   "supporting"
 ]);
-var generatedHeroLegibilityStrategySchema = z25.enum([
+var generatedHeroLegibilityStrategySchema = z24.enum([
   "none",
   "scrim-gradient"
 ]);
-var generatedBlockMediaIntentSchema = z25.object({
+var generatedBlockMediaIntentSchema = z24.object({
   media: generatedMediaCompositionIntentSchema,
   decorative: generatedDecorativeCompositionIntentSchema,
   heroLegibility: generatedChoiceSchema(generatedHeroLegibilityStrategySchema)
 }).strict();
-var generatedBoundaryIntentSchema = z25.object({
+var generatedBoundaryIntentSchema = z24.object({
   transitionAfter: generatedChoiceSchema(
-    z25.enum(generatedDesignOptionCatalog.transitions)
+    z24.enum(generatedDesignOptionCatalog.transitions)
   )
 }).strict();
-var generatedPageDesignBlockIntentSchema = z25.object({
-  blockId: z25.string().min(1),
-  blockKind: z25.string().min(1),
-  purpose: z25.string().min(1),
+var generatedPageDesignBlockIntentSchema = z24.object({
+  blockId: z24.string().min(1),
+  blockKind: z24.string().min(1),
+  purpose: z24.string().min(1),
   design: generatedBlockDesignIntentSchema,
   mediaIntent: generatedBlockMediaIntentSchema,
   boundaryIntent: generatedBoundaryIntentSchema
 }).strict();
-var generatedPageDesignIntentSchema = z25.object({
+var generatedPageDesignIntentSchema = z24.object({
   siteStyleId: generatedSiteStyleIdSchema,
-  blocks: z25.array(generatedPageDesignBlockIntentSchema)
+  blocks: z24.array(generatedPageDesignBlockIntentSchema)
 }).strict();
 
 // ../theme-core/src/site-styles/pageDesignIntent.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 var pageDesignIntentSchemaVersion = 1;
-var pageDesignUserPinnedAppearanceChoiceSchema = z26.object({
-  kind: z26.literal("user-pinned"),
-  value: z26.string().min(1).transform(asAppearancePresetId)
+var pageDesignUserPinnedAppearanceChoiceSchema = z25.object({
+  kind: z25.literal("user-pinned"),
+  value: z25.string().min(1).transform(asAppearancePresetId)
 }).strict();
-var pageDesignUserPinnedBoundaryChoiceSchema = z26.object({
-  kind: z26.literal("user-pinned"),
-  value: z26.string().min(1).transform(asBoundaryOptionId)
+var pageDesignUserPinnedBoundaryChoiceSchema = z25.object({
+  kind: z25.literal("user-pinned"),
+  value: z25.string().min(1).transform(asBoundaryOptionId)
 }).strict();
-var pageDesignBlockLookPinSchema = z26.object({
-  blockId: z26.string().min(1).transform(asDesignBlockId),
-  blockKind: z26.string().min(1),
+var pageDesignBlockLookPinSchema = z25.object({
+  blockId: z25.string().min(1).transform(asDesignBlockId),
+  blockKind: z25.string().min(1),
   choice: pageDesignUserPinnedAppearanceChoiceSchema
 }).strict();
-var pageDesignBoundaryPinSchema = z26.object({
-  boundaryId: z26.string().min(1).transform(asDesignBoundaryId),
-  previousBlockId: z26.string().min(1).transform(asDesignBlockId),
-  nextBlockId: z26.string().min(1).transform(asDesignBlockId),
+var pageDesignBoundaryPinSchema = z25.object({
+  boundaryId: z25.string().min(1).transform(asDesignBoundaryId),
+  previousBlockId: z25.string().min(1).transform(asDesignBlockId),
+  nextBlockId: z25.string().min(1).transform(asDesignBlockId),
   choice: pageDesignUserPinnedBoundaryChoiceSchema
 }).strict().superRefine((pin, ctx) => {
   const expectedBoundaryId = makeBoundaryId(
@@ -10458,18 +10382,18 @@ var pageDesignBoundaryPinSchema = z26.object({
   );
   if (pin.boundaryId !== expectedBoundaryId) {
     ctx.addIssue({
-      code: z26.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: ["boundaryId"],
       message: `Boundary id must match previousBlockId and nextBlockId. Expected ${expectedBoundaryId}.`
     });
   }
 });
-var pageDesignIntentV1Schema = z26.object({
-  schemaVersion: z26.literal(pageDesignIntentSchemaVersion),
-  siteStyleId: z26.string().min(1).transform(asSiteStyleId),
-  pageFlowPresetId: z26.string().min(1).transform(asPageFlowPresetId),
-  blockLookPins: z26.array(pageDesignBlockLookPinSchema),
-  boundaryPins: z26.array(pageDesignBoundaryPinSchema)
+var pageDesignIntentV1Schema = z25.object({
+  schemaVersion: z25.literal(pageDesignIntentSchemaVersion),
+  siteStyleId: z25.string().min(1).transform(asSiteStyleId),
+  pageFlowPresetId: z25.string().min(1).transform(asPageFlowPresetId),
+  blockLookPins: z25.array(pageDesignBlockLookPinSchema),
+  boundaryPins: z25.array(pageDesignBoundaryPinSchema)
 }).strict().superRefine((intent, ctx) => {
   addDuplicateStringIssues(ctx, {
     values: intent.blockLookPins.map((pin) => pin.blockId),
@@ -10495,7 +10419,7 @@ function addDuplicateStringIssues(ctx, input) {
   }
   for (const duplicate of duplicates) {
     ctx.addIssue({
-      code: z26.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       path: [...input.path],
       message: `Duplicate ${input.label}: ${duplicate}.`
     });
@@ -10647,75 +10571,75 @@ var defaultComponentRuntimeRules = defineComponentRuntimeRules({
 });
 
 // ../theme-core/src/site-styles/pageDesignAuthority.ts
-import { z as z27 } from "zod";
-var nonEmptyStringSchema = z27.string().min(1);
+import { z as z26 } from "zod";
+var nonEmptyStringSchema = z26.string().min(1);
 var blockContentVersionIdSchema = nonEmptyStringSchema.transform(asBlockContentVersionId);
 var designBlockIdSchema = nonEmptyStringSchema.transform(asDesignBlockId);
 var designPageIdSchema = nonEmptyStringSchema.transform(asDesignPageId);
 var designEntryIdSchema = nonEmptyStringSchema.transform(asDesignEntryId);
-var blockOrderIndexSchema = z27.number().int().nonnegative().transform(asBlockOrderIndex);
-var publishedPageBlockSnapshotSchema = z27.object({
-  kind: z27.literal("published-block-content"),
+var blockOrderIndexSchema = z26.number().int().nonnegative().transform(asBlockOrderIndex);
+var publishedPageBlockSnapshotSchema = z26.object({
+  kind: z26.literal("published-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema,
-  identifier: z27.string().nullable(),
+  identifier: z26.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var draftPageBlockSnapshotSchema = z27.object({
-  kind: z27.literal("draft-block-content"),
+var draftPageBlockSnapshotSchema = z26.object({
+  kind: z26.literal("draft-block-content"),
   blockId: designBlockIdSchema,
   contentVersionId: blockContentVersionIdSchema.nullable(),
-  identifier: z27.string().nullable(),
+  identifier: z26.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema
 }).strict();
-var missingPageBlockSnapshotSchema = z27.object({
-  kind: z27.literal("missing-block-content"),
+var missingPageBlockSnapshotSchema = z26.object({
+  kind: z26.literal("missing-block-content"),
   blockId: designBlockIdSchema,
-  identifier: z27.string().nullable(),
+  identifier: z26.string().nullable(),
   blockKind: nonEmptyStringSchema,
   orderIndex: blockOrderIndexSchema,
-  reason: z27.enum([
+  reason: z26.enum([
     "new-block",
     "deleted-content-version",
     "unpublished-block"
   ])
 }).strict();
-var pageBlockSnapshotSchema = z27.discriminatedUnion("kind", [
+var pageBlockSnapshotSchema = z26.discriminatedUnion("kind", [
   publishedPageBlockSnapshotSchema,
   draftPageBlockSnapshotSchema,
   missingPageBlockSnapshotSchema
 ]);
-var publishedPageBlockSequenceSchema = z27.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var draftPageBlockSequenceSchema = z27.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
-var publishedPageDesignVersionDataV1Schema = z27.object({
-  schemaVersion: z27.literal(1),
-  stage: z27.literal("published"),
+var publishedPageBlockSequenceSchema = z26.array(publishedPageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var draftPageBlockSequenceSchema = z26.array(pageBlockSnapshotSchema).superRefine(validateBlockSequence);
+var publishedPageDesignVersionDataV1Schema = z26.object({
+  schemaVersion: z26.literal(1),
+  stage: z26.literal("published"),
   pageId: designPageIdSchema,
   blockSequence: publishedPageBlockSequenceSchema
 }).strict();
-var draftPageDesignVersionDataV1Schema = z27.object({
-  schemaVersion: z27.literal(1),
-  stage: z27.literal("draft"),
+var draftPageDesignVersionDataV1Schema = z26.object({
+  schemaVersion: z26.literal(1),
+  stage: z26.literal("draft"),
   pageId: designPageIdSchema,
   blockSequence: draftPageBlockSequenceSchema
 }).strict();
-var pageDesignVersionDataV1Schema = z27.discriminatedUnion("stage", [
+var pageDesignVersionDataV1Schema = z26.discriminatedUnion("stage", [
   publishedPageDesignVersionDataV1Schema,
   draftPageDesignVersionDataV1Schema
 ]);
-var contentVersionOwnerSchema = z27.discriminatedUnion("kind", [
-  z27.object({
-    kind: z27.literal("block"),
+var contentVersionOwnerSchema = z26.discriminatedUnion("kind", [
+  z26.object({
+    kind: z26.literal("block"),
     blockId: designBlockIdSchema
   }).strict(),
-  z27.object({
-    kind: z27.literal("entry"),
+  z26.object({
+    kind: z26.literal("entry"),
     entryId: designEntryIdSchema
   }).strict(),
-  z27.object({
-    kind: z27.literal("page"),
+  z26.object({
+    kind: z26.literal("page"),
     pageId: designPageIdSchema
   }).strict()
 ]);
@@ -10732,7 +10656,7 @@ function collectBlockSequenceIssues(snapshots) {
   snapshots.forEach((snapshot, index) => {
     if (seenBlockIds.has(snapshot.blockId)) {
       issues.push({
-        code: z27.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: `Duplicate blockId in page design blockSequence: ${snapshot.blockId}`,
         path: [index, "blockId"]
       });
@@ -10741,7 +10665,7 @@ function collectBlockSequenceIssues(snapshots) {
     const orderIndex = snapshot.orderIndex;
     if (seenOrderIndexes.has(orderIndex)) {
       issues.push({
-        code: z27.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: `Duplicate orderIndex in page design blockSequence: ${String(orderIndex)}`,
         path: [index, "orderIndex"]
       });
@@ -10749,7 +10673,7 @@ function collectBlockSequenceIssues(snapshots) {
     seenOrderIndexes.add(orderIndex);
     if (previousOrderIndex !== null && orderIndex <= previousOrderIndex) {
       issues.push({
-        code: z27.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: `Expected orderIndex greater than ${String(previousOrderIndex)} for blockSequence position ${String(index)}; received ${String(orderIndex)}.`,
         path: [index, "orderIndex"]
       });
@@ -10802,7 +10726,7 @@ var pageFlowPresets = [
 ];
 
 // ../theme-core/src/site-styles/tokenRecipes.ts
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 var themeTokenRecipeOptions = {
   palette: ["brand-led", "warm-neutral", "high-contrast", "soft-natural"],
   contrast: ["standard", "strong", "maximum"],
@@ -10817,14 +10741,14 @@ var themeTokenRecipeOptions = {
   spacing: ["compact", "regular", "airy"],
   motion: ["none", "subtle", "expressive"]
 };
-var themeTokenRecipesSchema = z28.object({
-  palette: z28.enum(themeTokenRecipeOptions.palette),
-  contrast: z28.enum(themeTokenRecipeOptions.contrast),
-  radius: z28.enum(themeTokenRecipeOptions.radius),
-  shadow: z28.enum(themeTokenRecipeOptions.shadow),
-  typography: z28.enum(themeTokenRecipeOptions.typography),
-  spacing: z28.enum(themeTokenRecipeOptions.spacing),
-  motion: z28.enum(themeTokenRecipeOptions.motion)
+var themeTokenRecipesSchema = z27.object({
+  palette: z27.enum(themeTokenRecipeOptions.palette),
+  contrast: z27.enum(themeTokenRecipeOptions.contrast),
+  radius: z27.enum(themeTokenRecipeOptions.radius),
+  shadow: z27.enum(themeTokenRecipeOptions.shadow),
+  typography: z27.enum(themeTokenRecipeOptions.typography),
+  spacing: z27.enum(themeTokenRecipeOptions.spacing),
+  motion: z27.enum(themeTokenRecipeOptions.motion)
 });
 
 // ../blocks/src/system/designCapabilities.ts
@@ -13101,26 +13025,26 @@ function sectionState(opts) {
 }
 
 // ../blocks/src/system/fragments/types.ts
-import { z as z29 } from "zod";
+import { z as z28 } from "zod";
 var FRAGMENT_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
 var FIELD_ID_PATTERN = /^[a-z][a-zA-Z0-9_-]*$/;
-var dataLoaderSchema = z29.object({
-  endpoint: z29.string().min(1, "Fragment data loader requires an endpoint"),
-  params: z29.record(z29.string(), z29.unknown()).default({}),
-  mode: z29.enum(["server", "client"]).default("server")
+var dataLoaderSchema = z28.object({
+  endpoint: z28.string().min(1, "Fragment data loader requires an endpoint"),
+  params: z28.record(z28.string(), z28.unknown()).default({}),
+  mode: z28.enum(["server", "client"]).default("server")
 });
-var fragmentDataSchema = z29.object({
-  key: z29.string().min(1, "Fragment data key is required"),
+var fragmentDataSchema = z28.object({
+  key: z28.string().min(1, "Fragment data key is required"),
   loader: dataLoaderSchema.optional()
 });
-var fragmentConfigSchema = z29.object({
-  id: z29.string().min(1, "Fragment id is required").regex(FRAGMENT_ID_PATTERN, "Fragment id must be alphanumeric with optional . _ - separators"),
-  title: z29.string().optional(),
-  description: z29.string().optional(),
-  category: z29.enum(["content", "media", "interactive", "layout"]).optional(),
-  icon: z29.string().optional(),
+var fragmentConfigSchema = z28.object({
+  id: z28.string().min(1, "Fragment id is required").regex(FRAGMENT_ID_PATTERN, "Fragment id must be alphanumeric with optional . _ - separators"),
+  title: z28.string().optional(),
+  description: z28.string().optional(),
+  category: z28.enum(["content", "media", "interactive", "layout"]).optional(),
+  icon: z28.string().optional(),
   fields: fieldSchema.array().default([]),
-  layout: z29.union([NodeSchema, NodeSchema.array()]).transform((value) => Array.isArray(value) ? value : [value]),
+  layout: z28.union([NodeSchema, NodeSchema.array()]).transform((value) => Array.isArray(value) ? value : [value]),
   data: fragmentDataSchema.optional()
 });
 var FragmentConfigError = class extends Error {
@@ -15770,7 +15694,7 @@ var bodyTextBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/blog-post.tsx
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 var composition = composeFragments([{ fragment: blogFeaturedPostFragment }]);
 var blogPostLayout = section(
   { background: "background", className: "rb-px-6 rb-py-12" },
@@ -15799,17 +15723,17 @@ var blogPostManifest = createBlockManifest({
   additionalFields: composition.fields,
   layout: blogPostLayout
 });
-var blogPostDataSchema = z30.object({
-  id: z30.string(),
-  title: z30.string(),
-  slug: z30.string(),
-  path: z30.string(),
-  excerpt: z30.string().nullable().optional(),
-  image: z30.object({
-    url: z30.string().optional().nullable(),
-    alt: z30.string().optional().nullable()
+var blogPostDataSchema = z29.object({
+  id: z29.string(),
+  title: z29.string(),
+  slug: z29.string(),
+  path: z29.string(),
+  excerpt: z29.string().nullable().optional(),
+  image: z29.object({
+    url: z29.string().optional().nullable(),
+    alt: z29.string().optional().nullable()
   }).nullable().optional(),
-  publishedAt: z30.string().nullable().optional()
+  publishedAt: z29.string().nullable().optional()
 });
 var blogPostBlockDefinition = {
   manifest: blogPostManifest,
@@ -15818,7 +15742,7 @@ var blogPostBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/blog-listing.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 var blogListingDataLoader = {
   endpoint: "listPublishedEntries",
   params: {
@@ -16136,24 +16060,24 @@ var blogListingManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var blogPostListEntrySchema = z31.object({
-  id: z31.string(),
-  slug: z31.string(),
-  path: z31.string(),
-  title: z31.string(),
-  excerpt: z31.string().nullable().optional(),
-  publishedAt: z31.string().nullable().optional(),
-  updatedAt: z31.string(),
-  status: z31.string(),
-  image: z31.object({
-    url: z31.string(),
-    alt: z31.string().nullable().optional()
+var blogPostListEntrySchema = z30.object({
+  id: z30.string(),
+  slug: z30.string(),
+  path: z30.string(),
+  title: z30.string(),
+  excerpt: z30.string().nullable().optional(),
+  publishedAt: z30.string().nullable().optional(),
+  updatedAt: z30.string(),
+  status: z30.string(),
+  image: z30.object({
+    url: z30.string(),
+    alt: z30.string().nullable().optional()
   }).nullable().optional()
 });
 var blogListingBlockDefinition = {
   manifest: blogListingManifest,
   dataSchemas: {
-    posts: z31.array(blogPostListEntrySchema).optional()
+    posts: z30.array(blogPostListEntrySchema).optional()
   },
   dataLoaders: {
     posts: blogListingDataLoader
@@ -16217,10 +16141,10 @@ var singleButtonBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/form.tsx
-import { z as z33 } from "zod";
+import { z as z32 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/form.interactive.ts
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 
 // ../blocks/src/contracts/runtime.ts
 function decodeSuccess(value) {
@@ -16268,14 +16192,14 @@ function defineClientOwnedBlockRuntime(runtime) {
 }
 
 // ../blocks/src/contracts/islands.ts
-function isObjectRecord2(value) {
+function isObjectRecord(value) {
   return typeof value === "object" && value !== null;
 }
 function pickRecordKeys(source, keys) {
   return Object.fromEntries(keys.map((key) => [key, source[key]]));
 }
 function expectEncodedRecord(value, label) {
-  if (isObjectRecord2(value)) {
+  if (isObjectRecord(value)) {
     return value;
   }
   throw new Error(`Expected ${label} codec to encode an object`);
@@ -16307,7 +16231,7 @@ function createInteractiveIslandCodec(options) {
       };
     },
     decode: (input) => {
-      if (!isObjectRecord2(input)) {
+      if (!isObjectRecord(input)) {
         return decodeFailure([{ path: [], message: "Expected island props object" }]);
       }
       const metaResult = options.meta.decode(pickRecordKeys(input, options.metaKeys));
@@ -16319,7 +16243,7 @@ function createInteractiveIslandCodec(options) {
         });
       }
       const renderInput = input.render;
-      if (!isObjectRecord2(renderInput)) {
+      if (!isObjectRecord(renderInput)) {
         renderIssues.push({
           path: ["render"],
           message: "Expected render object"
@@ -16385,75 +16309,75 @@ function groupFormFields(fields3) {
 }
 
 // ../blocks/src/system/runtime/nodes/form.interactive.ts
-var formFieldSchema = z32.object({
-  id: z32.string(),
-  label: z32.string().optional(),
-  type: z32.string().optional(),
-  required: z32.boolean().optional(),
-  placeholder: z32.string().optional(),
-  helpText: z32.string().optional(),
-  layout: z32.object({
-    width: z32.enum(["full", "half"]).optional()
+var formFieldSchema = z31.object({
+  id: z31.string(),
+  label: z31.string().optional(),
+  type: z31.string().optional(),
+  required: z31.boolean().optional(),
+  placeholder: z31.string().optional(),
+  helpText: z31.string().optional(),
+  layout: z31.object({
+    width: z31.enum(["full", "half"]).optional()
   }).optional(),
-  rows: z32.number().optional(),
-  options: z32.array(z32.object({
-    value: z32.string(),
-    label: z32.string()
+  rows: z31.number().optional(),
+  options: z31.array(z31.object({
+    value: z31.string(),
+    label: z31.string()
   })).optional(),
-  multiple: z32.boolean().optional(),
-  minLength: z32.number().optional(),
-  maxLength: z32.number().optional(),
-  pattern: z32.string().optional(),
-  min: z32.number().optional(),
-  max: z32.number().optional()
-});
-var formRecordSchema = z32.object({
-  id: z32.string(),
-  schemaJson: z32.object({
-    fields: z32.array(formFieldSchema).optional()
+  multiple: z31.boolean().optional(),
+  minLength: z31.number().optional(),
+  maxLength: z31.number().optional(),
+  pattern: z31.string().optional(),
+  min: z31.number().optional(),
+  max: z31.number().optional()
+});
+var formRecordSchema = z31.object({
+  id: z31.string(),
+  schemaJson: z31.object({
+    fields: z31.array(formFieldSchema).optional()
   }).optional()
 });
-var formFieldGroupSchema = z32.discriminatedUnion("type", [
-  z32.object({
-    type: z32.literal("single"),
-    key: z32.string(),
+var formFieldGroupSchema = z31.discriminatedUnion("type", [
+  z31.object({
+    type: z31.literal("single"),
+    key: z31.string(),
     field: formFieldSchema
   }),
-  z32.object({
-    type: z32.literal("row"),
-    key: z32.string(),
-    fields: z32.tuple([formFieldSchema, formFieldSchema])
+  z31.object({
+    type: z31.literal("row"),
+    key: z31.string(),
+    fields: z31.tuple([formFieldSchema, formFieldSchema])
   })
 ]);
-var formSourceSchema = z32.object({
+var formSourceSchema = z31.object({
   value: formRecordSchema.optional(),
-  siteId: z32.string().optional(),
-  apiBaseUrl: z32.string().optional(),
-  submitLabel: z32.string().optional(),
-  successMessage: z32.string().nullable().optional(),
-  className: z32.string().optional(),
-  spamProtectionEnabled: z32.boolean().optional()
-});
-var formDisplaySchema = z32.object({
-  kind: z32.literal("form"),
-  state: z32.enum(["missing", "ready"]),
-  className: z32.string().nullable(),
-  formId: z32.string().nullable(),
-  submitLabel: z32.string(),
-  successMessage: z32.string().nullable(),
+  siteId: z31.string().optional(),
+  apiBaseUrl: z31.string().optional(),
+  submitLabel: z31.string().optional(),
+  successMessage: z31.string().nullable().optional(),
+  className: z31.string().optional(),
+  spamProtectionEnabled: z31.boolean().optional()
+});
+var formDisplaySchema = z31.object({
+  kind: z31.literal("form"),
+  state: z31.enum(["missing", "ready"]),
+  className: z31.string().nullable(),
+  formId: z31.string().nullable(),
+  submitLabel: z31.string(),
+  successMessage: z31.string().nullable(),
   form: formRecordSchema.nullable(),
-  groups: z32.array(formFieldGroupSchema)
+  groups: z31.array(formFieldGroupSchema)
 });
-var formHydrationSchema = z32.object({
-  spamProtectionEnabled: z32.boolean().optional()
+var formHydrationSchema = z31.object({
+  spamProtectionEnabled: z31.boolean().optional()
 });
-var formRenderSchema = z32.object({
+var formRenderSchema = z31.object({
   display: formDisplaySchema,
   hydration: formHydrationSchema
 });
-var formIslandMetaCodec = createZodCodec(z32.object({
-  siteId: z32.string().optional(),
-  apiBaseUrl: z32.string().optional()
+var formIslandMetaCodec = createZodCodec(z31.object({
+  siteId: z31.string().optional(),
+  apiBaseUrl: z31.string().optional()
 }));
 var formIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildFormDisplay(source) {
@@ -16528,16 +16452,16 @@ var formManifest = createBlockManifest({
   tags: ["form", "contact", "input", "submit", "fields", "signup", "lead-capture"],
   icon: "FormInput"
 });
-var formDataSchema = z33.object({
-  id: z33.string(),
-  siteId: z33.string(),
-  userId: z33.string(),
-  name: z33.string(),
-  slug: z33.string(),
-  schemaJson: z33.any(),
-  settingsJson: z33.any().optional(),
-  createdAt: z33.string(),
-  updatedAt: z33.string()
+var formDataSchema = z32.object({
+  id: z32.string(),
+  siteId: z32.string(),
+  userId: z32.string(),
+  name: z32.string(),
+  slug: z32.string(),
+  schemaJson: z32.any(),
+  settingsJson: z32.any().optional(),
+  createdAt: z32.string(),
+  updatedAt: z32.string()
 });
 var formBlockDefinition = {
   manifest: formManifest,
@@ -16583,7 +16507,7 @@ var faqBlockDefinition = {
 };
 
 // ../blocks/src/system/transforms/registry/formatting.ts
-import { z as z34 } from "zod";
+import { z as z33 } from "zod";
 var uppercaseTransform = {
   id: "string.uppercase",
   kind: "string",
@@ -16594,7 +16518,7 @@ var fallbackTransform = {
   id: "value.fallback",
   kind: "formatter",
   summary: "Provide fallback when value is null or undefined",
-  schema: z34.object({ fallback: z34.unknown() }),
+  schema: z33.object({ fallback: z33.unknown() }),
   run: (value, options) => value === null || value === void 0 || value === "" ? options.fallback : value
 };
 var dateFormatShort = {
@@ -16641,8 +16565,8 @@ var jsonArrayTransform = {
     return "";
   }
 };
-var marqueeLoopOptionsSchema = z34.object({
-  minItems: z34.number().int().min(1).default(10)
+var marqueeLoopOptionsSchema = z33.object({
+  minItems: z33.number().int().min(1).default(10)
 });
 var marqueeLoopTransform = {
   id: "array.marqueeLoop",
@@ -16670,7 +16594,7 @@ var formattingTransforms = [
 ];
 
 // ../blocks/src/system/transforms/registry/ui.ts
-import { z as z35 } from "zod";
+import { z as z34 } from "zod";
 var joinClasses3 = (parts) => parts.filter(
   (part) => typeof part === "string" && part.trim().length > 0
 ).join(" ").replace(/\s+/g, " ").trim();
@@ -16730,8 +16654,8 @@ function getNavStyleClasses(navStyle) {
       return baseClasses;
   }
 }
-var headerNavClassOptionsSchema = z35.object({
-  base: z35.string().optional()
+var headerNavClassOptionsSchema = z34.object({
+  base: z34.string().optional()
 });
 var headerNavLinkClassTransform = {
   id: "ui.headerNavLinkClass",
@@ -16814,8 +16738,8 @@ function resolveHeroContentMaxWidth(content) {
     return raw;
   return "default";
 }
-var heroContentWrapperClassSchema = z35.object({
-  base: z35.string().optional()
+var heroContentWrapperClassSchema = z34.object({
+  base: z34.string().optional()
 });
 var heroContentWrapperClassTransform = {
   id: "ui.heroContentWrapperClass",
@@ -16857,8 +16781,8 @@ var heroStackJustifyFromVerticalAlignmentTransform = {
     return vertical === "top" ? "start" : vertical === "bottom" ? "end" : "center";
   }
 };
-var heroGridClassFromVerticalAlignmentSchema = z35.object({
-  base: z35.string()
+var heroGridClassFromVerticalAlignmentSchema = z34.object({
+  base: z34.string()
 });
 var heroGridClassFromVerticalAlignmentTransform = {
   id: "ui.heroGridClassFromVerticalAlignment",
@@ -16872,10 +16796,10 @@ var heroGridClassFromVerticalAlignmentTransform = {
     return joinClasses3([options.base, itemsClass]);
   }
 };
-var imageFragmentClassOptionsSchema = z35.object({
-  base: z35.string(),
-  whenAuto: z35.string(),
-  whenFixed: z35.string()
+var imageFragmentClassOptionsSchema = z34.object({
+  base: z34.string(),
+  whenAuto: z34.string(),
+  whenFixed: z34.string()
 });
 var imageFragmentClassTransform = {
   id: "ui.imageFragmentClass",
@@ -16891,9 +16815,9 @@ var imageFragmentClassTransform = {
     ]);
   }
 };
-var imageFragmentSizeOptionsSchema = z35.object({
-  max: z35.number().int().positive().default(1920),
-  quality: z35.number().int().min(1).max(100).default(85)
+var imageFragmentSizeOptionsSchema = z34.object({
+  max: z34.number().int().positive().default(1920),
+  quality: z34.number().int().min(1).max(100).default(85)
 });
 var imageFragmentSizeTransform = {
   id: "ui.imageFragmentSize",
@@ -16913,9 +16837,9 @@ var imageFragmentSizeTransform = {
     return { width, height, quality, resize: "cover" };
   }
 };
-var conditionalClassOptionsSchema = z35.object({
-  whenTrue: z35.string(),
-  whenFalse: z35.string()
+var conditionalClassOptionsSchema = z34.object({
+  whenTrue: z34.string(),
+  whenFalse: z34.string()
 });
 var conditionalClassTransform = {
   id: "ui.conditionalClass",
@@ -16927,9 +16851,9 @@ var conditionalClassTransform = {
     return isTrue ? options.whenTrue : options.whenFalse;
   }
 };
-var twoColumnContainerClassOptionsSchema = z35.object({
-  base: z35.string(),
-  reverseClass: z35.string()
+var twoColumnContainerClassOptionsSchema = z34.object({
+  base: z34.string(),
+  reverseClass: z34.string()
 });
 var twoColumnContainerClassTransform = {
   id: "ui.twoColumnContainerClass",
@@ -16944,8 +16868,8 @@ var twoColumnContainerClassTransform = {
     ]);
   }
 };
-var twoColumnFlexBasisOptionsSchema = z35.object({
-  side: z35.enum(["image", "text"])
+var twoColumnFlexBasisOptionsSchema = z34.object({
+  side: z34.enum(["image", "text"])
 });
 var twoColumnFlexBasisTransform = {
   id: "ui.twoColumnFlexBasis",
@@ -16959,8 +16883,8 @@ var twoColumnFlexBasisTransform = {
     return `${percent}%`;
   }
 };
-var columnsDesktopSpanClassOptionsSchema = z35.object({
-  base: z35.string().optional()
+var columnsDesktopSpanClassOptionsSchema = z34.object({
+  base: z34.string().optional()
 });
 var columnsDesktopSpanClassTransform = {
   id: "ui.columnsDesktopSpanClass",
@@ -17002,8 +16926,8 @@ var columnsColsAtTransform = {
   id: "ui.columnsColsAt",
   kind: "formatter",
   summary: "Resolve columns count for a specific breakpoint",
-  schema: z35.object({
-    breakpoint: z35.enum(["mobile", "md", "lg", "xl"])
+  schema: z34.object({
+    breakpoint: z34.enum(["mobile", "md", "lg", "xl"])
   }),
   run: (value, options) => {
     const content = asPartialObject(value) ?? {};
@@ -17127,7 +17051,7 @@ var uiTransforms = [
 ];
 
 // ../blocks/src/system/transforms/registry/layout.ts
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 
 // ../theme-core/src/palette/utils/colorConversion.ts
 var mod = (a, n) => (a % n + n) % n;
@@ -17198,10 +17122,10 @@ function featuresFromHex(hex) {
 var joinClasses4 = (parts) => parts.filter(
   (part) => typeof part === "string" && part.trim().length > 0
 ).join(" ").replace(/\s+/g, " ").trim();
-var maxWidthClassSchema = z36.object({
-  base: z36.string().optional(),
-  container: z36.string().optional(),
-  full: z36.string().optional()
+var maxWidthClassSchema = z35.object({
+  base: z35.string().optional(),
+  container: z35.string().optional(),
+  full: z35.string().optional()
 });
 var maxWidthClassTransform = {
   id: "layout.maxWidthClass",
@@ -17217,11 +17141,11 @@ var maxWidthClassTransform = {
     return joinClasses4([base, chosen]);
   }
 };
-var headerRootClassSchema = z36.object({
-  base: z36.string().optional(),
-  sticky: z36.string().optional(),
-  stickyTransparent: z36.string().optional(),
-  invert: z36.string().optional()
+var headerRootClassSchema = z35.object({
+  base: z35.string().optional(),
+  sticky: z35.string().optional(),
+  stickyTransparent: z35.string().optional(),
+  invert: z35.string().optional()
 });
 function resolveBackgroundVisualStyles(backgroundColor, tokens, defaultToken = "surface") {
   const backgroundToken = typeof backgroundColor === "string" && backgroundColor.trim().length > 0 ? backgroundColor : defaultToken;
@@ -17342,11 +17266,11 @@ var headerRootClassTransform = {
     return joinClasses4(classes);
   }
 };
-var footerRootClassSchema = z36.object({
-  base: z36.string().optional(),
-  surface: z36.string().optional(),
-  tokenPrefix: z36.string().optional(),
-  transparent: z36.string().optional()
+var footerRootClassSchema = z35.object({
+  base: z35.string().optional(),
+  surface: z35.string().optional(),
+  tokenPrefix: z35.string().optional(),
+  transparent: z35.string().optional()
 });
 var footerRootClassTransform = {
   id: "layout.footerRootClass",
@@ -17450,8 +17374,8 @@ var footerAlignClassMap = {
   end: "rb-justify-end",
   "space-between": "rb-justify-between"
 };
-var footerBottomBarClassSchema = z36.object({
-  base: z36.string().optional()
+var footerBottomBarClassSchema = z35.object({
+  base: z35.string().optional()
 });
 var footerBottomBarClassTransform = {
   id: "layout.footerBottomBarClass",
@@ -17473,10 +17397,10 @@ var footerBottomBarClassTransform = {
     ]);
   }
 };
-var footerBottomBarContainerClassSchema = z36.object({
-  base: z36.string().optional(),
-  fullBleed: z36.string().optional(),
-  contained: z36.string().optional()
+var footerBottomBarContainerClassSchema = z35.object({
+  base: z35.string().optional(),
+  fullBleed: z35.string().optional(),
+  contained: z35.string().optional()
 });
 var footerBottomBarContainerClassTransform = {
   id: "layout.footerBottomBarContainerClass",
@@ -17561,8 +17485,8 @@ var footerSplitNavSingleClassTransform = {
     ]);
   }
 };
-var footerLogoClassSchema = z36.object({
-  base: z36.string().optional()
+var footerLogoClassSchema = z35.object({
+  base: z35.string().optional()
 });
 var footerLogoClassTransform = {
   id: "layout.footerLogoClass",
@@ -17584,8 +17508,8 @@ var footerLogoClassTransform = {
     ]);
   }
 };
-var footerLogoMediaClassSchema = z36.object({
-  base: z36.string().optional()
+var footerLogoMediaClassSchema = z35.object({
+  base: z35.string().optional()
 });
 var footerLogoMediaClassTransform = {
   id: "layout.footerLogoMediaClass",
@@ -17639,12 +17563,12 @@ var layoutTransforms = [
 ];
 
 // ../blocks/src/system/transforms/registry/media.ts
-import { z as z37 } from "zod";
-var mediaFromUrlOptionsSchema = z37.object({
-  width: z37.number().int().positive().optional(),
-  height: z37.number().int().positive().optional(),
-  quality: z37.number().int().min(1).max(100).optional(),
-  resize: z37.enum(["cover", "contain", "fill"]).optional()
+import { z as z36 } from "zod";
+var mediaFromUrlOptionsSchema = z36.object({
+  width: z36.number().int().positive().optional(),
+  height: z36.number().int().positive().optional(),
+  quality: z36.number().int().min(1).max(100).optional(),
+  resize: z36.enum(["cover", "contain", "fill"]).optional()
 });
 function maybeBuildSupabaseTransformUrl(inputUrl, options) {
   const width = options.width;
@@ -17692,10 +17616,20 @@ var mediaFromUrl = {
 var mediaTransforms = [mediaFromUrl];
 
 // ../blocks/src/system/transforms/registry/content.ts
-import { z as z38 } from "zod";
-var supportedRichTextTokenSchema = z38.enum(["year", "site_name"]);
-var interpolateRichTextTokensOptionsSchema = z38.object({
-  tokens: z38.array(supportedRichTextTokenSchema).default(["year", "site_name"])
+import { z as z37 } from "zod";
+
+// ../blocks/src/lib/typeGuards.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// ../blocks/src/system/transforms/registry/content.ts
+var supportedRichTextTokenSchema = z37.enum(["year", "site_name"]);
+var interpolateRichTextTokensOptionsSchema = z37.object({
+  tokens: z37.array(supportedRichTextTokenSchema).default(["year", "site_name"])
 });
 var richTextTokenPattern = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
 function getSiteName(context) {
@@ -19505,7 +19439,7 @@ var mediaTextBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/appointment-booking.tsx
-import { z as z39 } from "zod";
+import { z as z38 } from "zod";
 var appointmentBookingManifest = createBlockManifest({
   id: "block.appointment-booking",
   version: "2.0.0",
@@ -19581,11 +19515,11 @@ var appointmentBookingManifest = createBlockManifest({
     })
   ]
 });
-var availabilityDataSchema = z39.object({
-  slots: z39.array(z39.object({
-    startAt: z39.string(),
-    endAt: z39.string(),
-    resourceId: z39.string()
+var availabilityDataSchema = z38.object({
+  slots: z38.array(z38.object({
+    startAt: z38.string(),
+    endAt: z38.string(),
+    resourceId: z38.string()
   }))
 });
 var appointmentBookingBlockDefinition = {
@@ -19610,13 +19544,13 @@ var appointmentBookingBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-registration.ts
-import { z as z47 } from "zod";
+import { z as z46 } from "zod";
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-import { z as z43 } from "zod";
+import { z as z42 } from "zod";
 
 // ../blocks/src/lib/media.ts
-import z40 from "zod";
+import z39 from "zod";
 var PUBLIC_DOWNLOAD_MEDIA_TYPES = [
   "document",
   "spreadsheet",
@@ -19624,52 +19558,52 @@ var PUBLIC_DOWNLOAD_MEDIA_TYPES = [
   "audio",
   "video"
 ];
-var hotspotSchema2 = z40.object({
-  x: z40.number().min(0).max(1),
-  y: z40.number().min(0).max(1),
-  radius: z40.number().optional()
-});
-var rotationSchema2 = z40.union([z40.literal(0), z40.literal(90), z40.literal(180), z40.literal(270)]);
-var rectSchema2 = z40.tuple([z40.number(), z40.number(), z40.number(), z40.number()]);
-var aspectCropSchema2 = z40.object({
-  aspect: z40.preprocess((value) => value == null ? void 0 : value, z40.string().optional()),
-  rect: z40.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-  hotspot: z40.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-  rotation: z40.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-});
-var transformSchema2 = z40.object({
-  aspectCrops: z40.preprocess((value) => {
+var hotspotSchema2 = z39.object({
+  x: z39.number().min(0).max(1),
+  y: z39.number().min(0).max(1),
+  radius: z39.number().optional()
+});
+var rotationSchema2 = z39.union([z39.literal(0), z39.literal(90), z39.literal(180), z39.literal(270)]);
+var rectSchema2 = z39.tuple([z39.number(), z39.number(), z39.number(), z39.number()]);
+var aspectCropSchema2 = z39.object({
+  aspect: z39.preprocess((value) => value == null ? void 0 : value, z39.string().optional()),
+  rect: z39.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+  hotspot: z39.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+  rotation: z39.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+});
+var transformSchema2 = z39.object({
+  aspectCrops: z39.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z40.record(z40.string(), aspectCropSchema2.catch({}))).optional(),
+  }, z39.record(z39.string(), aspectCropSchema2.catch({}))).optional(),
   rect: rectSchema2.optional(),
   hotspot: hotspotSchema2.optional(),
   rotation: rotationSchema2.optional()
 });
-var mediaBaseSchema = z40.object({
-  purpose: z40.string().optional(),
-  placeholder: z40.boolean().default(true).optional(),
-  assetId: z40.string().optional(),
-  identifier: z40.string().optional(),
-  src: z40.string().optional(),
-  alt: z40.string().optional(),
-  filename: z40.string().optional(),
-  mimeType: z40.string().optional(),
-  width: z40.number().optional(),
-  height: z40.number().optional(),
-  storageBucket: z40.string().optional(),
-  storagePath: z40.string().optional(),
+var mediaBaseSchema = z39.object({
+  purpose: z39.string().optional(),
+  placeholder: z39.boolean().default(true).optional(),
+  assetId: z39.string().optional(),
+  identifier: z39.string().optional(),
+  src: z39.string().optional(),
+  alt: z39.string().optional(),
+  filename: z39.string().optional(),
+  mimeType: z39.string().optional(),
+  width: z39.number().optional(),
+  height: z39.number().optional(),
+  storageBucket: z39.string().optional(),
+  storagePath: z39.string().optional(),
   transform: transformSchema2.optional()
 });
-var imageMediaSchema = mediaBaseSchema.extend({ type: z40.literal("image") });
-var videoMediaSchema = mediaBaseSchema.extend({ type: z40.literal("video") });
-var audioMediaSchema = mediaBaseSchema.extend({ type: z40.literal("audio") });
-var documentMediaSchema = mediaBaseSchema.extend({ type: z40.literal("document") });
-var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z40.literal("spreadsheet") });
-var archiveMediaSchema = mediaBaseSchema.extend({ type: z40.literal("archive") });
-var mediaSchema2 = z40.discriminatedUnion("type", [
+var imageMediaSchema = mediaBaseSchema.extend({ type: z39.literal("image") });
+var videoMediaSchema = mediaBaseSchema.extend({ type: z39.literal("video") });
+var audioMediaSchema = mediaBaseSchema.extend({ type: z39.literal("audio") });
+var documentMediaSchema = mediaBaseSchema.extend({ type: z39.literal("document") });
+var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z39.literal("spreadsheet") });
+var archiveMediaSchema = mediaBaseSchema.extend({ type: z39.literal("archive") });
+var mediaSchema2 = z39.discriminatedUnion("type", [
   imageMediaSchema,
   videoMediaSchema,
   audioMediaSchema,
@@ -19679,252 +19613,252 @@ var mediaSchema2 = z40.discriminatedUnion("type", [
 ]);
 
 // ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
-import { z as z41 } from "zod";
-var bookingDepositRefundPolicySchema = z41.enum([
+import { z as z40 } from "zod";
+var bookingDepositRefundPolicySchema = z40.enum([
   "refundable",
   "non_refundable"
 ]);
-var bookingInstalmentPlanSchema = z41.union([
-  z41.object({
-    kind: z41.literal("deposit_plus_one_remainder"),
-    depositAmountCents: z41.number().int().min(0),
+var bookingInstalmentPlanSchema = z40.union([
+  z40.object({
+    kind: z40.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z40.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    remainderDueCount: z41.number().int().positive(),
-    intervalUnit: z41.enum(["day", "week", "month"])
+    remainderDueCount: z40.number().int().positive(),
+    intervalUnit: z40.enum(["day", "week", "month"])
   }),
-  z41.object({
-    kind: z41.literal("deposit_plus_scheduled_instalments"),
-    depositAmountCents: z41.number().int().min(0),
+  z40.object({
+    kind: z40.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z40.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    instalmentCount: z41.number().int().positive(),
-    intervalCount: z41.number().int().positive(),
-    intervalUnit: z41.enum(["day", "week", "month"])
+    instalmentCount: z40.number().int().positive(),
+    intervalCount: z40.number().int().positive(),
+    intervalUnit: z40.enum(["day", "week", "month"])
   }),
-  z41.object({
-    kind: z41.literal("equal_scheduled_instalments"),
-    instalmentCount: z41.number().int().positive(),
-    intervalCount: z41.number().int().positive(),
-    intervalUnit: z41.enum(["day", "week", "month"])
+  z40.object({
+    kind: z40.literal("equal_scheduled_instalments"),
+    instalmentCount: z40.number().int().positive(),
+    intervalCount: z40.number().int().positive(),
+    intervalUnit: z40.enum(["day", "week", "month"])
   })
 ]);
-var bookingFlexibleBalanceDueDateRuleSchema = z41.union([
-  z41.object({
-    kind: z41.literal("relative_to_start_date"),
-    daysBeforeStart: z41.number().int().positive()
+var bookingFlexibleBalanceDueDateRuleSchema = z40.union([
+  z40.object({
+    kind: z40.literal("relative_to_start_date"),
+    daysBeforeStart: z40.number().int().positive()
   }),
-  z41.object({
-    kind: z41.literal("fixed_calendar_date"),
-    dueAt: z41.string().datetime()
+  z40.object({
+    kind: z40.literal("fixed_calendar_date"),
+    dueAt: z40.string().datetime()
   })
 ]);
-var bookingFlexibleBalanceConfigSchema = z41.object({
-  upfrontAmountCents: z41.number().int().min(0),
+var bookingFlexibleBalanceConfigSchema = z40.object({
+  upfrontAmountCents: z40.number().int().min(0),
   dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
   depositRefundability: bookingDepositRefundPolicySchema
 });
-var blockBookingPaymentCollectionOptionSchema = z41.union([
-  z41.object({
-    kind: z41.literal("upfront")
+var blockBookingPaymentCollectionOptionSchema = z40.union([
+  z40.object({
+    kind: z40.literal("upfront")
   }),
-  z41.object({
-    kind: z41.literal("deferred_manual")
+  z40.object({
+    kind: z40.literal("deferred_manual")
   }),
-  z41.object({
-    kind: z41.literal("instalment_plan"),
+  z40.object({
+    kind: z40.literal("instalment_plan"),
     plan: bookingInstalmentPlanSchema
   }),
-  z41.object({
-    kind: z41.literal("flexible_balance"),
+  z40.object({
+    kind: z40.literal("flexible_balance"),
     config: bookingFlexibleBalanceConfigSchema
   })
 ]);
-var blockBookingPaymentTermsSchema = z41.object({
-  allowedOptions: z41.array(blockBookingPaymentCollectionOptionSchema).min(1)
+var blockBookingPaymentTermsSchema = z40.object({
+  allowedOptions: z40.array(blockBookingPaymentCollectionOptionSchema).min(1)
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z42 } from "zod";
-var courseVenueSchema = z42.object({
-  id: z42.string(),
-  name: z42.string(),
-  address: z42.string().nullable()
+import { z as z41 } from "zod";
+var courseVenueSchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  address: z41.string().nullable()
+});
+var courseSessionSchema = z41.object({
+  id: z41.string(),
+  startsAt: z41.string(),
+  endsAt: z41.string(),
+  timeZone: z41.string(),
+  capacityOverride: z41.number().nullable().optional(),
+  overrides: z41.record(z41.string(), z41.unknown()).nullable().optional()
+});
+var courseTeamMemberSummarySchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  roleLabel: z41.string().nullable(),
+  summary: z41.string().nullable(),
+  profilePath: z41.string().nullable()
+});
+var coursePricingOptionSchema = z41.object({
+  id: z41.string(),
+  name: z41.string(),
+  description: z41.string().nullable(),
+  priceAmount: z41.number(),
+  isActive: z41.boolean(),
+  sortOrder: z41.number(),
+  capacityLimit: z41.number().nullable(),
+  saleStartsAt: z41.string().nullable(),
+  saleEndsAt: z41.string().nullable(),
+  attendanceScope: z41.enum(["in_person", "online", "both"]).nullable().optional()
+});
+var coursePricingSchema = z41.object({
+  bookingRequirement: z41.enum(["none", "required"]),
+  pricingStrategy: z41.enum(["free", "single", "tiered"]),
+  currency: z41.string(),
+  singlePriceAmount: z41.number().nullable(),
+  paymentTerms: blockBookingPaymentTermsSchema,
+  options: z41.array(coursePricingOptionSchema)
+});
+var publicCourseSchema = z41.object({
+  id: z41.string(),
+  title: z41.string(),
+  slug: z41.string(),
+  description: z41.unknown().nullable(),
+  teamMembers: z41.array(courseTeamMemberSummarySchema).optional(),
+  enrollmentOpen: z41.boolean(),
+  pricing: coursePricingSchema.optional(),
+  priceCents: z41.number().nullable(),
+  currency: z41.string(),
+  paymentTerms: blockBookingPaymentTermsSchema,
+  enrollmentCapacity: z41.number().nullable(),
+  acceptsMemberships: z41.boolean(),
+  status: z41.enum(["active", "draft", "cancelled"]),
+  sessionsCount: z41.number(),
+  enrolledCount: z41.number(),
+  availableSpots: z41.number().nullable(),
+  sessions: z41.array(courseSessionSchema),
+  venue: courseVenueSchema.nullable(),
+  contentEntryId: z41.string().nullable()
 });
-var courseSessionSchema = z42.object({
+var publicCoursesArraySchema = z41.array(publicCourseSchema);
+
+// ../blocks/src/system/blocks/events/shared/schemas.ts
+var eventPresetSchema = z42.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z42.enum(["recurring", "oneOff"]);
+var eventVenueSchema = z42.object({
   id: z42.string(),
-  startsAt: z42.string(),
-  endsAt: z42.string(),
-  timeZone: z42.string(),
-  capacityOverride: z42.number().nullable().optional(),
-  overrides: z42.record(z42.string(), z42.unknown()).nullable().optional()
+  name: z42.string(),
+  address: z42.string().nullable(),
+  location: z42.object({
+    lat: z42.number(),
+    lng: z42.number()
+  }).nullable()
 });
-var courseTeamMemberSummarySchema = z42.object({
+var eventCategorySchema = z42.object({
   id: z42.string(),
   name: z42.string(),
-  roleLabel: z42.string().nullable(),
-  summary: z42.string().nullable(),
-  profilePath: z42.string().nullable()
+  color: z42.string().nullable()
 });
-var coursePricingOptionSchema = z42.object({
+var pricingTypeSchema = z42.enum(["free", "paid", "pass_only", "membership_only"]);
+var accessRestrictionSchema = z42.enum(["none", "category"]);
+var eventPricingModeSchema = z42.enum(["single", "ticket_types"]);
+var publicEventAttendanceModeSchema = z42.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z42.object({
+  mode: publicEventAttendanceModeSchema,
+  capacity: z42.number().nullable(),
+  registeredCount: z42.number(),
+  availableSpots: z42.number().nullable(),
+  waitlistEnabled: z42.boolean()
+});
+var publicEventTicketTypeAvailabilitySchema = z42.union([
+  z42.object({
+    kind: z42.literal("available"),
+    remainingCapacity: z42.number().nullable()
+  }),
+  z42.object({
+    kind: z42.literal("unavailable"),
+    reason: z42.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+    remainingCapacity: z42.number().nullable()
+  })
+]);
+var publicEventTicketTypeSchema = z42.object({
   id: z42.string(),
+  siteId: z42.string(),
+  eventSeriesId: z42.string(),
   name: z42.string(),
   description: z42.string().nullable(),
   priceAmount: z42.number(),
   isActive: z42.boolean(),
   sortOrder: z42.number(),
+  capacityMode: z42.enum(["limited", "unlimited"]),
   capacityLimit: z42.number().nullable(),
+  attendanceScope: z42.enum(["in_person", "online", "both"]).optional(),
   saleStartsAt: z42.string().nullable(),
   saleEndsAt: z42.string().nullable(),
-  attendanceScope: z42.enum(["in_person", "online", "both"]).nullable().optional()
-});
-var coursePricingSchema = z42.object({
-  bookingRequirement: z42.enum(["none", "required"]),
-  pricingStrategy: z42.enum(["free", "single", "tiered"]),
-  currency: z42.string(),
-  singlePriceAmount: z42.number().nullable(),
-  paymentTerms: blockBookingPaymentTermsSchema,
-  options: z42.array(coursePricingOptionSchema)
-});
-var publicCourseSchema = z42.object({
-  id: z42.string(),
-  title: z42.string(),
-  slug: z42.string(),
-  description: z42.unknown().nullable(),
-  teamMembers: z42.array(courseTeamMemberSummarySchema).optional(),
-  enrollmentOpen: z42.boolean(),
-  pricing: coursePricingSchema.optional(),
-  priceCents: z42.number().nullable(),
-  currency: z42.string(),
-  paymentTerms: blockBookingPaymentTermsSchema,
-  enrollmentCapacity: z42.number().nullable(),
-  acceptsMemberships: z42.boolean(),
-  status: z42.enum(["active", "draft", "cancelled"]),
-  sessionsCount: z42.number(),
-  enrolledCount: z42.number(),
-  availableSpots: z42.number().nullable(),
-  sessions: z42.array(courseSessionSchema),
-  venue: courseVenueSchema.nullable(),
-  contentEntryId: z42.string().nullable()
-});
-var publicCoursesArraySchema = z42.array(publicCourseSchema);
-
-// ../blocks/src/system/blocks/events/shared/schemas.ts
-var eventPresetSchema = z43.enum(["event", "class", "workshop", "retreat", "performance"]);
-var eventScheduleScopeSchema = z43.enum(["recurring", "oneOff"]);
-var eventVenueSchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  address: z43.string().nullable(),
-  location: z43.object({
-    lat: z43.number(),
-    lng: z43.number()
-  }).nullable()
-});
-var eventCategorySchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  color: z43.string().nullable()
-});
-var pricingTypeSchema = z43.enum(["free", "paid", "pass_only", "membership_only"]);
-var accessRestrictionSchema = z43.enum(["none", "category"]);
-var eventPricingModeSchema = z43.enum(["single", "ticket_types"]);
-var publicEventAttendanceModeSchema = z43.enum(["in_person", "online"]);
-var publicEventAttendanceModeAvailabilitySchema = z43.object({
-  mode: publicEventAttendanceModeSchema,
-  capacity: z43.number().nullable(),
-  registeredCount: z43.number(),
-  availableSpots: z43.number().nullable(),
-  waitlistEnabled: z43.boolean()
-});
-var publicEventTicketTypeAvailabilitySchema = z43.union([
-  z43.object({
-    kind: z43.literal("available"),
-    remainingCapacity: z43.number().nullable()
-  }),
-  z43.object({
-    kind: z43.literal("unavailable"),
-    reason: z43.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
-    remainingCapacity: z43.number().nullable()
-  })
-]);
-var publicEventTicketTypeSchema = z43.object({
-  id: z43.string(),
-  siteId: z43.string(),
-  eventSeriesId: z43.string(),
-  name: z43.string(),
-  description: z43.string().nullable(),
-  priceAmount: z43.number(),
-  isActive: z43.boolean(),
-  sortOrder: z43.number(),
-  capacityMode: z43.enum(["limited", "unlimited"]),
-  capacityLimit: z43.number().nullable(),
-  attendanceScope: z43.enum(["in_person", "online", "both"]).optional(),
-  saleStartsAt: z43.string().nullable(),
-  saleEndsAt: z43.string().nullable(),
   availability: publicEventTicketTypeAvailabilitySchema,
-  createdAt: z43.string(),
-  updatedAt: z43.string()
+  createdAt: z42.string(),
+  updatedAt: z42.string()
 });
-var publicTeamMemberSummarySchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  roleLabel: z43.string().nullable(),
-  summary: z43.string().nullable(),
-  profilePath: z43.string().nullable()
+var publicTeamMemberSummarySchema = z42.object({
+  id: z42.string(),
+  name: z42.string(),
+  roleLabel: z42.string().nullable(),
+  summary: z42.string().nullable(),
+  profilePath: z42.string().nullable()
 });
-var publicEventSchema = z43.object({
-  kind: z43.enum(["event", "course_session"]).optional(),
+var publicEventSchema = z42.object({
+  kind: z42.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
-  id: z43.string(),
-  occurrenceId: z43.string(),
-  seriesId: z43.string(),
-  title: z43.string(),
-  description: z43.string().nullable(),
-  presentation: z43.object({
-    cardTitleOverride: z43.string().nullable().optional(),
-    summary: z43.string().nullable().optional(),
+  id: z42.string(),
+  occurrenceId: z42.string(),
+  seriesId: z42.string(),
+  title: z42.string(),
+  description: z42.string().nullable(),
+  presentation: z42.object({
+    cardTitleOverride: z42.string().nullable().optional(),
+    summary: z42.string().nullable().optional(),
     image: mediaSchema2.nullable().optional(),
-    tags: z43.array(z43.string()).optional(),
-    ctaLabel: z43.string().nullable().optional(),
-    badges: z43.array(z43.string()).optional()
+    tags: z42.array(z42.string()).optional(),
+    ctaLabel: z42.string().nullable().optional(),
+    badges: z42.array(z42.string()).optional()
   }).optional(),
-  slug: z43.string(),
-  path: z43.string(),
-  requiresRegistration: z43.boolean(),
-  deliveryMode: z43.enum(["in_person", "online", "hybrid"]),
-  attendanceModes: z43.array(publicEventAttendanceModeAvailabilitySchema),
-  startsAt: z43.string(),
-  endsAt: z43.string(),
-  capacity: z43.number().nullable(),
-  registeredCount: z43.number(),
-  availableSpots: z43.number().nullable(),
-  waitlistEnabled: z43.boolean(),
+  slug: z42.string(),
+  path: z42.string(),
+  requiresRegistration: z42.boolean(),
+  deliveryMode: z42.enum(["in_person", "online", "hybrid"]),
+  attendanceModes: z42.array(publicEventAttendanceModeAvailabilitySchema),
+  startsAt: z42.string(),
+  endsAt: z42.string(),
+  capacity: z42.number().nullable(),
+  registeredCount: z42.number(),
+  availableSpots: z42.number().nullable(),
+  waitlistEnabled: z42.boolean(),
   venue: eventVenueSchema.nullable(),
   eventCategory: eventCategorySchema.nullable(),
-  teamMembers: z43.array(publicTeamMemberSummarySchema).optional(),
-  status: z43.enum(["active", "draft", "archived"]).optional(),
-  timeZone: z43.string(),
+  teamMembers: z42.array(publicTeamMemberSummarySchema).optional(),
+  status: z42.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z42.string(),
   // Pricing & access fields
   pricingType: pricingTypeSchema,
-  price: z43.number().nullable(),
-  currency: z43.string(),
+  price: z42.number().nullable(),
+  currency: z42.string(),
   paymentTerms: blockBookingPaymentTermsSchema,
   pricingMode: eventPricingModeSchema.optional(),
-  ticketTypes: z43.array(publicEventTicketTypeSchema).optional(),
+  ticketTypes: z42.array(publicEventTicketTypeSchema).optional(),
   accessRestriction: accessRestrictionSchema,
-  allowedCategoryIds: z43.array(z43.string()),
-  requireGuestDetails: z43.boolean().optional(),
-  acceptsPasses: z43.boolean().optional(),
-  acceptsMemberships: z43.boolean().optional(),
-  course: z43.object({
-    id: z43.string(),
+  allowedCategoryIds: z42.array(z42.string()),
+  requireGuestDetails: z42.boolean().optional(),
+  acceptsPasses: z42.boolean().optional(),
+  acceptsMemberships: z42.boolean().optional(),
+  course: z42.object({
+    id: z42.string(),
     pricing: coursePricingSchema.optional(),
-    priceCents: z43.number().nullable(),
-    currency: z43.string(),
-    enrollmentOpen: z43.boolean()
+    priceCents: z42.number().nullable(),
+    currency: z42.string(),
+    enrollmentOpen: z42.boolean()
   }).nullable().optional()
 });
-var publicEventsArraySchema = z43.array(publicEventSchema);
+var publicEventsArraySchema = z42.array(publicEventSchema);
 
 // ../blocks/src/system/blocks/events/shared/fields.ts
 var cardStylingFields = [
@@ -20128,83 +20062,83 @@ function normalizeEventStaffMemberId(value) {
 }
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z44 } from "zod";
-var occurrenceContextSchema = z44.object({
-  id: z44.string(),
-  seriesId: z44.string(),
-  startsAt: z44.string(),
-  endsAt: z44.string(),
-  timeZone: z44.string(),
-  capacityOverride: z44.number().nullable().optional(),
-  overrides: z44.record(z44.string(), z44.unknown()).nullable().optional()
+import { z as z43 } from "zod";
+var occurrenceContextSchema = z43.object({
+  id: z43.string(),
+  seriesId: z43.string(),
+  startsAt: z43.string(),
+  endsAt: z43.string(),
+  timeZone: z43.string(),
+  capacityOverride: z43.number().nullable().optional(),
+  overrides: z43.record(z43.string(), z43.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z46 } from "zod";
+import { z as z45 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z45 } from "zod";
-var previewStageSchema = z45.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z45.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z45.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z45.enum(["grid", "stack", "compact"]);
-var columnOptionSchema = z45.enum(["2", "3", "4"]);
-var weekStartSchema = z45.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z45.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z45.enum(["both", "month", "week"]);
+import { z as z44 } from "zod";
+var previewStageSchema = z44.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z44.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z44.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z44.enum(["grid", "stack", "compact"]);
+var columnOptionSchema = z44.enum(["2", "3", "4"]);
+var weekStartSchema = z44.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z44.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z44.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-var contentEntrySchema = z46.object({
-  id: z46.string(),
-  slug: z46.string(),
-  contentTypeSlug: z46.string()
-});
-var eventRegistrationSourceSchema = z46.object({
-  siteId: z46.string().optional(),
-  apiBaseUrl: z46.string().optional(),
-  portalToken: z46.string().nullable().optional(),
+var contentEntrySchema = z45.object({
+  id: z45.string(),
+  slug: z45.string(),
+  contentTypeSlug: z45.string()
+});
+var eventRegistrationSourceSchema = z45.object({
+  siteId: z45.string().optional(),
+  apiBaseUrl: z45.string().optional(),
+  portalToken: z45.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z46.array(publicEventSchema).nullable().optional(),
-  className: z46.string().nullable().optional(),
-  buttonText: z46.string().nullable().optional(),
-  maxTickets: z46.string().nullable().optional(),
-  showVenue: z46.boolean().optional(),
-  showCapacity: z46.boolean().optional(),
-  successMessage: z46.string().optional(),
-  waitlistMessage: z46.string().optional(),
+  events: z45.array(publicEventSchema).nullable().optional(),
+  className: z45.string().nullable().optional(),
+  buttonText: z45.string().nullable().optional(),
+  maxTickets: z45.string().nullable().optional(),
+  showVenue: z45.boolean().optional(),
+  showCapacity: z45.boolean().optional(),
+  successMessage: z45.string().optional(),
+  waitlistMessage: z45.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z46.boolean().optional(),
+  spamProtectionEnabled: z45.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z46.string().optional()
+  supportEmail: z45.string().optional()
 });
-var eventRegistrationDisplaySchema = z46.object({
-  kind: z46.literal("event-registration"),
-  state: z46.literal("shell"),
-  className: z46.string().nullable(),
-  summaryButtonText: z46.string()
+var eventRegistrationDisplaySchema = z45.object({
+  kind: z45.literal("event-registration"),
+  state: z45.literal("shell"),
+  className: z45.string().nullable(),
+  summaryButtonText: z45.string()
 });
-var eventRegistrationHydrationSchema = z46.object({
+var eventRegistrationHydrationSchema = z45.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z46.array(publicEventSchema).nullable().optional(),
-  maxTickets: z46.string().optional(),
-  showVenue: z46.boolean().optional(),
-  showCapacity: z46.boolean().optional(),
-  successMessage: z46.string().optional(),
-  waitlistMessage: z46.string().optional(),
+  events: z45.array(publicEventSchema).nullable().optional(),
+  maxTickets: z45.string().optional(),
+  showVenue: z45.boolean().optional(),
+  showCapacity: z45.boolean().optional(),
+  successMessage: z45.string().optional(),
+  waitlistMessage: z45.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z46.boolean().optional(),
-  supportEmail: z46.string().optional()
+  spamProtectionEnabled: z45.boolean().optional(),
+  supportEmail: z45.string().optional()
 });
-var eventRegistrationRenderSchema = z46.object({
+var eventRegistrationRenderSchema = z45.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z46.object({
-  siteId: z46.string().optional(),
-  apiBaseUrl: z46.string().optional(),
-  portalToken: z46.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z45.object({
+  siteId: z45.string().optional(),
+  apiBaseUrl: z45.string().optional(),
+  portalToken: z45.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -20421,7 +20355,7 @@ var eventRegistrationBlockDefinition = {
   manifest: eventRegistrationManifest,
   runtime: eventRegistrationBlockRuntime,
   dataSchemas: {
-    events: z47.array(publicEventSchema).optional(),
+    events: z46.array(publicEventSchema).optional(),
     occurrenceContext: occurrenceContextSchema.optional()
   },
   dataLoaders: {
@@ -20444,72 +20378,72 @@ var eventRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z48 } from "zod";
-var contentEntrySchema2 = z48.object({
-  id: z48.string(),
-  slug: z48.string(),
-  contentTypeSlug: z48.string()
-});
-var courseEntrySubrouteContextSchema = z48.union([
-  z48.object({
-    kind: z48.literal("course-run"),
-    run: z48.object({
-      courseId: z48.string(),
-      seriesId: z48.string(),
-      runSlug: z48.string()
+import { z as z47 } from "zod";
+var contentEntrySchema2 = z47.object({
+  id: z47.string(),
+  slug: z47.string(),
+  contentTypeSlug: z47.string()
+});
+var courseEntrySubrouteContextSchema = z47.union([
+  z47.object({
+    kind: z47.literal("course-run"),
+    run: z47.object({
+      courseId: z47.string(),
+      seriesId: z47.string(),
+      runSlug: z47.string()
     })
   }),
-  z48.object({
-    kind: z48.literal("event-occurrence"),
+  z47.object({
+    kind: z47.literal("event-occurrence"),
     occurrence: occurrenceContextSchema
   })
 ]);
-var courseRegistrationSourceSchema = z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
+var courseRegistrationSourceSchema = z47.object({
+  siteId: z47.string().optional(),
+  apiBaseUrl: z47.string().optional(),
+  portalToken: z47.string().nullable().optional(),
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z48.array(publicCourseSchema).nullable().optional(),
-  className: z48.string().nullable().optional(),
-  showSessions: z48.boolean().optional(),
-  showPrice: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  showVenue: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
-  membershipMessage: z48.string().optional(),
-  buttonText: z48.string().nullable().optional(),
+  courses: z47.array(publicCourseSchema).nullable().optional(),
+  className: z47.string().nullable().optional(),
+  showSessions: z47.boolean().optional(),
+  showPrice: z47.boolean().optional(),
+  showCapacity: z47.boolean().optional(),
+  showVenue: z47.boolean().optional(),
+  successMessage: z47.string().optional(),
+  waitlistMessage: z47.string().optional(),
+  membershipMessage: z47.string().optional(),
+  buttonText: z47.string().nullable().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
   stage: previewStageSchema.optional()
 });
-var courseRegistrationDisplaySchema = z48.object({
-  kind: z48.literal("course-registration"),
-  state: z48.literal("shell"),
-  className: z48.string().nullable(),
-  summaryButtonText: z48.string()
+var courseRegistrationDisplaySchema = z47.object({
+  kind: z47.literal("course-registration"),
+  state: z47.literal("shell"),
+  className: z47.string().nullable(),
+  summaryButtonText: z47.string()
 });
-var courseRegistrationHydrationSchema = z48.object({
+var courseRegistrationHydrationSchema = z47.object({
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z48.array(publicCourseSchema).nullable().optional(),
-  showSessions: z48.boolean().optional(),
-  showPrice: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  showVenue: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
-  membershipMessage: z48.string().optional(),
+  courses: z47.array(publicCourseSchema).nullable().optional(),
+  showSessions: z47.boolean().optional(),
+  showPrice: z47.boolean().optional(),
+  showCapacity: z47.boolean().optional(),
+  showVenue: z47.boolean().optional(),
+  successMessage: z47.string().optional(),
+  waitlistMessage: z47.string().optional(),
+  membershipMessage: z47.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional()
 });
-var courseRegistrationRenderSchema = z48.object({
+var courseRegistrationRenderSchema = z47.object({
   display: courseRegistrationDisplaySchema,
   hydration: courseRegistrationHydrationSchema
 });
-var courseRegistrationIslandMetaCodec = createZodCodec(z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
+var courseRegistrationIslandMetaCodec = createZodCodec(z47.object({
+  siteId: z47.string().optional(),
+  apiBaseUrl: z47.string().optional(),
+  portalToken: z47.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -20769,32 +20703,32 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z50 } from "zod";
+import { z as z49 } from "zod";
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z49 } from "zod";
-var publicPassProductSchema = z49.object({
-  id: z49.string(),
-  productUseCase: z49.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z49.string(),
-  description: z49.string().nullable(),
-  price: z49.number(),
-  currency: z49.string(),
-  creditsTotal: z49.number(),
-  pricePerCredit: z49.number(),
-  validDays: z49.number().nullable(),
-  eligibleCategoryIds: z49.array(z49.string()),
-  eligibleCategoryNames: z49.array(z49.string())
-});
-var publicMembershipProductSchema = z49.object({
-  id: z49.string(),
-  name: z49.string(),
-  description: z49.string().nullable(),
-  price: z49.number(),
-  currency: z49.string(),
-  billingInterval: z49.enum(["month", "year"]),
-  eligibleCategoryIds: z49.array(z49.string()),
-  eligibleCategoryNames: z49.array(z49.string())
+import { z as z48 } from "zod";
+var publicPassProductSchema = z48.object({
+  id: z48.string(),
+  productUseCase: z48.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z48.string(),
+  description: z48.string().nullable(),
+  price: z48.number(),
+  currency: z48.string(),
+  creditsTotal: z48.number(),
+  pricePerCredit: z48.number(),
+  validDays: z48.number().nullable(),
+  eligibleCategoryIds: z48.array(z48.string()),
+  eligibleCategoryNames: z48.array(z48.string())
+});
+var publicMembershipProductSchema = z48.object({
+  id: z48.string(),
+  name: z48.string(),
+  description: z48.string().nullable(),
+  price: z48.number(),
+  currency: z48.string(),
+  billingInterval: z48.enum(["month", "year"]),
+  eligibleCategoryIds: z48.array(z48.string()),
+  eligibleCategoryNames: z48.array(z48.string())
 });
 
 // ../blocks/src/system/blocks/event-details.ts
@@ -20926,22 +20860,22 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z50.object({
-  id: z50.string(),
-  seriesId: z50.string(),
-  startsAt: z50.string(),
-  endsAt: z50.string(),
-  timeZone: z50.string(),
-  capacityOverride: z50.number().nullable().optional(),
-  overrides: z50.record(z50.string(), z50.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z49.object({
+  id: z49.string(),
+  seriesId: z49.string(),
+  startsAt: z49.string(),
+  endsAt: z49.string(),
+  timeZone: z49.string(),
+  capacityOverride: z49.number().nullable().optional(),
+  overrides: z49.record(z49.string(), z49.unknown()).nullable().optional()
 }).nullable();
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z50.object({
+    eventDetailsData: z49.object({
       events: publicEventsArraySchema,
-      sitePasses: z50.object({ passes: z50.array(publicPassProductSchema) }),
-      siteMemberships: z50.object({ memberships: z50.array(publicMembershipProductSchema) })
+      sitePasses: z49.object({ passes: z49.array(publicPassProductSchema) }),
+      siteMemberships: z49.object({ memberships: z49.array(publicMembershipProductSchema) })
     }).optional(),
     occurrenceContext: occurrenceContextSchema2.optional()
   },
@@ -21260,7 +21194,7 @@ var eventSpotlightBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z51 } from "zod";
+import { z as z50 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/events/shared/utils.ts
 var COLUMN_CLASSES = {
@@ -21367,87 +21301,87 @@ function computeMediaTransformStyle(value, style, targetAspectRatio, options) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-var cardVariantSchema2 = z51.enum(["default", "variant1", "variant2"]);
-var cardOrientationSchema = z51.enum(["vertical", "horizontal"]);
-var eventBlockKindSchema = z51.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema = z51.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema2 = z51.enum(eventScheduleScopeValues);
-var eventListingSourceSchema = z51.object({
-  events: z51.array(publicEventSchema).nullable().optional(),
-  siteId: z51.string(),
-  apiBaseUrl: z51.string().optional(),
+var cardVariantSchema2 = z50.enum(["default", "variant1", "variant2"]);
+var cardOrientationSchema = z50.enum(["vertical", "horizontal"]);
+var eventBlockKindSchema = z50.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema = z50.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema2 = z50.enum(eventScheduleScopeValues);
+var eventListingSourceSchema = z50.object({
+  events: z50.array(publicEventSchema).nullable().optional(),
+  siteId: z50.string(),
+  apiBaseUrl: z50.string().optional(),
   stage: previewStageSchema.optional(),
   layout: eventLayoutSchema.optional(),
   columns: columnOptionSchema.optional(),
-  eventsPerPage: z51.string().optional(),
-  paginationMode: z51.enum(["loadMore", "seeAllLink"]).optional(),
-  seeAllUrl: z51.string().optional(),
-  loadMoreText: z51.string().optional(),
+  eventsPerPage: z50.string().optional(),
+  paginationMode: z50.enum(["loadMore", "seeAllLink"]).optional(),
+  seeAllUrl: z50.string().optional(),
+  loadMoreText: z50.string().optional(),
   cardVariant: cardVariantSchema2.optional(),
   buttonVariant: eventButtonVariantSchema.optional(),
-  buttonText: z51.string().optional(),
-  showVenue: z51.boolean().optional(),
-  showMap: z51.boolean().optional(),
-  showCapacity: z51.boolean().optional(),
-  emptyMessage: z51.string().optional(),
-  className: z51.string().optional(),
-  showFilters: z51.boolean().nullable().optional(),
+  buttonText: z50.string().optional(),
+  showVenue: z50.boolean().optional(),
+  showMap: z50.boolean().optional(),
+  showCapacity: z50.boolean().optional(),
+  emptyMessage: z50.string().optional(),
+  className: z50.string().optional(),
+  showFilters: z50.boolean().nullable().optional(),
   showCategoryFilter: filterAutoShowSchema.optional(),
-  showVenueFilter: z51.boolean().nullable().optional(),
-  showStaffFilter: z51.boolean().nullable().optional(),
+  showVenueFilter: z50.boolean().nullable().optional(),
+  showStaffFilter: z50.boolean().nullable().optional(),
   eventKind: eventBlockKindSchema.nullable().optional(),
   eventSurface: eventSurfaceScopeSchema.nullable().optional(),
-  filterEventPresets: z51.union([z51.string(), z51.array(z51.string())]).nullable().optional(),
+  filterEventPresets: z50.union([z50.string(), z50.array(z50.string())]).nullable().optional(),
   scheduleScope: eventScheduleScopeSchema2.nullable().optional(),
-  filterCategoryIds: z51.string().nullable().optional(),
-  filterStaffMemberId: z51.string().nullable().optional(),
-  filterVenueId: z51.string().nullable().optional()
+  filterCategoryIds: z50.string().nullable().optional(),
+  filterStaffMemberId: z50.string().nullable().optional(),
+  filterVenueId: z50.string().nullable().optional()
 });
-var eventListingDisplaySchema = z51.object({
-  kind: z51.literal("event-listing"),
-  state: z51.enum(["loading", "empty", "ready"]),
+var eventListingDisplaySchema = z50.object({
+  kind: z50.literal("event-listing"),
+  state: z50.enum(["loading", "empty", "ready"]),
   listLayout: eventLayoutSchema,
-  className: z51.string().nullable(),
-  emptyMessage: z51.string(),
-  loadingMessage: z51.string(),
-  containerClass: z51.string(),
+  className: z50.string().nullable(),
+  emptyMessage: z50.string(),
+  loadingMessage: z50.string(),
+  containerClass: z50.string(),
   cardVariant: cardVariantSchema2,
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z51.string(),
-  showVenue: z51.boolean(),
-  showMap: z51.boolean(),
-  showCapacity: z51.boolean(),
+  buttonText: z50.string(),
+  showVenue: z50.boolean(),
+  showMap: z50.boolean(),
+  showCapacity: z50.boolean(),
   orientation: cardOrientationSchema,
-  events: z51.array(publicEventSchema)
+  events: z50.array(publicEventSchema)
 });
-var eventListingHydrationSchema = z51.object({
-  siteId: z51.string(),
+var eventListingHydrationSchema = z50.object({
+  siteId: z50.string(),
   stage: previewStageSchema.optional(),
-  eventsPerPage: z51.string(),
-  paginationMode: z51.enum(["loadMore", "seeAllLink"]),
-  seeAllUrl: z51.string().optional(),
-  loadMoreText: z51.string(),
-  showFilters: z51.boolean(),
+  eventsPerPage: z50.string(),
+  paginationMode: z50.enum(["loadMore", "seeAllLink"]),
+  seeAllUrl: z50.string().optional(),
+  loadMoreText: z50.string(),
+  showFilters: z50.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z51.boolean(),
-  showStaffFilter: z51.boolean(),
+  showVenueFilter: z50.boolean(),
+  showStaffFilter: z50.boolean(),
   eventKind: eventBlockKindSchema,
   eventSurface: eventSurfaceScopeSchema,
-  filterEventPresets: z51.string().nullable(),
+  filterEventPresets: z50.string().nullable(),
   scheduleScope: eventScheduleScopeSchema2,
-  filterCategoryIds: z51.string().nullable().optional(),
-  filterStaffMemberId: z51.string().nullable().optional(),
-  filterVenueId: z51.string().nullable().optional(),
-  fetchInitialEventsOnMount: z51.boolean()
+  filterCategoryIds: z50.string().nullable().optional(),
+  filterStaffMemberId: z50.string().nullable().optional(),
+  filterVenueId: z50.string().nullable().optional(),
+  fetchInitialEventsOnMount: z50.boolean()
 });
-var eventListingRenderSchema = z51.object({
+var eventListingRenderSchema = z50.object({
   display: eventListingDisplaySchema,
   hydration: eventListingHydrationSchema
 });
 var eventListingIslandMetaCodec = createZodCodec(
-  z51.object({
-    siteId: z51.string(),
-    apiBaseUrl: z51.string().optional(),
+  z50.object({
+    siteId: z50.string(),
+    apiBaseUrl: z50.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -21766,93 +21700,93 @@ var eventListingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z52 } from "zod";
-var displayModeSchema = z52.enum(["combined", "month", "week", "list", "timetable"]);
-var eventBlockKindSchema2 = z52.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema2 = z52.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema3 = z52.enum(eventScheduleScopeValues);
-var eventCalendarSourceSchema = z52.object(
+import { z as z51 } from "zod";
+var displayModeSchema = z51.enum(["combined", "month", "week", "list", "timetable"]);
+var eventBlockKindSchema2 = z51.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema2 = z51.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema3 = z51.enum(eventScheduleScopeValues);
+var eventCalendarSourceSchema = z51.object(
   {
-    events: z52.array(publicEventSchema).nullable().optional(),
-    siteId: z52.string(),
-    apiBaseUrl: z52.string().optional(),
+    events: z51.array(publicEventSchema).nullable().optional(),
+    siteId: z51.string(),
+    apiBaseUrl: z51.string().optional(),
     stage: previewStageSchema.optional(),
     displayMode: displayModeSchema.nullable().optional(),
     listLayout: eventLayoutSchema.optional(),
     listColumns: columnOptionSchema.optional(),
     layout: eventLayoutSchema.optional(),
     columns: columnOptionSchema.optional(),
-    eventsPerPage: z52.string().optional(),
-    compactEventsPerPage: z52.string().optional(),
-    loadMoreText: z52.string().optional(),
+    eventsPerPage: z51.string().optional(),
+    compactEventsPerPage: z51.string().optional(),
+    loadMoreText: z51.string().optional(),
     startOfWeek: weekStartSchema.optional(),
     calendarTabViews: calendarTabViewsSchema.optional(),
-    showFilters: z52.boolean().nullable().optional(),
+    showFilters: z51.boolean().nullable().optional(),
     showCategoryFilter: filterAutoShowSchema.optional(),
-    showVenueFilter: z52.boolean().nullable().optional(),
-    showStaffFilter: z52.boolean().nullable().optional(),
+    showVenueFilter: z51.boolean().nullable().optional(),
+    showStaffFilter: z51.boolean().nullable().optional(),
     kind: eventBlockKindSchema2.nullable().optional(),
     eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-    filterEventPresets: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
+    filterEventPresets: z51.union([z51.string(), z51.array(z51.string())]).nullable().optional(),
     scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-    filterCategoryIds: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
-    filterStaffMemberId: z52.string().nullable().optional(),
-    filterVenueId: z52.string().nullable().optional(),
+    filterCategoryIds: z51.union([z51.string(), z51.array(z51.string())]).nullable().optional(),
+    filterStaffMemberId: z51.string().nullable().optional(),
+    filterVenueId: z51.string().nullable().optional(),
     buttonVariant: eventButtonVariantSchema.optional(),
-    buttonText: z52.string().optional(),
-    showVenue: z52.boolean().nullable().optional(),
-    showMap: z52.boolean().nullable().optional(),
-    showCapacity: z52.boolean().nullable().optional(),
-    emptyMessage: z52.string().optional(),
-    className: z52.string().optional()
+    buttonText: z51.string().optional(),
+    showVenue: z51.boolean().nullable().optional(),
+    showMap: z51.boolean().nullable().optional(),
+    showCapacity: z51.boolean().nullable().optional(),
+    emptyMessage: z51.string().optional(),
+    className: z51.string().optional()
   }
 );
-var eventCalendarDisplaySchema = z52.object({
-  kind: z52.literal("event-calendar"),
+var eventCalendarDisplaySchema = z51.object({
+  kind: z51.literal("event-calendar"),
   displayMode: displayModeSchema,
-  className: z52.string().nullable(),
-  events: z52.array(publicEventSchema),
+  className: z51.string().nullable(),
+  events: z51.array(publicEventSchema),
   listLayout: eventLayoutSchema,
   listColumns: columnOptionSchema,
-  eventsPerPage: z52.string(),
-  loadMoreText: z52.string(),
+  eventsPerPage: z51.string(),
+  loadMoreText: z51.string(),
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
-  showFilters: z52.boolean(),
+  showFilters: z51.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z52.boolean(),
-  showStaffFilter: z52.boolean(),
+  showVenueFilter: z51.boolean(),
+  showStaffFilter: z51.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z52.string().nullable(),
+  filterEventPresets: z51.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3,
-  filterCategoryIds: z52.string().nullable(),
-  filterStaffMemberId: z52.string().nullable(),
-  filterVenueId: z52.string().nullable(),
+  filterCategoryIds: z51.string().nullable(),
+  filterStaffMemberId: z51.string().nullable(),
+  filterVenueId: z51.string().nullable(),
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z52.string(),
-  showVenue: z52.boolean(),
-  showMap: z52.boolean(),
-  showCapacity: z52.boolean(),
-  emptyMessage: z52.string()
-});
-var eventCalendarHydrationSchema = z52.object({
-  siteId: z52.string(),
+  buttonText: z51.string(),
+  showVenue: z51.boolean(),
+  showMap: z51.boolean(),
+  showCapacity: z51.boolean(),
+  emptyMessage: z51.string()
+});
+var eventCalendarHydrationSchema = z51.object({
+  siteId: z51.string(),
   stage: previewStageSchema.optional(),
-  prefetchedEvents: z52.boolean(),
+  prefetchedEvents: z51.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z52.string().nullable(),
+  filterEventPresets: z51.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3
 });
-var eventCalendarRenderSchema = z52.object({
+var eventCalendarRenderSchema = z51.object({
   display: eventCalendarDisplaySchema,
   hydration: eventCalendarHydrationSchema
 });
 var eventCalendarIslandMetaCodec = createZodCodec(
-  z52.object({
-    siteId: z52.string(),
-    apiBaseUrl: z52.string().optional(),
+  z51.object({
+    siteId: z51.string(),
+    apiBaseUrl: z51.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -22446,7 +22380,7 @@ var eventCalendarBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z53 } from "zod";
+import { z as z52 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -22677,18 +22611,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z53.object({
-  id: z53.string(),
-  identifier: z53.string(),
-  title: z53.string(),
-  slug: z53.string().nullable().optional(),
-  content: z53.record(z53.string(), z53.unknown()).optional(),
-  publishedAt: z53.string().nullable().optional()
+var embedEntrySchema = z52.object({
+  id: z52.string(),
+  identifier: z52.string(),
+  title: z52.string(),
+  slug: z52.string().nullable().optional(),
+  content: z52.record(z52.string(), z52.unknown()).optional(),
+  publishedAt: z52.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z53.array(embedEntrySchema).optional()
+    entries: z52.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -23863,54 +23797,54 @@ var fileDownloadBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/shop.ts
-import { z as z57 } from "zod";
+import { z as z56 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z56 } from "zod";
+import { z as z55 } from "zod";
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z54 } from "zod";
-var publicProductVariantSchema = z54.object({
-  id: z54.string(),
-  title: z54.string(),
-  sku: z54.string().nullable(),
-  priceCents: z54.number(),
-  stockQuantity: z54.number().nullable(),
-  soldOut: z54.boolean()
-});
-var publicProductSchema = z54.object({
-  id: z54.string(),
-  contentEntryId: z54.string().nullable(),
-  title: z54.string(),
-  slug: z54.string(),
-  path: z54.string().nullable(),
-  status: z54.enum(["draft", "active"]),
-  priceCents: z54.number(),
-  currency: z54.string(),
-  productType: z54.enum(["physical", "digital"]),
-  requiresShipping: z54.boolean(),
-  hasVariants: z54.boolean(),
-  trackInventory: z54.boolean(),
-  soldOut: z54.boolean(),
-  category: z54.object({
-    id: z54.string(),
-    name: z54.string(),
-    slug: z54.string()
+import { z as z53 } from "zod";
+var publicProductVariantSchema = z53.object({
+  id: z53.string(),
+  title: z53.string(),
+  sku: z53.string().nullable(),
+  priceCents: z53.number(),
+  stockQuantity: z53.number().nullable(),
+  soldOut: z53.boolean()
+});
+var publicProductSchema = z53.object({
+  id: z53.string(),
+  contentEntryId: z53.string().nullable(),
+  title: z53.string(),
+  slug: z53.string(),
+  path: z53.string().nullable(),
+  status: z53.enum(["draft", "active"]),
+  priceCents: z53.number(),
+  currency: z53.string(),
+  productType: z53.enum(["physical", "digital"]),
+  requiresShipping: z53.boolean(),
+  hasVariants: z53.boolean(),
+  trackInventory: z53.boolean(),
+  soldOut: z53.boolean(),
+  category: z53.object({
+    id: z53.string(),
+    name: z53.string(),
+    slug: z53.string()
   }).nullable(),
-  summary: z54.string().nullable(),
-  badges: z54.array(z54.string()),
-  ctaLabel: z54.string().nullable(),
-  body: z54.unknown().nullable(),
-  gallery: z54.array(
-    z54.object({
-      url: z54.string(),
-      alt: z54.string().nullable()
+  summary: z53.string().nullable(),
+  badges: z53.array(z53.string()),
+  ctaLabel: z53.string().nullable(),
+  body: z53.unknown().nullable(),
+  gallery: z53.array(
+    z53.object({
+      url: z53.string(),
+      alt: z53.string().nullable()
     })
   ),
-  variants: z54.array(publicProductVariantSchema)
+  variants: z53.array(publicProductVariantSchema)
 });
-var publicProductsResponseSchema = z54.object({
-  products: z54.array(publicProductSchema)
+var publicProductsResponseSchema = z53.object({
+  products: z53.array(publicProductSchema)
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
@@ -23974,26 +23908,26 @@ function deriveCreditProductLabels(products, options = {}) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z55 } from "zod";
-var storedProductCartItemSchema = z55.object({
-  kind: z55.literal("product"),
-  productId: z55.string().min(1),
-  variantId: z55.string().min(1).optional().nullable(),
-  title: z55.string().min(1),
-  variantTitle: z55.string().optional().nullable(),
-  quantity: z55.number().finite(),
-  unitPriceCents: z55.number().finite(),
-  currency: z55.string().min(1),
-  imageUrl: z55.string().optional().nullable(),
-  soldOut: z55.boolean().optional()
-});
-var storedPassCartItemSchema = z55.object({
-  kind: z55.literal("pass"),
-  passId: z55.string().min(1),
-  title: z55.string().min(1),
-  quantity: z55.number().finite().optional(),
-  unitPriceCents: z55.number().finite(),
-  currency: z55.string().min(1)
+import { z as z54 } from "zod";
+var storedProductCartItemSchema = z54.object({
+  kind: z54.literal("product"),
+  productId: z54.string().min(1),
+  variantId: z54.string().min(1).optional().nullable(),
+  title: z54.string().min(1),
+  variantTitle: z54.string().optional().nullable(),
+  quantity: z54.number().finite(),
+  unitPriceCents: z54.number().finite(),
+  currency: z54.string().min(1),
+  imageUrl: z54.string().optional().nullable(),
+  soldOut: z54.boolean().optional()
+});
+var storedPassCartItemSchema = z54.object({
+  kind: z54.literal("pass"),
+  passId: z54.string().min(1),
+  title: z54.string().min(1),
+  quantity: z54.number().finite().optional(),
+  unitPriceCents: z54.number().finite(),
+  currency: z54.string().min(1)
 });
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
@@ -24232,219 +24166,219 @@ function formatValidity(days) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-var shopModeSchema = z56.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-var contentEntrySchema3 = z56.object({
-  id: z56.string().nullable().optional(),
-  slug: z56.string().nullable().optional()
+var shopModeSchema = z55.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+var contentEntrySchema3 = z55.object({
+  id: z55.string().nullable().optional(),
+  slug: z55.string().nullable().optional()
 }).nullable();
-var shopSourceSchema = z56.object({
-  className: z56.string().nullable().optional(),
+var shopSourceSchema = z55.object({
+  className: z55.string().nullable().optional(),
   mode: shopModeSchema.optional(),
-  heading: z56.string().nullable().optional(),
-  productSlug: z56.string().nullable().optional(),
-  showPasses: z56.boolean().optional(),
-  showMemberships: z56.boolean().optional(),
-  layout: z56.enum(["grid", "list"]).optional(),
-  columns: z56.string().optional(),
-  showDescriptions: z56.boolean().optional(),
-  showSummary: z56.boolean().optional(),
-  showBody: z56.boolean().optional(),
-  showBadges: z56.boolean().optional(),
-  showPrices: z56.boolean().optional(),
-  showValidityPeriod: z56.boolean().optional(),
-  showPricePerCredit: z56.boolean().nullable().optional(),
-  passesHeading: z56.string().optional(),
-  membershipsHeading: z56.string().optional(),
-  buyButtonText: z56.string().optional(),
-  addButtonText: z56.string().optional(),
-  passPurchaseMode: z56.enum(["add_to_cart", "buy_now"]).optional(),
-  subscribeButtonText: z56.string().optional(),
-  emptyStateText: z56.string().optional(),
-  checkoutButtonText: z56.string().optional(),
-  clearButtonText: z56.string().optional(),
-  submitButtonText: z56.string().optional(),
+  heading: z55.string().nullable().optional(),
+  productSlug: z55.string().nullable().optional(),
+  showPasses: z55.boolean().optional(),
+  showMemberships: z55.boolean().optional(),
+  layout: z55.enum(["grid", "list"]).optional(),
+  columns: z55.string().optional(),
+  showDescriptions: z55.boolean().optional(),
+  showSummary: z55.boolean().optional(),
+  showBody: z55.boolean().optional(),
+  showBadges: z55.boolean().optional(),
+  showPrices: z55.boolean().optional(),
+  showValidityPeriod: z55.boolean().optional(),
+  showPricePerCredit: z55.boolean().nullable().optional(),
+  passesHeading: z55.string().optional(),
+  membershipsHeading: z55.string().optional(),
+  buyButtonText: z55.string().optional(),
+  addButtonText: z55.string().optional(),
+  passPurchaseMode: z55.enum(["add_to_cart", "buy_now"]).optional(),
+  subscribeButtonText: z55.string().optional(),
+  emptyStateText: z55.string().optional(),
+  checkoutButtonText: z55.string().optional(),
+  clearButtonText: z55.string().optional(),
+  submitButtonText: z55.string().optional(),
   contentEntry: contentEntrySchema3.optional(),
-  passes: z56.array(publicPassProductSchema).nullable().optional(),
-  memberships: z56.array(publicMembershipProductSchema).nullable().optional(),
-  products: z56.array(publicProductSchema).nullable().optional(),
-  siteId: z56.string().optional(),
-  apiBaseUrl: z56.string().optional(),
+  passes: z55.array(publicPassProductSchema).nullable().optional(),
+  memberships: z55.array(publicMembershipProductSchema).nullable().optional(),
+  products: z55.array(publicProductSchema).nullable().optional(),
+  siteId: z55.string().optional(),
+  apiBaseUrl: z55.string().optional(),
   stage: previewStageSchema.optional()
 });
-var productVariantOptionDisplaySchema = z56.object({
-  id: z56.string(),
-  label: z56.string(),
-  soldOut: z56.boolean()
-});
-var productCardDisplaySchema = z56.object({
-  productId: z56.string(),
-  title: z56.string(),
-  path: z56.string().nullable(),
-  summary: z56.string().nullable(),
-  priceLabel: z56.string().nullable(),
-  badges: z56.array(z56.string()),
-  image: z56.object({
-    url: z56.string(),
-    alt: z56.string().nullable()
+var productVariantOptionDisplaySchema = z55.object({
+  id: z55.string(),
+  label: z55.string(),
+  soldOut: z55.boolean()
+});
+var productCardDisplaySchema = z55.object({
+  productId: z55.string(),
+  title: z55.string(),
+  path: z55.string().nullable(),
+  summary: z55.string().nullable(),
+  priceLabel: z55.string().nullable(),
+  badges: z55.array(z55.string()),
+  image: z55.object({
+    url: z55.string(),
+    alt: z55.string().nullable()
   }).nullable(),
-  variantOptions: z56.array(productVariantOptionDisplaySchema),
-  selectedVariantId: z56.string().nullable(),
-  selectionLabel: z56.string(),
-  actionLabel: z56.string(),
-  soldOut: z56.boolean()
-});
-var productListDisplaySchema = z56.object({
-  kind: z56.literal("product-list"),
-  state: z56.enum(["empty", "ready"]),
-  heading: z56.string().nullable(),
-  className: z56.string().nullable(),
-  layout: z56.enum(["grid", "list"]),
-  columns: z56.string(),
-  emptyMessage: z56.string(),
-  cards: z56.array(productCardDisplaySchema)
-});
-var productDetailDisplaySchema = z56.discriminatedUnion("state", [
-  z56.object({
-    kind: z56.literal("product-detail"),
-    state: z56.literal("empty"),
-    heading: z56.string().nullable(),
-    className: z56.string().nullable(),
-    emptyMessage: z56.string()
+  variantOptions: z55.array(productVariantOptionDisplaySchema),
+  selectedVariantId: z55.string().nullable(),
+  selectionLabel: z55.string(),
+  actionLabel: z55.string(),
+  soldOut: z55.boolean()
+});
+var productListDisplaySchema = z55.object({
+  kind: z55.literal("product-list"),
+  state: z55.enum(["empty", "ready"]),
+  heading: z55.string().nullable(),
+  className: z55.string().nullable(),
+  layout: z55.enum(["grid", "list"]),
+  columns: z55.string(),
+  emptyMessage: z55.string(),
+  cards: z55.array(productCardDisplaySchema)
+});
+var productDetailDisplaySchema = z55.discriminatedUnion("state", [
+  z55.object({
+    kind: z55.literal("product-detail"),
+    state: z55.literal("empty"),
+    heading: z55.string().nullable(),
+    className: z55.string().nullable(),
+    emptyMessage: z55.string()
   }),
-  z56.object({
-    kind: z56.literal("product-detail"),
-    state: z56.literal("ready"),
-    heading: z56.string().nullable(),
-    className: z56.string().nullable(),
-    title: z56.string(),
-    priceLabel: z56.string(),
-    summary: z56.string().nullable(),
-    badges: z56.array(z56.string()),
-    categoryLabel: z56.string().nullable(),
-    gallery: z56.array(z56.object({
-      url: z56.string(),
-      alt: z56.string().nullable()
+  z55.object({
+    kind: z55.literal("product-detail"),
+    state: z55.literal("ready"),
+    heading: z55.string().nullable(),
+    className: z55.string().nullable(),
+    title: z55.string(),
+    priceLabel: z55.string(),
+    summary: z55.string().nullable(),
+    badges: z55.array(z55.string()),
+    categoryLabel: z55.string().nullable(),
+    gallery: z55.array(z55.object({
+      url: z55.string(),
+      alt: z55.string().nullable()
     })),
-    variantOptions: z56.array(productVariantOptionDisplaySchema),
-    selectedVariantId: z56.string().nullable(),
-    selectionLabel: z56.string(),
-    actionLabel: z56.string(),
-    soldOut: z56.boolean(),
-    body: z56.unknown().nullable()
+    variantOptions: z55.array(productVariantOptionDisplaySchema),
+    selectedVariantId: z55.string().nullable(),
+    selectionLabel: z55.string(),
+    actionLabel: z55.string(),
+    soldOut: z55.boolean(),
+    body: z55.unknown().nullable()
   })
 ]);
-var passCardDisplaySchema = z56.object({
-  id: z56.string(),
-  title: z56.string(),
-  description: z56.string().nullable(),
-  priceLabel: z56.string(),
-  creditsLabel: z56.string(),
-  perCreditLabel: z56.string().nullable(),
-  validityLabel: z56.string().nullable(),
-  actionLabel: z56.string()
-});
-var membershipCardDisplaySchema = z56.object({
-  id: z56.string(),
-  title: z56.string(),
-  description: z56.string().nullable(),
-  priceLabel: z56.string(),
-  intervalLabel: z56.string(),
-  actionLabel: z56.string()
-});
-var passesMembershipsDisplaySchema = z56.object({
-  kind: z56.literal("passes-memberships"),
-  state: z56.enum(["empty", "ready"]),
-  className: z56.string().nullable(),
-  layout: z56.enum(["grid", "list"]),
-  columns: z56.string(),
-  emptyMessage: z56.string(),
-  passesHeading: z56.string(),
-  membershipsHeading: z56.string(),
-  passes: z56.array(passCardDisplaySchema),
-  memberships: z56.array(membershipCardDisplaySchema)
-});
-var cartLineDisplaySchema = z56.object({
-  key: z56.string(),
-  title: z56.string(),
-  priceLabel: z56.string(),
-  quantity: z56.number(),
-  quantityEditable: z56.boolean()
-});
-var cartDisplaySchema = z56.object({
-  kind: z56.literal("cart"),
-  state: z56.enum(["empty", "ready"]),
-  heading: z56.string().nullable(),
-  className: z56.string().nullable(),
-  emptyMessage: z56.string(),
-  supportText: z56.string().nullable(),
-  items: z56.array(cartLineDisplaySchema),
-  subtotalLabel: z56.string().nullable(),
-  checkoutButtonText: z56.string(),
-  clearButtonText: z56.string()
-});
-var checkoutDisplaySchema = z56.object({
-  kind: z56.literal("checkout"),
-  state: z56.enum(["empty", "blocked", "ready"]),
-  heading: z56.string().nullable(),
-  className: z56.string().nullable(),
-  message: z56.string().nullable(),
-  submitButtonText: z56.string()
-});
-var passesMembershipsHydrationSchema = z56.object({
-  passes: z56.array(publicPassProductSchema),
-  memberships: z56.array(publicMembershipProductSchema),
-  passPurchaseMode: z56.enum(["add_to_cart", "buy_now"])
-});
-var productListHydrationSchema = z56.object({
-  products: z56.array(publicProductSchema),
-  showSummary: z56.boolean(),
-  showBadges: z56.boolean(),
-  showPrices: z56.boolean(),
-  addButtonText: z56.string()
-});
-var productDetailHydrationSchema = z56.object({
-  products: z56.array(publicProductSchema),
-  productId: z56.string().nullable(),
-  showSummary: z56.boolean(),
-  showBadges: z56.boolean(),
-  showBody: z56.boolean(),
-  addButtonText: z56.string()
-});
-var cartHydrationSchema = z56.object({
-  emptyStateText: z56.string(),
-  checkoutButtonText: z56.string(),
-  clearButtonText: z56.string()
-});
-var checkoutHydrationSchema = z56.object({
-  emptyStateText: z56.string(),
-  submitButtonText: z56.string()
-});
-var passesMembershipsRenderSchema = z56.object({
+var passCardDisplaySchema = z55.object({
+  id: z55.string(),
+  title: z55.string(),
+  description: z55.string().nullable(),
+  priceLabel: z55.string(),
+  creditsLabel: z55.string(),
+  perCreditLabel: z55.string().nullable(),
+  validityLabel: z55.string().nullable(),
+  actionLabel: z55.string()
+});
+var membershipCardDisplaySchema = z55.object({
+  id: z55.string(),
+  title: z55.string(),
+  description: z55.string().nullable(),
+  priceLabel: z55.string(),
+  intervalLabel: z55.string(),
+  actionLabel: z55.string()
+});
+var passesMembershipsDisplaySchema = z55.object({
+  kind: z55.literal("passes-memberships"),
+  state: z55.enum(["empty", "ready"]),
+  className: z55.string().nullable(),
+  layout: z55.enum(["grid", "list"]),
+  columns: z55.string(),
+  emptyMessage: z55.string(),
+  passesHeading: z55.string(),
+  membershipsHeading: z55.string(),
+  passes: z55.array(passCardDisplaySchema),
+  memberships: z55.array(membershipCardDisplaySchema)
+});
+var cartLineDisplaySchema = z55.object({
+  key: z55.string(),
+  title: z55.string(),
+  priceLabel: z55.string(),
+  quantity: z55.number(),
+  quantityEditable: z55.boolean()
+});
+var cartDisplaySchema = z55.object({
+  kind: z55.literal("cart"),
+  state: z55.enum(["empty", "ready"]),
+  heading: z55.string().nullable(),
+  className: z55.string().nullable(),
+  emptyMessage: z55.string(),
+  supportText: z55.string().nullable(),
+  items: z55.array(cartLineDisplaySchema),
+  subtotalLabel: z55.string().nullable(),
+  checkoutButtonText: z55.string(),
+  clearButtonText: z55.string()
+});
+var checkoutDisplaySchema = z55.object({
+  kind: z55.literal("checkout"),
+  state: z55.enum(["empty", "blocked", "ready"]),
+  heading: z55.string().nullable(),
+  className: z55.string().nullable(),
+  message: z55.string().nullable(),
+  submitButtonText: z55.string()
+});
+var passesMembershipsHydrationSchema = z55.object({
+  passes: z55.array(publicPassProductSchema),
+  memberships: z55.array(publicMembershipProductSchema),
+  passPurchaseMode: z55.enum(["add_to_cart", "buy_now"])
+});
+var productListHydrationSchema = z55.object({
+  products: z55.array(publicProductSchema),
+  showSummary: z55.boolean(),
+  showBadges: z55.boolean(),
+  showPrices: z55.boolean(),
+  addButtonText: z55.string()
+});
+var productDetailHydrationSchema = z55.object({
+  products: z55.array(publicProductSchema),
+  productId: z55.string().nullable(),
+  showSummary: z55.boolean(),
+  showBadges: z55.boolean(),
+  showBody: z55.boolean(),
+  addButtonText: z55.string()
+});
+var cartHydrationSchema = z55.object({
+  emptyStateText: z55.string(),
+  checkoutButtonText: z55.string(),
+  clearButtonText: z55.string()
+});
+var checkoutHydrationSchema = z55.object({
+  emptyStateText: z55.string(),
+  submitButtonText: z55.string()
+});
+var passesMembershipsRenderSchema = z55.object({
   display: passesMembershipsDisplaySchema,
   hydration: passesMembershipsHydrationSchema
 });
-var productListRenderSchema = z56.object({
+var productListRenderSchema = z55.object({
   display: productListDisplaySchema,
   hydration: productListHydrationSchema
 });
-var productDetailRenderSchema = z56.object({
+var productDetailRenderSchema = z55.object({
   display: productDetailDisplaySchema,
   hydration: productDetailHydrationSchema
 });
-var cartRenderSchema = z56.object({
+var cartRenderSchema = z55.object({
   display: cartDisplaySchema,
   hydration: cartHydrationSchema
 });
-var checkoutRenderSchema = z56.object({
+var checkoutRenderSchema = z55.object({
   display: checkoutDisplaySchema,
   hydration: checkoutHydrationSchema
 });
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
-var shopIslandMetaCodec = createZodCodec(z56.object({
-  siteId: z56.string().optional(),
-  apiBaseUrl: z56.string().optional(),
+var shopIslandMetaCodec = createZodCodec(z55.object({
+  siteId: z55.string().optional(),
+  apiBaseUrl: z55.string().optional(),
   stage: previewStageSchema.optional()
 }));
 var shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -24826,9 +24760,9 @@ var shopBlockDefinition = {
   runtime: shopBlockRuntime,
   dataSchemas: {
     // listPublicPasses returns { passes: [...] }
-    passes: z57.object({ passes: z57.array(publicPassProductSchema) }).optional(),
+    passes: z56.object({ passes: z56.array(publicPassProductSchema) }).optional(),
     // listPublicMemberships returns { memberships: [...] }
-    memberships: z57.object({ memberships: z57.array(publicMembershipProductSchema) }).optional()
+    memberships: z56.object({ memberships: z56.array(publicMembershipProductSchema) }).optional()
   },
   dataLoaders: {
     // Load passes for display
@@ -24851,7 +24785,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z58 } from "zod";
+import { z as z57 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -24993,7 +24927,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z58.object({
+var productListDataSchema = z57.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -25263,72 +25197,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z59 } from "zod";
-var publicGiftCardOfferSchema = z59.object({
-  id: z59.string(),
-  kind: z59.literal("gift_card"),
-  title: z59.string(),
-  description: z59.string().nullable(),
-  sortOrder: z59.number().int(),
-  giftCard: z59.object({
-    fixedDenominations: z59.array(z59.number().int().positive()),
-    customAmountEnabled: z59.boolean(),
-    customAmountMinCents: z59.number().int().positive(),
-    customAmountMaxCents: z59.number().int().positive()
+import { z as z58 } from "zod";
+var publicGiftCardOfferSchema = z58.object({
+  id: z58.string(),
+  kind: z58.literal("gift_card"),
+  title: z58.string(),
+  description: z58.string().nullable(),
+  sortOrder: z58.number().int(),
+  giftCard: z58.object({
+    fixedDenominations: z58.array(z58.number().int().positive()),
+    customAmountEnabled: z58.boolean(),
+    customAmountMinCents: z58.number().int().positive(),
+    customAmountMaxCents: z58.number().int().positive()
   }),
-  voucher: z59.null()
-});
-var publicVoucherOfferSchema = z59.object({
-  id: z59.string(),
-  kind: z59.literal("voucher"),
-  title: z59.string(),
-  description: z59.string().nullable(),
-  sortOrder: z59.number().int(),
-  giftCard: z59.null(),
-  voucher: z59.object({
-    purchaseAmountCents: z59.number().int().positive()
+  voucher: z58.null()
+});
+var publicVoucherOfferSchema = z58.object({
+  id: z58.string(),
+  kind: z58.literal("voucher"),
+  title: z58.string(),
+  description: z58.string().nullable(),
+  sortOrder: z58.number().int(),
+  giftCard: z58.null(),
+  voucher: z58.object({
+    purchaseAmountCents: z58.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z59.object({
-  currency: z59.string(),
-  giftCards: z59.array(publicGiftCardOfferSchema),
-  vouchers: z59.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z58.object({
+  currency: z58.string(),
+  giftCards: z58.array(publicGiftCardOfferSchema),
+  vouchers: z58.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z59.object({
-  siteId: z59.string().optional(),
-  apiBaseUrl: z59.string().optional(),
+var giftingSourceSchema = z58.object({
+  siteId: z58.string().optional(),
+  apiBaseUrl: z58.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  className: z59.string().nullable().optional(),
-  heading: z59.string().nullable().optional(),
-  intro: z59.string().nullable().optional(),
-  giftCardsHeading: z59.string().nullable().optional(),
-  vouchersHeading: z59.string().nullable().optional(),
-  emptyStateText: z59.string().nullable().optional(),
-  checkoutButtonText: z59.string().nullable().optional(),
-  successMessage: z59.string().nullable().optional()
-});
-var giftingDisplaySchema = z59.object({
-  kind: z59.literal("gifting"),
-  state: z59.literal("ready"),
-  className: z59.string().nullable(),
-  heading: z59.string(),
-  intro: z59.string().nullable(),
-  giftCardsHeading: z59.string(),
-  vouchersHeading: z59.string(),
-  emptyStateText: z59.string()
-});
-var giftingHydrationSchema = z59.object({
+  className: z58.string().nullable().optional(),
+  heading: z58.string().nullable().optional(),
+  intro: z58.string().nullable().optional(),
+  giftCardsHeading: z58.string().nullable().optional(),
+  vouchersHeading: z58.string().nullable().optional(),
+  emptyStateText: z58.string().nullable().optional(),
+  checkoutButtonText: z58.string().nullable().optional(),
+  successMessage: z58.string().nullable().optional()
+});
+var giftingDisplaySchema = z58.object({
+  kind: z58.literal("gifting"),
+  state: z58.literal("ready"),
+  className: z58.string().nullable(),
+  heading: z58.string(),
+  intro: z58.string().nullable(),
+  giftCardsHeading: z58.string(),
+  vouchersHeading: z58.string(),
+  emptyStateText: z58.string()
+});
+var giftingHydrationSchema = z58.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z59.string(),
-  successMessage: z59.string()
+  checkoutButtonText: z58.string(),
+  successMessage: z58.string()
 });
-var giftingRenderSchema = z59.object({
+var giftingRenderSchema = z58.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z59.object({
-  siteId: z59.string().optional(),
-  apiBaseUrl: z59.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z58.object({
+  siteId: z58.string().optional(),
+  apiBaseUrl: z58.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -25499,7 +25433,7 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z60 } from "zod";
+import { z as z59 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset2, options) {
@@ -25553,49 +25487,49 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z60.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterFieldSchema = z60.object({
-  id: z60.string(),
-  type: z60.enum(["email", "text"]),
-  label: z60.string(),
-  required: z60.boolean(),
-  placeholder: z60.string().optional()
-});
-var newsletterSourceSchema = z60.object({
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional(),
-  listId: z60.string().nullable().optional(),
+var newsletterPresetSchema = z59.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterFieldSchema = z59.object({
+  id: z59.string(),
+  type: z59.enum(["email", "text"]),
+  label: z59.string(),
+  required: z59.boolean(),
+  placeholder: z59.string().optional()
+});
+var newsletterSourceSchema = z59.object({
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional(),
+  listId: z59.string().nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  includePhone: z60.boolean().optional(),
-  buttonLabel: z60.string().nullable().optional(),
-  successMessage: z60.string().nullable().optional(),
-  privacyNote: z60.string().nullable().optional(),
-  tags: z60.string().nullable().optional(),
-  spamProtectionEnabled: z60.boolean().optional(),
-  className: z60.string().nullable().optional()
-});
-var newsletterDisplaySchema = z60.object({
-  kind: z60.literal("newsletter-form"),
-  className: z60.string().nullable(),
-  buttonLabel: z60.string(),
-  successMessage: z60.string().nullable(),
-  privacyNote: z60.string().nullable(),
-  fields: z60.array(newsletterFieldSchema)
-});
-var newsletterHydrationSchema = z60.object({
-  listId: z60.string().nullable().optional(),
+  includePhone: z59.boolean().optional(),
+  buttonLabel: z59.string().nullable().optional(),
+  successMessage: z59.string().nullable().optional(),
+  privacyNote: z59.string().nullable().optional(),
+  tags: z59.string().nullable().optional(),
+  spamProtectionEnabled: z59.boolean().optional(),
+  className: z59.string().nullable().optional()
+});
+var newsletterDisplaySchema = z59.object({
+  kind: z59.literal("newsletter-form"),
+  className: z59.string().nullable(),
+  buttonLabel: z59.string(),
+  successMessage: z59.string().nullable(),
+  privacyNote: z59.string().nullable(),
+  fields: z59.array(newsletterFieldSchema)
+});
+var newsletterHydrationSchema = z59.object({
+  listId: z59.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z60.boolean(),
-  tags: z60.string().nullable().optional(),
-  spamProtectionEnabled: z60.boolean().optional()
+  includePhone: z59.boolean(),
+  tags: z59.string().nullable().optional(),
+  spamProtectionEnabled: z59.boolean().optional()
 });
-var newsletterRenderSchema = z60.object({
+var newsletterRenderSchema = z59.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z60.object({
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z59.object({
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -25716,23 +25650,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z61 } from "zod";
+import { z as z60 } from "zod";
 var ITEM_NAME2 = "member";
 var teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
   message: "Team member photos must be image media"
 }).nullable();
-var teamMemberDataSchema = z61.object({
-  _type: z61.literal("teamMember"),
-  id: z61.string(),
-  name: z61.string(),
-  role: z61.string().nullable(),
-  roleLabel: z61.string().nullable(),
-  bio: z61.string().nullable(),
-  summary: z61.string().nullable(),
+var teamMemberDataSchema = z60.object({
+  _type: z60.literal("teamMember"),
+  id: z60.string(),
+  name: z60.string(),
+  role: z60.string().nullable(),
+  roleLabel: z60.string().nullable(),
+  bio: z60.string().nullable(),
+  summary: z60.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z61.string().nullable()
+  profilePath: z60.string().nullable()
 });
-var teamMembersDataSchema = z61.array(teamMemberDataSchema);
+var teamMembersDataSchema = z60.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -27506,10 +27440,10 @@ function normalizeDataLoaders(def) {
 }
 function normalizeContent(block) {
   const source = block.draftContent ?? block.content ?? block.publishedContent ?? {};
-  if (!isObjectRecord(source)) return {};
+  if (!isObjectRecord2(source)) return {};
   if ("data" in source) {
     const data = source.data;
-    if (isObjectRecord(data)) {
+    if (isObjectRecord2(data)) {
       return data;
     }
     if (data === null || data === void 0) {
@@ -27634,7 +27568,7 @@ async function prefetchBlockData(page, context, options) {
 
 // ../blocks/src/system/data/normalizeLoaderParams.ts
 function toStringParams(value) {
-  if (!isObjectRecord(value)) return {};
+  if (!isObjectRecord2(value)) return {};
   const out = {};
   for (const [k, v] of Object.entries(value)) {
     if (typeof v === "string") out[k] = v;
@@ -27692,6 +27626,74 @@ function normalizeLoaderParams(endpoint, params, context) {
   return out;
 }
 
+// ../api/src/aiPlayground.ts
+import { z as z61 } from "zod";
+var Rfc6902PatchOp = z61.discriminatedUnion("op", [
+  // Standard RFC-6902 operations
+  z61.object({
+    op: z61.literal("add"),
+    path: z61.string(),
+    value: z61.unknown()
+  }),
+  z61.object({
+    op: z61.literal("remove"),
+    path: z61.string()
+  }),
+  z61.object({
+    op: z61.literal("replace"),
+    path: z61.string(),
+    value: z61.unknown()
+  }),
+  z61.object({
+    op: z61.literal("move"),
+    from: z61.string(),
+    path: z61.string()
+  }),
+  z61.object({
+    op: z61.literal("copy"),
+    from: z61.string(),
+    path: z61.string()
+  }),
+  // Block-level operations (Phase 2)
+  z61.object({
+    op: z61.literal("add_block"),
+    blockKind: z61.string(),
+    afterBlockId: z61.string().nullable(),
+    content: z61.record(z61.string(), z61.unknown()),
+    rationale: z61.string()
+  }),
+  z61.object({
+    op: z61.literal("delete_block"),
+    blockId: z61.string(),
+    rationale: z61.string()
+  }),
+  z61.object({
+    op: z61.literal("reorder_block"),
+    blockId: z61.string(),
+    afterBlockId: z61.string().nullable(),
+    rationale: z61.string()
+  })
+]);
+var PlaygroundProposeRequest = z61.object({
+  request: z61.string().min(1).max(2e3)
+});
+var MultiPagePatchEnvelope = z61.object({
+  pageId: z61.string(),
+  blockId: z61.string().optional(),
+  // Not present for page-level ops
+  blockKind: z61.string().optional(),
+  blockPurpose: z61.string().optional().nullable(),
+  ops: z61.array(Rfc6902PatchOp),
+  rationale: z61.string(),
+  currentContent: z61.record(z61.string(), z61.unknown()).optional()
+});
+var MultiPageUpdateResponse = z61.object({
+  patches: z61.array(MultiPagePatchEnvelope),
+  assistantMessage: z61.string(),
+  pagesModified: z61.number(),
+  toolCallsUsed: z61.number()
+});
+
 // src/data/prefetchBlockData.ts
 var SUPPORTED_LOADER_ENDPOINTS2 = [
   "listPublishedEntries",