@riverbankcms/sdk 0.82.0 → 0.84.0

package/dist/client/rendering/client.mjs

@@ -1360,7 +1360,7 @@ function rgbColorValue(token) {
   if (alpha === void 0) {
     return `rgb(var(${cssVar}))`;
   }
-  return `rgba(var(${cssVar}), ${alpha})`;
+  return `rgb(var(${cssVar}) / ${alpha})`;
 }
 function backgroundColorStyle(token) {
   return { backgroundColor: rgbColorValue(token) };
@@ -2461,6 +2461,102 @@ var init_joy_stamp = __esm({
   }
 });
 
+// ../theme-core/src/buttons/personalities/ornate-ritual.ts
+var ornateRitual;
+var init_ornate_ritual = __esm({
+  "../theme-core/src/buttons/personalities/ornate-ritual.ts"() {
+    "use strict";
+    init_types2();
+    ornateRitual = defineButtonPersonality({
+      id: "ornate-ritual",
+      name: "Ornate Ritual",
+      description: "Ceremonial framed buttons with jewel-toned fills and quiet color-change hover states.",
+      tags: { tone: "classic", energy: "vibrant", motion: "subtle", era: "organic" },
+      buttonSystem: {
+        global: {
+          cornerStyle: "rounded",
+          shadow: "none",
+          textTransform: "uppercase",
+          fontWeight: 600,
+          borderWidth: 1,
+          hoverTransform: "none",
+          hoverColor: "none",
+          letterSpacing: "loose"
+        },
+        sizes: {
+          sm: { padding: "0.5625rem 1.25rem", fontSize: "text-xs" },
+          md: { padding: "0.75rem 1.75rem", fontSize: "text-xs" },
+          lg: { padding: "0.875rem 2.25rem", fontSize: "text-sm" },
+          xl: { padding: "1rem 2.75rem", fontSize: "text-base" }
+        },
+        variants: [
+          {
+            id: "primary",
+            name: "Primary",
+            enabled: true,
+            priority: 1,
+            background: { type: "solid", colorToken: "primary" },
+            textColorToken: "primaryForeground",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "primary-100" } }],
+              active: [{ effectId: "scale-down", options: { scale: "0.98" } }]
+            }
+          },
+          {
+            id: "secondary",
+            name: "Secondary",
+            enabled: true,
+            priority: 2,
+            background: { type: "solid", colorToken: "secondary" },
+            textColorToken: "primaryForeground",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
+            }
+          },
+          {
+            id: "outline",
+            name: "Outline",
+            enabled: true,
+            priority: 3,
+            background: { type: "transparent" },
+            textColorToken: "primary",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "muted" } }]
+            }
+          },
+          {
+            id: "ghost",
+            name: "Ghost",
+            enabled: true,
+            priority: 3,
+            background: { type: "transparent" },
+            textColorToken: "accent",
+            borderRadius: "rounded-none",
+            sizes: {
+              sm: { padding: "0.375rem 0", fontSize: "text-xs" },
+              md: { padding: "0.5rem 0", fontSize: "text-sm" },
+              lg: { padding: "0.625rem 0", fontSize: "text-base" },
+              xl: { padding: "0.75rem 0", fontSize: "text-lg" }
+            },
+            effects: {
+              base: [{ effectId: "border-bottom-grow", options: { height: 1, colorToken: "accent", origin: "left" } }]
+            }
+          }
+        ]
+      }
+    });
+  }
+});
+
 // ../theme-core/src/buttons/personalities/pebble.ts
 var pebble;
 var init_pebble = __esm({
@@ -2756,6 +2852,7 @@ var init_personalities = __esm({
     init_editorial_link();
     init_ink_stamp();
     init_joy_stamp();
+    init_ornate_ritual();
     init_pebble();
     init_showtime_pill();
     init_soft_pill();
@@ -2769,7 +2866,8 @@ var init_personalities = __esm({
       inkStamp,
       brushedWash,
       showtimePill,
-      joyStamp
+      joyStamp,
+      ornateRitual
     ];
     personalitiesById = new Map(
       buttonPersonalities.map((p) => [p.id, p])
@@ -7461,6 +7559,9 @@ var init_types5 = __esm({
 function defineExactCatalog() {
   return (entries) => entries;
 }
+function asDesignBlockId(value) {
+  return brandNonEmptyString(value, "DesignBlockId");
+}
 function asAppearancePresetId(value) {
   return brandNonEmptyString(value, "AppearancePresetId");
 }
@@ -7513,6 +7614,7 @@ var init_types6 = __esm({
     ];
     eyebrowTreatmentValues = [
       "plain",
+      "accent",
       "pill",
       "accent-pill",
       "pill-bounce",
@@ -9049,6 +9151,132 @@ var init_shared = __esm({
   }
 });
 
+// ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
+function resolveRuntimeEventPricing(event) {
+  if (isPublicEventPricing(event.pricing)) {
+    return event.pricing;
+  }
+  const legacy = event;
+  const currency = readCurrency(legacy.currency);
+  if (event.requiresRegistration === false) {
+    return {
+      kind: "drop_in",
+      currency,
+      display: { kind: "free", currency }
+    };
+  }
+  if (legacy.pricingMode === "ticket_types") {
+    const ticketTypes = Array.isArray(legacy.ticketTypes) ? legacy.ticketTypes.filter(isPublicEventTicketType) : [];
+    return {
+      kind: "ticket_types",
+      currency,
+      ticketTypes,
+      display: readTicketTypePriceDisplay(legacy.priceDisplay, currency)
+    };
+  }
+  const amount = typeof legacy.price === "number" ? legacy.price : 0;
+  if (legacy.pricingType === "paid" && amount > 0) {
+    return {
+      kind: "single_paid",
+      amount,
+      currency,
+      display: { kind: "exact", amount, currency }
+    };
+  }
+  return {
+    kind: "free_registration",
+    currency,
+    display: { kind: "free", currency }
+  };
+}
+function readCurrency(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : DEFAULT_EVENT_CURRENCY;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPublicEventPricing(value) {
+  if (!isRecord6(value) || typeof value.kind !== "string") return false;
+  return value.kind === "drop_in" || value.kind === "free_registration" || value.kind === "single_paid" || value.kind === "ticket_types" || value.kind === "course";
+}
+function isPublicEventTicketType(value) {
+  return isRecord6(value) && typeof value.id === "string";
+}
+function readTicketTypePriceDisplay(value, currency) {
+  const display = readLegacyPriceDisplay(value, currency);
+  return display.kind === "course" ? { kind: "unavailable", currency } : display;
+}
+function readLegacyPriceDisplay(value, currency) {
+  if (!isRecord6(value) || typeof value.kind !== "string") {
+    return { kind: "unavailable", currency };
+  }
+  const displayCurrency = readCurrency(value.currency);
+  switch (value.kind) {
+    case "free":
+      return { kind: "free", currency: displayCurrency };
+    case "exact":
+      return readAmount(value.amount) !== null ? {
+        kind: "exact",
+        amount: readAmount(value.amount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "from":
+      return readAmount(value.amount) !== null ? {
+        kind: "from",
+        amount: readAmount(value.amount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "mixed":
+      return readAmount(value.paidFromAmount) !== null ? {
+        kind: "mixed",
+        paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "unavailable":
+      return { kind: "unavailable", currency: displayCurrency };
+    case "course":
+      return isRecord6(value.display) ? {
+        kind: "course",
+        display: readCoursePriceDisplay(value.display, displayCurrency)
+      } : {
+        kind: "course",
+        display: { kind: "unavailable", currency: displayCurrency }
+      };
+    default:
+      return { kind: "unavailable", currency };
+  }
+}
+function readCoursePriceDisplay(value, currency) {
+  switch (value.kind) {
+    case "free":
+      return { kind: "free", currency: readCurrency(value.currency) };
+    case "exact":
+      return readAmount(value.amount) !== null ? {
+        kind: "exact",
+        amount: readAmount(value.amount) ?? 0,
+        currency: readCurrency(value.currency)
+      } : { kind: "unavailable", currency };
+    case "from":
+      return readAmount(value.amount) !== null ? {
+        kind: "from",
+        amount: readAmount(value.amount) ?? 0,
+        currency: readCurrency(value.currency)
+      } : { kind: "unavailable", currency };
+    default:
+      return { kind: "unavailable", currency };
+  }
+}
+function readAmount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var DEFAULT_EVENT_CURRENCY;
+var init_pricing2 = __esm({
+  "../blocks/src/system/runtime/nodes/events/shared/pricing.ts"() {
+    "use strict";
+    DEFAULT_EVENT_CURRENCY = "USD";
+  }
+});
+
 // ../calendar/src/grid.ts
 function formatDateKey2(date) {
   const year = date.getFullYear();
@@ -9765,7 +9993,9 @@ function formatPublicEventPriceDisplay(display) {
   }
 }
 function formatEventPrice(event) {
-  return formatPublicEventPriceDisplay(publicEventPricingDisplay(event.pricing));
+  return formatPublicEventPriceDisplay(
+    publicEventPricingDisplay(resolveRuntimeEventPricing(event))
+  );
 }
 function resolveEventCta(event, buttonText) {
   const { isFull: isSoldOut } = getEventAvailability(event);
@@ -9786,6 +10016,7 @@ var init_utils = __esm({
     init_src3();
     init_shared();
     init_eventCapacity();
+    init_pricing2();
     init_src3();
     init_src3();
     COLUMN_CLASSES = {
@@ -9881,8 +10112,9 @@ function EventDetailsView({
     priceCents: selected.course.priceCents,
     currency: selected.course.currency
   }) : null;
-  const eventPricingType = publicEventPricingType(selected.pricing);
-  const eventPricingCurrency = publicEventPricingCurrency(selected.pricing) ?? "USD";
+  const eventPricing = resolveRuntimeEventPricing(selected);
+  const eventPricingType = publicEventPricingType(eventPricing);
+  const eventPricingCurrency = publicEventPricingCurrency(eventPricing) ?? "USD";
   const isPaid = eventPricingType === "paid";
   const shouldShowCoursePricing = showCost && !isDropIn && coursePricing !== null;
   const shouldShowEventCost = showCost && isPaid && !isDropIn && coursePricing === null;
@@ -9980,6 +10212,7 @@ var init_view = __esm({
     "use strict";
     init_src();
     init_shared();
+    init_pricing2();
     init_utils();
     init_DateTimeTile();
     init_CoursePricingDisplay();
@@ -12435,6 +12668,15 @@ var init_onColor = __esm({
   }
 });
 
+// ../theme-core/src/site-styles/accessibleSurfaces.ts
+var init_accessibleSurfaces = __esm({
+  "../theme-core/src/site-styles/accessibleSurfaces.ts"() {
+    "use strict";
+    init_contrast2();
+    init_onColor();
+  }
+});
+
 // ../theme-core/src/site-styles/headerCtaVariants.ts
 function hasButtonVariant(theme, variantId) {
   return theme.buttons?.variants.some((variant) => variant.enabled && variant.id === variantId) ?? false;
@@ -12464,6 +12706,13 @@ var init_headerCtaVariants = __esm({
   }
 });
 
+// ../theme-core/src/mock-themes/modern-minimal.ts
+var init_modern_minimal = __esm({
+  "../theme-core/src/mock-themes/modern-minimal.ts"() {
+    "use strict";
+  }
+});
+
 // ../theme-core/src/palette/generateCssVars.ts
 var init_generateCssVars = __esm({
   "../theme-core/src/palette/generateCssVars.ts"() {
@@ -14094,7 +14343,7 @@ var init_warm_neutral = __esm({
 });
 
 // ../theme-core/src/palette/variants/warm-dark.ts
-var warmDarkEmber;
+var warmDarkEmber, warmDarkKirtanGold;
 var init_warm_dark = __esm({
   "../theme-core/src/palette/variants/warm-dark.ts"() {
     "use strict";
@@ -14121,6 +14370,28 @@ var init_warm_dark = __esm({
         { name: "border", hex: "#894e31" }
       ]
     });
+    warmDarkKirtanGold = definePaletteVariant({
+      id: "warm-dark-kirtan-gold",
+      name: "Warm Dark \u2014 Kirtan Gold",
+      description: "Deep plum ground with pale gold primary, rose accent, and soft devotional text.",
+      tags: { tone: "bold", energy: "calm", era: "editorial" },
+      mode: "dark",
+      colors: [
+        { name: "primary", hex: "#ffcdb2" },
+        { name: "secondary", hex: "#b5838d" },
+        { name: "accent", hex: "#e5989b" },
+        { name: "success", hex: "#8fbf8f" },
+        { name: "warning", hex: "#f2b86b" },
+        { name: "destructive", hex: "#d96b6b" },
+        { name: "background", hex: "#403944" },
+        { name: "surface", hex: "#403944" },
+        { name: "surfaceAlt", hex: "#372f3b" },
+        { name: "muted", hex: "#4d4550" },
+        { name: "text", hex: "#e6d2d5" },
+        { name: "primaryForeground", hex: "#403944" },
+        { name: "border", hex: "#8d747a" }
+      ]
+    });
   }
 });
 
@@ -14156,7 +14427,8 @@ var init_variants = __esm({
       softNaturalWatercolor,
       softNaturalLilac,
       // Warm-dark family (dark mode)
-      warmDarkEmber
+      warmDarkEmber,
+      warmDarkKirtanGold
     ];
     paletteVariantsById = new Map(
       paletteVariants.map((v) => [v.id, v])
@@ -14183,6 +14455,13 @@ var init_tokens2 = __esm({
   }
 });
 
+// ../theme-core/src/site-styles/schemaVersionedJson.ts
+var init_schemaVersionedJson = __esm({
+  "../theme-core/src/site-styles/schemaVersionedJson.ts"() {
+    "use strict";
+  }
+});
+
 // ../theme-core/src/accordions/siteStyleDefaults.ts
 var editorialDividedAccordionSystem, quietUnderlinedAccordionSystem, calmPanelAccordionSystem, boldBorderedAccordionSystem, warmInsetAccordionSystem, softEarthAccordionSystem;
 var init_siteStyleDefaults = __esm({
@@ -15421,8 +15700,69 @@ var init_headerLooks = __esm({
 function asFooterLookId(value) {
   return value;
 }
+function asFooterLayoutId(value) {
+  return value;
+}
+function asFooterStyleId(value) {
+  return value;
+}
+function identityQuietFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "simple",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    navStyle: "minimal",
+    navWeight: "regular",
+    navColor: "text",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "regular",
+      textTransform: "none",
+      italic: false,
+      colorToken: "text",
+      hoverColorToken: "primary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "default",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: true,
+      placement: "left",
+      size: "sm",
+      align: "start"
+    },
+    bottomBar: {
+      enabled: false,
+      fullBleed: false,
+      textAlign: "left",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "none"
+      }
+    }
+  };
+}
 function mutedGroundingFooter(theme) {
-  return theme.footer;
+  return {
+    ...identityQuietFooter(theme),
+    background: theme.footer.background,
+    navStyle: theme.footer.navStyle,
+    navColor: theme.footer.navColor,
+    navWeight: theme.footer.navWeight,
+    navLinkStyle: theme.footer.navLinkStyle,
+    bottomTextLinkStyle: theme.footer.bottomTextLinkStyle
+  };
 }
 function brandTwoBandFooter(theme) {
   return {
@@ -15527,6 +15867,53 @@ function centeredCalmFooter(theme) {
     }
   };
 }
+function splitEditorialFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "split",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    navStyle: "minimal",
+    navWeight: "regular",
+    navColor: "text",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "regular",
+      textTransform: "none",
+      italic: false,
+      colorToken: "text",
+      hoverColorToken: "primary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "relaxed",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: true,
+      placement: "right",
+      size: "sm",
+      align: "end"
+    },
+    bottomBar: {
+      enabled: true,
+      fullBleed: false,
+      textAlign: "left",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "thin"
+      }
+    }
+  };
+}
 function editorialColumnsFooter(theme) {
   return {
     ...theme.footer,
@@ -15568,33 +15955,110 @@ function editorialColumnsFooter(theme) {
     }
   };
 }
-var guaranteedFallbackFooterLookId, footerLookCatalog, footerLooksById;
+var guaranteedFallbackFooterLookId, footerLayoutCatalog, footerStyleCatalog, footerLayoutsById, footerStylesById, footerLookCatalog, footerLooksById;
 var init_footerLooks = __esm({
   "../theme-core/src/site-styles/footerLooks.ts"() {
     "use strict";
     init_customizableSurfaces();
     init_types6();
-    guaranteedFallbackFooterLookId = asFooterLookId("footer-muted-grounding");
+    guaranteedFallbackFooterLookId = asFooterLookId("footer-identity-quiet");
+    footerLayoutCatalog = defineExactCatalog()([
+      {
+        id: asFooterLayoutId("identity"),
+        label: "Identity",
+        description: "Logo, site text, address, and legal copy without relying on footer navigation."
+      },
+      {
+        id: asFooterLayoutId("centered"),
+        label: "Centered",
+        description: "A calm centered stack for identity, short copy, and optional compact navigation.",
+        maxRecommendedNavDensity: "sparse"
+      },
+      {
+        id: asFooterLayoutId("split"),
+        label: "Split",
+        description: "Navigation and brand signoff separated into a wider split footer.",
+        requiresFooterNav: true,
+        maxRecommendedNavDensity: "balanced"
+      },
+      {
+        id: asFooterLayoutId("columns"),
+        label: "Columns",
+        description: "Grouped footer navigation columns with a supporting bottom line.",
+        requiresFooterNav: true,
+        requiresFooterNavGroups: true
+      }
+    ]);
+    footerStyleCatalog = defineExactCatalog()([
+      {
+        id: asFooterStyleId("quiet"),
+        label: "Quiet",
+        description: "Lightweight, practical footer treatment."
+      },
+      {
+        id: asFooterStyleId("calm"),
+        label: "Calm",
+        description: "Soft centered treatment with restrained dividers."
+      },
+      {
+        id: asFooterStyleId("editorial"),
+        label: "Editorial",
+        description: "Text-forward treatment with fine-line structure."
+      },
+      {
+        id: asFooterStyleId("brand-band"),
+        label: "Brand band",
+        description: "High-contrast brand treatment with a stronger bottom bar."
+      }
+    ]);
+    footerLayoutsById = new Map(
+      footerLayoutCatalog.map((layout) => [layout.id, layout])
+    );
+    footerStylesById = new Map(
+      footerStyleCatalog.map((style) => [style.id, style])
+    );
     footerLookCatalog = defineExactCatalog()([
+      {
+        id: asFooterLookId("footer-identity-quiet"),
+        label: "Identity footer",
+        layoutId: asFooterLayoutId("identity"),
+        styleId: asFooterStyleId("quiet"),
+        compile: identityQuietFooter
+      },
       {
         id: asFooterLookId("footer-muted-grounding"),
         label: "Muted grounding footer",
+        layoutId: asFooterLayoutId("identity"),
+        styleId: asFooterStyleId("quiet"),
+        hiddenFromLayoutStyleControls: true,
         compile: mutedGroundingFooter
       },
       {
         id: asFooterLookId("footer-centered-calm"),
         label: "Centered calm footer",
+        layoutId: asFooterLayoutId("centered"),
+        styleId: asFooterStyleId("calm"),
         compile: centeredCalmFooter
       },
+      {
+        id: asFooterLookId("footer-split-editorial"),
+        label: "Split editorial footer",
+        layoutId: asFooterLayoutId("split"),
+        styleId: asFooterStyleId("editorial"),
+        compile: splitEditorialFooter
+      },
       {
         id: asFooterLookId("footer-editorial-columns"),
         label: "Editorial columns footer",
+        layoutId: asFooterLayoutId("columns"),
+        styleId: asFooterStyleId("editorial"),
         compile: editorialColumnsFooter
       },
       {
         id: asFooterLookId("site-footer-brand-two-band"),
         label: "Two-band brand footer",
-        maxRecommendedNavDensity: "balanced",
+        layoutId: asFooterLayoutId("split"),
+        styleId: asFooterStyleId("brand-band"),
         allowedContentPresence: ["default-footer", "default-and-blocks"],
         compile: brandTwoBandFooter
       }
@@ -15684,7 +16148,7 @@ function defineTypographyPreset(preset) {
     id: asTypographyPresetId(preset.id)
   };
 }
-var bodyReadablePolicy, headingFlexiblePolicy, displayHeadingPolicy, modernSansTypography, warmRoundedTypography, editorialSerifTypography, classicSerifTypography, luxeContrastTypography, boldDisplayTypography, originalJoyTypography, typographyPresets, typographyPresetsById;
+var bodyReadablePolicy, headingFlexiblePolicy, displayHeadingPolicy, modernSansTypography, warmRoundedTypography, editorialSerifTypography, classicSerifTypography, luxeContrastTypography, kirtanOrnateTypography, boldDisplayTypography, originalJoyTypography, typographyPresets, typographyPresetsById;
 var init_typographyPresets = __esm({
   "../theme-core/src/site-styles/typographyPresets.ts"() {
     "use strict";
@@ -15817,6 +16281,30 @@ var init_typographyPresets = __esm({
       },
       scale: "spacious"
     };
+    kirtanOrnateTypography = {
+      body: {
+        family: "Jost, system-ui, sans-serif",
+        size: "md",
+        weight: "regular",
+        lineHeight: "relaxed",
+        letterSpacing: "normal"
+      },
+      headings: {
+        default: {
+          family: "Marcellus, Georgia, serif",
+          weight: "regular",
+          lineHeight: "normal",
+          letterSpacing: "normal",
+          colorToken: "primary",
+          italic: null,
+          case: null
+        },
+        h1: { size: "2xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h2: { size: "xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h3: { size: "md", weight: "regular", lineHeight: "relaxed", letterSpacing: "normal", italic: null }
+      },
+      scale: "spacious"
+    };
     boldDisplayTypography = {
       body: {
         family: "Manrope, system-ui, sans-serif",
@@ -15851,16 +16339,16 @@ var init_typographyPresets = __esm({
       },
       headings: {
         default: {
-          family: "Bricolage Grotesque, system-ui, sans-serif",
-          weight: "bold",
+          family: "Lobster, cursive",
+          weight: "regular",
           lineHeight: "normal",
-          letterSpacing: "tight",
+          letterSpacing: "normal",
           italic: null,
           case: null
         },
-        h1: { size: "2xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
-        h2: { size: "xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
-        h3: { size: "lg", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null }
+        h1: { size: "2xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h2: { size: "xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h3: { size: "lg", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null }
       },
       scale: "balanced"
     };
@@ -15925,6 +16413,32 @@ var init_typographyPresets = __esm({
         slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
         typography: luxeContrastTypography
       }),
+      defineTypographyPreset({
+        id: "typography-preset:kirtan-ornate",
+        name: "Kirtan Ornate",
+        description: "Marcellus devotional headings over a refined Jost body, matching dark ceremonial layouts.",
+        defaultFonts: { body: "Jost, system-ui, sans-serif", heading: "Marcellus, Georgia, serif" },
+        recommendedFonts: {
+          body: ["Jost", "Manrope", "Inter"],
+          heading: ["Marcellus", "Cormorant Garamond", "Playfair Display"]
+        },
+        slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+        typography: kirtanOrnateTypography,
+        heroTypography: {
+          headlineSize: "6xl",
+          headlineLineHeight: "normal",
+          subheadlineSize: "xl",
+          subheadlineLineHeight: "relaxed",
+          microHeadlineSize: "5xl",
+          microHeadlineLineHeight: "normal",
+          microSubheadlineSize: "lg",
+          microSubheadlineLineHeight: "relaxed",
+          responsive: {
+            tablet: { headlineSize: "5xl" },
+            mobile: { headlineSize: "4xl", subheadlineSize: "lg" }
+          }
+        }
+      }),
       defineTypographyPreset({
         id: "typography-preset:bold-display",
         name: "Bold Display",
@@ -15954,11 +16468,11 @@ var init_typographyPresets = __esm({
       defineTypographyPreset({
         id: "typography-preset:original-joy",
         name: "Original Joy",
-        description: "Bold Bricolage Grotesque display headings over a clean DM Sans body, editorial and warm.",
-        defaultFonts: { body: "DM Sans, system-ui, sans-serif", heading: "Bricolage Grotesque, system-ui, sans-serif" },
+        description: "Lobster display headings over a clean DM Sans body, expressive and warm.",
+        defaultFonts: { body: "DM Sans, system-ui, sans-serif", heading: "Lobster, cursive" },
         recommendedFonts: {
           body: ["DM Sans", "Inter", "Manrope"],
-          heading: ["Bricolage Grotesque", "Space Grotesk", "Archivo"]
+          heading: ["Lobster", "Bricolage Grotesque", "Space Grotesk"]
         },
         slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
         typography: originalJoyTypography,
@@ -15984,6 +16498,344 @@ var init_typographyPresets = __esm({
   }
 });
 
+// ../theme-core/src/site-styles/designState.ts
+import { z as z30 } from "zod";
+function uniqueNonEmpty(values) {
+  const uniqueValues = [...new Set(values)];
+  const firstValue = uniqueValues[0];
+  if (!firstValue) {
+    throw new Error("Expected at least one Theme V2 design state option.");
+  }
+  return [firstValue, ...uniqueValues.slice(1)];
+}
+var themeV2DesignStateSchemaVersion, designResolutionPolicySchema, runtimeStyleFieldNameSchema, nonEmptyRuntimeStyleFieldNamesSchema, heroLegibilityStrategySchema, heroCompositionIntentSchema, heroTypographyScaleIntentSchema, sectionHeightIntentSchema, imageSurfaceTreatmentIntensitySchema, imageSurfaceMotionSchema, imageSurfaceTreatmentSchema, testimonialCardTreatmentSchema, tileTreatmentSchema, eventListTreatmentSchema, eyebrowTreatmentSchema, userPanelTreatments, userFlushTreatments, userFlushBleeds, contentFrameIntentSchema, blockDesignPlanSchema, styleAuthoritySchema, blockRuntimeStyleAuthoritySchema, persistedPageDesignStateV1Schema;
+var init_designState = __esm({
+  "../theme-core/src/site-styles/designState.ts"() {
+    "use strict";
+    init_sourceCatalogs();
+    init_types6();
+    init_schemaVersionedJson();
+    init_rawStyleFields();
+    init_rawStyleFields();
+    themeV2DesignStateSchemaVersion = 1;
+    designResolutionPolicySchema = z30.enum(["generated", "user", "admin", "sdk"]);
+    runtimeStyleFieldNameSchema = z30.enum(themeV2RuntimeStyleFieldNames);
+    nonEmptyRuntimeStyleFieldNamesSchema = z30.array(runtimeStyleFieldNameSchema).min(1).transform((fields) => [
+      fields[0],
+      ...fields.slice(1)
+    ]);
+    heroLegibilityStrategySchema = z30.enum([
+      "none",
+      "scrim-gradient",
+      "solid-panel"
+    ]);
+    heroCompositionIntentSchema = z30.enum([
+      "center",
+      "bottom-left"
+    ]);
+    heroTypographyScaleIntentSchema = z30.enum([
+      "quiet",
+      "editorial",
+      "display",
+      "poster"
+    ]);
+    sectionHeightIntentSchema = z30.enum([
+      "default",
+      "banner",
+      "hero",
+      "immersive"
+    ]);
+    imageSurfaceTreatmentIntensitySchema = z30.enum(["soft", "balanced", "strong"]);
+    imageSurfaceMotionSchema = z30.enum(["static", "fixed-frame"]);
+    imageSurfaceTreatmentSchema = z30.discriminatedUnion("kind", [
+      z30.object({ kind: z30.literal("none") }).strict(),
+      z30.object({
+        kind: z30.literal("brand-scrim"),
+        token: z30.enum(["primary", "secondary", "accent"]),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z30.object({
+        kind: z30.literal("brand-wash"),
+        token: z30.enum(["primary", "secondary", "accent"]),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z30.object({
+        kind: z30.literal("neutral-scrim"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z30.object({
+        kind: z30.literal("neutral-wash"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z30.object({
+        kind: z30.literal("solid-panel"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict()
+    ]);
+    testimonialCardTreatmentSchema = z30.enum(["default", "accent-quote"]);
+    tileTreatmentSchema = z30.enum(tileTreatmentValues);
+    eventListTreatmentSchema = z30.enum(eventListTreatmentValues);
+    eyebrowTreatmentSchema = z30.enum(eyebrowTreatmentValues);
+    userPanelTreatments = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
+    );
+    userFlushTreatments = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
+    );
+    userFlushBleeds = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
+    );
+    contentFrameIntentSchema = z30.discriminatedUnion("kind", [
+      z30.object({ kind: z30.literal("plain") }).strict(),
+      z30.object({
+        kind: z30.literal("panel"),
+        treatment: z30.enum(userPanelTreatments)
+      }).strict(),
+      z30.object({
+        kind: z30.literal("flush-panel"),
+        treatment: z30.enum(userFlushTreatments),
+        bleed: z30.enum(userFlushBleeds)
+      }).strict()
+    ]);
+    blockDesignPlanSchema = z30.object({
+      blockId: z30.string().min(1).transform(asDesignBlockId),
+      blockKind: z30.string().min(1),
+      purpose: z30.string().min(1),
+      sectionSurface: z30.enum(userDesignOptionCatalog.sectionSurfaces),
+      contentFrame: contentFrameIntentSchema,
+      itemSurface: z30.enum(userDesignOptionCatalog.itemSurfaces),
+      transitionAfter: z30.enum(userDesignOptionCatalog.transitions),
+      emphasis: z30.enum(userDesignOptionCatalog.emphases),
+      sectionHeight: sectionHeightIntentSchema.optional(),
+      heroLegibility: heroLegibilityStrategySchema.optional(),
+      heroComposition: heroCompositionIntentSchema.optional(),
+      heroTypographyScale: heroTypographyScaleIntentSchema.optional(),
+      imageSurfaceTreatment: imageSurfaceTreatmentSchema.optional(),
+      imageSurfaceMotion: imageSurfaceMotionSchema.optional(),
+      testimonialCardTreatment: testimonialCardTreatmentSchema.optional(),
+      tileTreatment: tileTreatmentSchema.optional(),
+      eventListTreatment: eventListTreatmentSchema.optional(),
+      eyebrowTreatment: eyebrowTreatmentSchema.optional()
+    }).strict();
+    styleAuthoritySchema = z30.discriminatedUnion("kind", [
+      z30.object({
+        kind: z30.literal("theme-v2"),
+        source: designResolutionPolicySchema,
+        siteStyleId: z30.string().min(1).transform(asSiteStyleId),
+        templateId: z30.string().min(1).transform(asDesignSystemTemplateId),
+        templateVersion: z30.number().int().nonnegative(),
+        resolverVersion: z30.number().int().nonnegative()
+      }).strict(),
+      z30.object({
+        kind: z30.literal("legacy-raw"),
+        reason: z30.enum(["pre-theme-v2", "manual-runtime-fields"])
+      }).strict(),
+      z30.object({
+        kind: z30.literal("advanced-detached"),
+        reason: z30.literal("detached-custom-runtime-fields")
+      }).strict()
+    ]);
+    blockRuntimeStyleAuthoritySchema = z30.object({
+      unit: z30.literal("block-runtime-fields"),
+      blockId: z30.string().min(1).transform(asDesignBlockId),
+      fields: nonEmptyRuntimeStyleFieldNamesSchema,
+      authority: styleAuthoritySchema
+    }).strict();
+    persistedPageDesignStateV1Schema = z30.object({
+      schemaVersion: z30.literal(themeV2DesignStateSchemaVersion),
+      siteStyleId: z30.string().min(1).transform(asSiteStyleId),
+      templateId: z30.string().min(1).transform(asDesignSystemTemplateId),
+      templateVersion: z30.number().int().nonnegative(),
+      resolverVersion: z30.number().int().nonnegative(),
+      rhythmPresetId: z30.string().min(1),
+      blocks: z30.array(blockDesignPlanSchema),
+      styleAuthorities: z30.array(blockRuntimeStyleAuthoritySchema)
+    }).strict();
+  }
+});
+
+// ../theme-core/src/site-styles/runtimeCompiler.ts
+function defineDesignRuntimeRules(rules) {
+  return rules;
+}
+function defineComponentRuntimeRules(rules) {
+  return rules;
+}
+function uniformSectionForeground(token) {
+  return {
+    textColor: token,
+    headingColor: token,
+    linkColor: token,
+    supportingColor: token
+  };
+}
+var defaultDesignRuntimeRules, defaultComponentRuntimeRules;
+var init_runtimeCompiler = __esm({
+  "../theme-core/src/site-styles/runtimeCompiler.ts"() {
+    "use strict";
+    init_schema2();
+    init_modern_minimal();
+    init_expandPalette();
+    init_personalities();
+    init_variants();
+    init_designState();
+    init_types6();
+    init_accessibleSurfaces();
+    defaultDesignRuntimeRules = defineDesignRuntimeRules({
+      sectionSurfaces: {
+        base: {},
+        "muted-band": {
+          background: {
+            type: "color",
+            color: "muted"
+          }
+        },
+        "accent-band": {
+          background: {
+            type: "color",
+            color: "primary"
+          }
+        },
+        "brand-depth-band": {
+          background: {
+            type: "color",
+            color: "primary-800"
+          }
+        },
+        "hero-image": {
+          background: {
+            type: "image",
+            opacity: 1,
+            position: "center center",
+            ...uniformSectionForeground("text")
+          }
+        }
+      },
+      heroLegibility: {
+        "scrim-gradient": {
+          type: "gradient",
+          gradient: "linear-gradient(180deg, rgba(255,255,255,0.38) 0%, rgba(244,241,234,0.62) 90%)",
+          opacity: 1
+        },
+        "solid-panel": {
+          type: "color",
+          color: "surface",
+          opacity: 0.88
+        }
+      },
+      transitionClassName: (transition, fromSurface, toSurface) => transition === "none" ? null : `site-style-transition-${transition}-from-${fromSurface}-to-${toSurface}`
+    });
+    defaultComponentRuntimeRules = defineComponentRuntimeRules({
+      panelFrames: {
+        inset: {
+          spacing: "comfortable",
+          rounded: "xl",
+          raised: false,
+          background: {
+            type: "color",
+            color: "surfaceAlt",
+            textColor: "text"
+          }
+        },
+        raised: {
+          spacing: "comfortable",
+          rounded: "xl",
+          raised: true,
+          background: {
+            type: "color",
+            color: "surfaceAlt",
+            textColor: "text"
+          }
+        },
+        editorial: {
+          spacing: "medium",
+          rounded: "xl",
+          raised: false,
+          background: {
+            type: "color",
+            color: "surface",
+            textColor: "text"
+          }
+        }
+      },
+      flushFrames: {
+        "media-panel": {
+          fullWidth: true,
+          spacing: "none",
+          rounded: "none",
+          raised: false
+        }
+      },
+      itemSurfaces: {
+        none: null,
+        default: {
+          spacing: "medium",
+          rounded: "lg",
+          raised: false
+        },
+        flat: {
+          spacing: "medium",
+          rounded: "lg",
+          raised: false
+        },
+        outlined: {
+          spacing: "medium",
+          rounded: "lg",
+          raised: false,
+          border: {
+            enabled: true,
+            width: "1",
+            colorToken: "border"
+          }
+        },
+        raised: {
+          spacing: "medium",
+          rounded: "xl",
+          raised: true
+        },
+        inset: {
+          treatment: "soft-panel",
+          spacing: "comfortable",
+          rounded: "xl",
+          raised: false,
+          border: {
+            enabled: false
+          },
+          background: {
+            type: "color",
+            color: "surfaceAlt",
+            textColor: "text"
+          }
+        },
+        editorial: {
+          // Boxless open column with a short rule on top; the visual treatment
+          // lives in blocks-static/card-treatments.css.
+          treatment: "editorial-rule",
+          spacing: "none",
+          rounded: "none",
+          raised: false,
+          border: {
+            enabled: false
+          }
+        },
+        "color-blocked": {
+          // Bold, flat colour-blocked cards. The per-card background colour cycle
+          // (by position) and staggered offset live in
+          // blocks-static/card-treatments.css; here we set the shared shape:
+          // generous padding, large radius, no border, flat (no shadow).
+          treatment: "color-blocked",
+          spacing: "spacious",
+          rounded: "2xl",
+          raised: false,
+          border: {
+            enabled: false
+          }
+        }
+      }
+    });
+  }
+});
+
 // ../theme-core/src/site-styles/curatedSiteStyles.ts
 function uniqueContentFrameKinds() {
   const kinds = [
@@ -16041,6 +16893,7 @@ function defineCuratedSiteStyle(input) {
     // clean/minimal styles default to none.
     headingDecoration: input.headingDecoration ?? noHeadingDecoration,
     ...input.themeOverrides ? { themeOverrides: input.themeOverrides } : {},
+    ...input.designRuntimeRules ? { designRuntimeRules: input.designRuntimeRules } : {},
     ...input.defaultBlockVariants ? { defaultBlockVariants: input.defaultBlockVariants } : {},
     recommendedAppearancePresetIds: (input.recommendedAppearancePresetIds ?? []).map(asAppearancePresetId),
     defaultHeaderSelection: input.defaultHeaderSelection ? {
@@ -16222,7 +17075,7 @@ function defaultTypographyPresetChoicesForRecipe(recipe) {
       ];
   }
 }
-var SOFT_EARTH_SITE_STYLE_ID_VALUE, SOFT_EARTH_SITE_STYLE_ID, quietBudget, balancedBudget, expressiveBudget, expressiveUnderlineInputs, generatedContentFrameKinds, curatedSiteStyles, curatedSiteStylesById;
+var SOFT_EARTH_SITE_STYLE_ID_VALUE, SOFT_EARTH_SITE_STYLE_ID, quietBudget, balancedBudget, expressiveBudget, kirtanOrnateDesignRuntimeRules, expressiveUnderlineInputs, ornateDarkInputs, generatedContentFrameKinds, curatedSiteStyles, curatedSiteStylesById;
 var init_curatedSiteStyles = __esm({
   "../theme-core/src/site-styles/curatedSiteStyles.ts"() {
     "use strict";
@@ -16237,6 +17090,7 @@ var init_curatedSiteStyles = __esm({
     init_sourceCatalogs();
     init_types6();
     init_typographyPresets();
+    init_runtimeCompiler();
     SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
     SOFT_EARTH_SITE_STYLE_ID = asSiteStyleId(SOFT_EARTH_SITE_STYLE_ID_VALUE);
     quietBudget = {
@@ -16263,6 +17117,50 @@ var init_curatedSiteStyles = __esm({
       mediaDensity: "high",
       decorativeRepetition: "medium"
     };
+    kirtanOrnateDesignRuntimeRules = defineDesignRuntimeRules({
+      ...defaultDesignRuntimeRules,
+      defaultEyebrowTreatment: "accent",
+      sectionSurfaces: {
+        ...defaultDesignRuntimeRules.sectionSurfaces,
+        "muted-band": {
+          background: {
+            type: "color",
+            color: "muted"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        },
+        "brand-depth-band": {
+          background: {
+            type: "color",
+            color: "primary-800"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        },
+        "hero-image": {
+          background: {
+            type: "image",
+            opacity: 1,
+            position: "center center"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        }
+      }
+    });
     expressiveUnderlineInputs = {
       base: {
         background: { type: "transparent" },
@@ -16300,6 +17198,43 @@ var init_curatedSiteStyles = __esm({
         opacity: 0.6
       }
     };
+    ornateDarkInputs = {
+      base: {
+        background: { type: "solid", colorToken: "surfaceAlt" },
+        textColorToken: "text",
+        border: {
+          widthClass: "border",
+          colorToken: "primary/45",
+          style: "all"
+        },
+        corners: "square",
+        shadow: null,
+        spacing: "medium",
+        fontSize: "base"
+      },
+      label: {
+        textColorToken: "primary",
+        fontWeight: "semibold",
+        fontSize: "xs",
+        textTransform: "uppercase",
+        letterSpacing: "wider",
+        opacity: 1
+      },
+      focus: {
+        ringColorToken: "primary/18",
+        ringWidth: "2",
+        borderColorToken: "primary/70"
+      },
+      error: {
+        borderColorToken: "destructive",
+        textColorToken: "destructive"
+      },
+      disabled: {
+        backgroundColorToken: "muted",
+        textColorToken: "mutedText",
+        opacity: 0.6
+      }
+    };
     generatedContentFrameKinds = uniqueContentFrameKinds();
     curatedSiteStyles = [
       defineCuratedSiteStyle({
@@ -17070,6 +18005,80 @@ var init_curatedSiteStyles = __esm({
           paletteChoice("high-contrast-ink")
         ]
       }),
+      defineCuratedSiteStyle({
+        id: "site-style:kirtan-ornate",
+        name: "Kirtan Ornate",
+        headingDecoration: { family: "short-center-rule", colorToken: "accent" },
+        description: "Ceremonial, jewel-toned, and devotional: ornate frames, warm contrast, and composed rhythm for intimate music gatherings.",
+        generationBrief: "Use a deep plum ground with pale gold as the main brand color, rose accent details, cream text, spacious split hero sections, devotional editorial headings, compact event lists, and framed conversion sections. The mood should feel soulful and ceremonial, not gothic or theatrical.",
+        selectionKeywordRules: [
+          { kind: "word", value: "kirtan" },
+          { kind: "word", value: "chanting" },
+          { kind: "word", value: "ceremony" },
+          { kind: "word", value: "devotional" }
+        ],
+        tokenRecipes: {
+          palette: "brand-led",
+          contrast: "strong",
+          radius: "soft",
+          shadow: "subtle",
+          typography: "serif-editorial",
+          spacing: "airy",
+          motion: "subtle"
+        },
+        compositionBudget: expressiveBudget,
+        typographyPresetChoices: [
+          typographyChoice("typography-preset:kirtan-ornate"),
+          typographyChoice("typography-preset:luxe-contrast"),
+          typographyChoice("typography-preset:editorial-serif")
+        ],
+        defaultTypographyPresetId: "typography-preset:kirtan-ornate",
+        themeOverrides: {
+          accordions: warmInsetAccordionSystem,
+          cards: originalJoyCardSystem,
+          testimonialQuote: serifDisplayQuote,
+          bodyText: {
+            intro: {
+              paragraphSize: "editorial",
+              headingSize: "editorial"
+            }
+          },
+          inputs: ornateDarkInputs
+        },
+        designRuntimeRules: kirtanOrnateDesignRuntimeRules,
+        recommendedAppearancePresetIds: [
+          "hero-brand-scrim-fixed-frame",
+          "media-text-quiet-story",
+          "events-lined-panel",
+          "schedule-details-brand-depth",
+          "testimonials-statement-cards",
+          "contact-form-panel"
+        ],
+        defaultHeaderSelection: { layoutId: "floating", styleId: "minimal-surface" },
+        recommendedHeaderLayoutChoices: [headerLayoutChoice("floating")],
+        recommendedHeaderStyleChoicesByLayout: {
+          floating: [
+            headerStyleChoice("minimal-surface"),
+            headerStyleChoice("split-glass"),
+            headerStyleChoice("glass")
+          ]
+        },
+        recommendedHeaderLookIds: ["minimal-transparent"],
+        recommendedFooterLookIds: [
+          "site-footer-brand-two-band",
+          "footer-muted-grounding"
+        ],
+        buttonPersonalityChoices: [
+          buttonChoice("ornate-ritual"),
+          buttonChoice("joy-stamp"),
+          buttonChoice("ink-stamp")
+        ],
+        paletteVariantChoices: [
+          paletteChoice("warm-dark-kirtan-gold"),
+          paletteChoice("warm-dark-ember"),
+          paletteChoice("brand-led-burgundy-gold")
+        ]
+      }),
       defineCuratedSiteStyle({
         id: "site-style:original-joy",
         name: "Original Joy",
@@ -18084,7 +19093,7 @@ var init_repeaterGrid = __esm({
 });
 
 // ../blocks/src/system/manifest/schema.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function isDisplayMediaKind(kind) {
   return DISPLAY_MEDIA_KINDS.includes(kind);
 }
@@ -18095,7 +19104,7 @@ function getFieldSchemaInternal() {
   if (_fieldSchemaInternal) {
     return _fieldSchemaInternal;
   }
-  _fieldSchemaInternal = z30.discriminatedUnion("type", [
+  _fieldSchemaInternal = z31.discriminatedUnion("type", [
     textFieldSchema,
     richTextFieldSchema,
     mediaFieldSchema,
@@ -18148,7 +19157,7 @@ function createSiteOptionSelectField(input) {
     })
   );
 }
-var visibilityLevels, MEDIA_KINDS, DISPLAY_MEDIA_KINDS, PUBLIC_FILE_FIELD_KINDS, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, fileFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, quickFieldPrioritySchema, previewCustomizeManifestCurationSchema, blockCategoryEnum, manifestSchema;
+var visibilityLevels, MEDIA_KINDS, DISPLAY_MEDIA_KINDS, PUBLIC_FILE_FIELD_KINDS, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, visibleWhenPredicateSchema, visibleWhenSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, fileFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, quickFieldPrioritySchema, previewCustomizeManifestCurationSchema, blockCategoryEnum, manifestSchema;
 var init_schema3 = __esm({
   "../blocks/src/system/manifest/schema.ts"() {
     "use strict";
@@ -18181,92 +19190,101 @@ var init_schema3 = __esm({
       "venues",
       "staffMembers"
     ];
-    mediaDeliverySchema = z30.object({
-      sizes: z30.string().optional(),
-      widthCandidates: z30.array(z30.number().int().positive()).optional(),
-      maxCssWidth: z30.number().positive().optional(),
-      maxCssHeight: z30.number().positive().optional(),
-      strategy: z30.enum(["default", "columnsAuto", "imageGalleryVariant"]).optional(),
-      strategyOptions: z30.record(z30.string(), z30.unknown()).optional()
-    });
-    selectOptionSchema = z30.object({
-      value: z30.string(),
-      label: z30.string(),
-      description: z30.string().optional(),
-      icon: z30.string().optional()
-    });
-    selectSourceSchema = z30.discriminatedUnion("kind", [
-      z30.object({
-        kind: z30.literal("static")
+    mediaDeliverySchema = z31.object({
+      sizes: z31.string().optional(),
+      widthCandidates: z31.array(z31.number().int().positive()).optional(),
+      maxCssWidth: z31.number().positive().optional(),
+      maxCssHeight: z31.number().positive().optional(),
+      strategy: z31.enum(["default", "columnsAuto", "imageGalleryVariant"]).optional(),
+      strategyOptions: z31.record(z31.string(), z31.unknown()).optional()
+    });
+    selectOptionSchema = z31.object({
+      value: z31.string(),
+      label: z31.string(),
+      description: z31.string().optional(),
+      icon: z31.string().optional()
+    });
+    selectSourceSchema = z31.discriminatedUnion("kind", [
+      z31.object({
+        kind: z31.literal("static")
       }),
-      z30.object({
-        kind: z30.literal("site"),
-        optionSource: z30.enum(siteOptionSources)
+      z31.object({
+        kind: z31.literal("site"),
+        optionSource: z31.enum(siteOptionSources)
       }),
-      z30.object({
-        kind: z30.literal("sdk")
+      z31.object({
+        kind: z31.literal("sdk")
+      })
+    ]);
+    visibleWhenPredicateSchema = z31.object({
+      field: z31.string().min(1),
+      equals: z31.any().optional(),
+      notEquals: z31.any().optional(),
+      oneOf: z31.array(z31.any()).optional(),
+      notIn: z31.array(z31.any()).optional(),
+      minItems: z31.number().int().nonnegative().optional(),
+      maxItems: z31.number().int().nonnegative().optional()
+    });
+    visibleWhenSchema = z31.union([
+      visibleWhenPredicateSchema,
+      z31.object({
+        allOf: z31.array(visibleWhenPredicateSchema).min(1)
       })
     ]);
-    uiSchema = z30.object({
-      widget: z30.string().optional(),
+    uiSchema = z31.object({
+      widget: z31.string().optional(),
       // Container/widget presets (used by Group/Repeater widgets themselves, not for widget selection)
-      preset: z30.enum(["disclosure"]).optional(),
-      flattenInRepeater: z30.boolean().optional(),
-      hidden: z30.boolean().optional(),
-      hideLabel: z30.boolean().optional(),
-      hideDescription: z30.boolean().optional(),
-      showCharCount: z30.union([
-        z30.number().int().positive(),
-        z30.object({ max: z30.number().int().positive() })
+      preset: z31.enum(["disclosure"]).optional(),
+      flattenInRepeater: z31.boolean().optional(),
+      hidden: z31.boolean().optional(),
+      hideLabel: z31.boolean().optional(),
+      hideDescription: z31.boolean().optional(),
+      showCharCount: z31.union([
+        z31.number().int().positive(),
+        z31.object({ max: z31.number().int().positive() })
       ]).optional(),
-      showSlugPreview: z30.boolean().optional(),
-      variant: z30.enum(["full", "inline", "limited", "media", "notes"]).optional(),
-      richTextVariant: z30.enum(["full", "inline", "limited", "media", "notes"]).optional(),
-      cropEditorMode: z30.enum(["dialog", "inline"]).optional(),
-      cropEditorAutoOpen: z30.boolean().optional(),
-      mediaPickerAutoOpen: z30.boolean().optional(),
-      showMediaPreview: z30.boolean().optional(),
-      showMediaOverlayActions: z30.boolean().optional(),
-      mediaPreviewMaxWidth: z30.enum(["xs", "sm", "md", "none"]).optional(),
-      preventMediaPreviewUpscale: z30.boolean().optional(),
+      showSlugPreview: z31.boolean().optional(),
+      variant: z31.enum(["full", "inline", "limited", "media", "notes"]).optional(),
+      richTextVariant: z31.enum(["full", "inline", "limited", "media", "notes"]).optional(),
+      cropEditorMode: z31.enum(["dialog", "inline"]).optional(),
+      cropEditorAutoOpen: z31.boolean().optional(),
+      mediaPickerAutoOpen: z31.boolean().optional(),
+      showMediaPreview: z31.boolean().optional(),
+      showMediaOverlayActions: z31.boolean().optional(),
+      mediaPreviewMaxWidth: z31.enum(["xs", "sm", "md", "none"]).optional(),
+      preventMediaPreviewUpscale: z31.boolean().optional(),
       mediaDelivery: mediaDeliverySchema.optional(),
-      mediaDeliveryByVariant: z30.record(z30.string(), mediaDeliverySchema).optional(),
+      mediaDeliveryByVariant: z31.record(z31.string(), mediaDeliverySchema).optional(),
       // Optional input hints for validators/widgets
-      inputType: z30.enum(["text", "email", "tel", "number"]).optional(),
-      min: z30.number().optional(),
-      max: z30.number().optional(),
-      step: z30.number().optional(),
-      showValue: z30.boolean().optional(),
-      pattern: z30.string().optional(),
-      placeholder: z30.string().optional(),
-      visibleWhen: z30.object({
-        field: z30.string().min(1),
-        equals: z30.any().optional(),
-        notEquals: z30.any().optional(),
-        oneOf: z30.array(z30.any()).optional(),
-        notIn: z30.array(z30.any()).optional()
-      }).optional(),
+      inputType: z31.enum(["text", "email", "tel", "number"]).optional(),
+      min: z31.number().optional(),
+      max: z31.number().optional(),
+      step: z31.number().optional(),
+      showValue: z31.boolean().optional(),
+      pattern: z31.string().optional(),
+      placeholder: z31.string().optional(),
+      visibleWhen: visibleWhenSchema.optional(),
       // Modal configuration for modal and group fields
-      modalConfig: z30.object({
-        buttonLabel: z30.string().optional(),
-        description: z30.string().optional(),
-        buttonVariant: z30.enum(["default", "outline"]).optional(),
-        showCustomizedIndicator: z30.boolean().optional(),
-        maxWidth: z30.string().optional()
+      modalConfig: z31.object({
+        buttonLabel: z31.string().optional(),
+        description: z31.string().optional(),
+        buttonVariant: z31.enum(["default", "outline"]).optional(),
+        showCustomizedIndicator: z31.boolean().optional(),
+        maxWidth: z31.string().optional()
       }).optional(),
       // Background field configuration
-      allowedTypes: z30.array(z30.enum(["color", "gradient", "image"])).optional(),
+      allowedTypes: z31.array(z31.enum(["color", "gradient", "image"])).optional(),
       // Tab group configuration
-      fullWidth: z30.boolean().optional(),
+      fullWidth: z31.boolean().optional(),
       // Field layout configuration
-      row: z30.string().optional(),
-      colSpan: z30.number().int().min(1).max(4).optional(),
+      row: z31.string().optional(),
+      colSpan: z31.number().int().min(1).max(4).optional(),
       // Group layout configuration
-      layout: z30.enum(["stack", "grid"]).optional(),
-      columns: z30.number().int().min(2).max(4).optional(),
+      layout: z31.enum(["stack", "grid"]).optional(),
+      columns: z31.number().int().min(2).max(4).optional(),
       // Named grid presets for GroupField grid layout.
       // Use these for common responsive patterns to avoid embedding Tailwind strings in manifests.
-      gridColsPreset: z30.enum([
+      gridColsPreset: z31.enum([
         "simple2",
         // base 1 col -> sm 2 cols
         "simple3",
@@ -18279,107 +19297,107 @@ var init_schema3 = __esm({
       // Responsive grid columns for GroupField grid layout (mobile-first).
       // Uses Tailwind breakpoints; when provided, GroupField will build the appropriate
       // `grid-cols-*` classes from this config.
-      gridColumns: z30.object({
-        base: z30.number().int().min(1).max(4).optional(),
-        sm: z30.number().int().min(1).max(4).optional(),
-        md: z30.number().int().min(1).max(4).optional(),
-        lg: z30.number().int().min(1).max(4).optional(),
-        xl: z30.number().int().min(1).max(4).optional()
+      gridColumns: z31.object({
+        base: z31.number().int().min(1).max(4).optional(),
+        sm: z31.number().int().min(1).max(4).optional(),
+        md: z31.number().int().min(1).max(4).optional(),
+        lg: z31.number().int().min(1).max(4).optional(),
+        xl: z31.number().int().min(1).max(4).optional()
       }).optional(),
       // Group grid override: allows custom responsive grid column classes (e.g. unequal column widths)
-      gridColsClassName: z30.string().optional(),
+      gridColsClassName: z31.string().optional(),
       // Repeater presentation presets
-      repeaterPreset: z30.enum(["thumbnailGrid", "layoutGrid"]).optional(),
-      thumbnailField: z30.string().optional(),
-      thumbnailAltField: z30.string().optional(),
-      thumbnailLabelField: z30.string().optional(),
-      thumbnailAspectRatio: z30.string().optional(),
-      thumbnailCardDensity: z30.enum(["compact", "comfortable"]).optional(),
-      layoutGridColumnsFields: z30.object({
-        base: z30.string().optional(),
-        sm: z30.string().optional(),
-        md: z30.string().optional(),
-        lg: z30.string().min(1),
-        xl: z30.string().optional()
+      repeaterPreset: z31.enum(["thumbnailGrid", "layoutGrid"]).optional(),
+      thumbnailField: z31.string().optional(),
+      thumbnailAltField: z31.string().optional(),
+      thumbnailLabelField: z31.string().optional(),
+      thumbnailAspectRatio: z31.string().optional(),
+      thumbnailCardDensity: z31.enum(["compact", "comfortable"]).optional(),
+      layoutGridColumnsFields: z31.object({
+        base: z31.string().optional(),
+        sm: z31.string().optional(),
+        md: z31.string().optional(),
+        lg: z31.string().min(1),
+        xl: z31.string().optional()
       }).optional(),
-      layoutGridSpanField: z30.string().optional(),
-      layoutGridRowField: z30.string().optional(),
-      layoutGridColumnField: z30.string().optional(),
-      layoutGridMaxRows: z30.number().int().positive().optional(),
+      layoutGridSpanField: z31.string().optional(),
+      layoutGridRowField: z31.string().optional(),
+      layoutGridColumnField: z31.string().optional(),
+      layoutGridMaxRows: z31.number().int().positive().optional(),
       // Icon picker configuration (used when ui.widget === 'iconPicker')
-      iconPickerPreset: z30.enum(ICON_PICKER_PRESETS).optional(),
+      iconPickerPreset: z31.enum(ICON_PICKER_PRESETS).optional(),
       // Entry picker configuration
-      contentTypeField: z30.string().optional(),
-      fixedContentType: z30.string().optional(),
-      valueFrom: z30.enum(["id", "identifier", "slug"]).optional(),
-      siteOptionSource: z30.enum(siteOptionSources).optional(),
-      searchThreshold: z30.number().int().positive().optional(),
+      contentTypeField: z31.string().optional(),
+      fixedContentType: z31.string().optional(),
+      valueFrom: z31.enum(["id", "identifier", "slug"]).optional(),
+      siteOptionSource: z31.enum(siteOptionSources).optional(),
+      searchThreshold: z31.number().int().positive().optional(),
       // Render in block header instead of form body (used for section styles)
-      renderInHeader: z30.boolean().optional(),
+      renderInHeader: z31.boolean().optional(),
       // Semantic field intent for content-first form routing and settings tab grouping
-      intent: z30.enum(["content", "display", "behavior", "style"]).optional()
+      intent: z31.enum(["content", "display", "behavior", "style"]).optional()
     }).partial();
-    baseFieldSchema = z30.object({
-      id: z30.string().min(1, "Field id is required"),
-      label: z30.string().min(1, "Field label is required"),
-      description: z30.string().optional(),
-      visibleRoles: z30.array(z30.enum(visibilityLevels)).optional(),
-      defaultValue: z30.any().optional(),
-      required: z30.boolean().default(false),
+    baseFieldSchema = z31.object({
+      id: z31.string().min(1, "Field id is required"),
+      label: z31.string().min(1, "Field label is required"),
+      description: z31.string().optional(),
+      visibleRoles: z31.array(z31.enum(visibilityLevels)).optional(),
+      defaultValue: z31.any().optional(),
+      required: z31.boolean().default(false),
       ui: uiSchema.optional()
     });
     textFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("text"),
-      multiline: z30.boolean().default(false),
-      maxLength: z30.number().int().positive().optional()
+      type: z31.literal("text"),
+      multiline: z31.boolean().default(false),
+      maxLength: z31.number().int().positive().optional()
     });
     richTextFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("richText")
+      type: z31.literal("richText")
     });
     mediaFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("media"),
+      type: z31.literal("media"),
       // Keep full MEDIA_KINDS parse compatibility for pre-file-field manifests.
       // New authoring surfaces should use `file.fileKinds` for document/archive
       // style assets, but old saved schemas must not fail to open.
-      mediaKinds: z30.array(z30.enum(MEDIA_KINDS)).default(["image"]).transform((kinds) => {
+      mediaKinds: z31.array(z31.enum(MEDIA_KINDS)).default(["image"]).transform((kinds) => {
         const displayKinds = kinds.filter(isDisplayMediaKind);
         return displayKinds.length > 0 ? displayKinds : ["image"];
       }),
-      aspectRatio: z30.string().optional()
+      aspectRatio: z31.string().optional()
     });
     fileFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("file"),
-      fileKinds: z30.array(z30.enum(PUBLIC_FILE_FIELD_KINDS)).default([...PUBLIC_FILE_FIELD_KINDS])
+      type: z31.literal("file"),
+      fileKinds: z31.array(z31.enum(PUBLIC_FILE_FIELD_KINDS)).default([...PUBLIC_FILE_FIELD_KINDS])
     });
     booleanFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("boolean")
+      type: z31.literal("boolean")
     });
     dateFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("date")
+      type: z31.literal("date")
     });
     timeFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("time")
+      type: z31.literal("time")
     });
     dateTimeFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("datetime")
+      type: z31.literal("datetime")
     });
     slugFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("slug"),
-      sourceFieldId: z30.string().min(1).optional(),
-      statusFieldId: z30.string().min(1).optional(),
-      maxLength: z30.number().int().positive().optional()
+      type: z31.literal("slug"),
+      sourceFieldId: z31.string().min(1).optional(),
+      statusFieldId: z31.string().min(1).optional(),
+      maxLength: z31.number().int().positive().optional()
     });
     urlFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("url"),
-      allowRelative: z30.boolean().default(false)
+      type: z31.literal("url"),
+      allowRelative: z31.boolean().default(false)
     });
     linkFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("link")
+      type: z31.literal("link")
     });
     selectFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("select"),
-      options: z30.array(selectOptionSchema),
-      multiple: z30.boolean().default(false),
+      type: z31.literal("select"),
+      options: z31.array(selectOptionSchema),
+      multiple: z31.boolean().default(false),
       source: selectSourceSchema.optional()
     }).superRefine((field, ctx) => {
       const widget = field.ui?.widget;
@@ -18387,7 +19405,7 @@ var init_schema3 = __esm({
       if (!field.source) {
         if (siteOptionSource || widget === "sdkSelect") {
           ctx.addIssue({
-            code: z30.ZodIssueCode.custom,
+            code: z31.ZodIssueCode.custom,
             message: "Runtime-backed select fields must declare source.kind explicitly",
             path: ["source"]
           });
@@ -18395,7 +19413,7 @@ var init_schema3 = __esm({
         }
         if (field.options.length === 0) {
           ctx.addIssue({
-            code: z30.ZodIssueCode.custom,
+            code: z31.ZodIssueCode.custom,
             message: "Select fields require at least one option unless a runtime source is configured",
             path: ["options"]
           });
@@ -18406,14 +19424,14 @@ var init_schema3 = __esm({
         case "static":
           if (siteOptionSource || widget === "sdkSelect") {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "Static select fields cannot declare runtime-backed UI metadata",
               path: ["ui"]
             });
           }
           if (field.options.length === 0) {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "Static select fields require at least one option",
               path: ["options"]
             });
@@ -18422,21 +19440,21 @@ var init_schema3 = __esm({
         case "site":
           if (field.options.length > 0) {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "Site-backed select fields must not define static options",
               path: ["options"]
             });
           }
           if (widget !== "siteOptionPicker") {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "Site-backed select fields must use the siteOptionPicker widget",
               path: ["ui", "widget"]
             });
           }
           if (siteOptionSource !== field.source.optionSource) {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "Site-backed select fields must keep ui.siteOptionSource in sync with source.optionSource",
               path: ["ui", "siteOptionSource"]
             });
@@ -18445,14 +19463,14 @@ var init_schema3 = __esm({
         case "sdk":
           if (widget !== "sdkSelect") {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "SDK-backed select fields must use the sdkSelect widget",
               path: ["ui", "widget"]
             });
           }
           if (siteOptionSource) {
             ctx.addIssue({
-              code: z30.ZodIssueCode.custom,
+              code: z31.ZodIssueCode.custom,
               message: "SDK-backed select fields cannot declare ui.siteOptionSource",
               path: ["ui", "siteOptionSource"]
             });
@@ -18463,36 +19481,36 @@ var init_schema3 = __esm({
       }
     });
     referenceFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("reference"),
-      referenceKind: z30.string().min(1),
-      allowManualEntry: z30.boolean().default(false)
-    });
-    itemTypeSchema = z30.object({
-      label: z30.string().min(1),
-      icon: z30.string().optional(),
-      fields: z30.lazy(
+      type: z31.literal("reference"),
+      referenceKind: z31.string().min(1),
+      allowManualEntry: z31.boolean().default(false)
+    });
+    itemTypeSchema = z31.object({
+      label: z31.string().min(1),
+      icon: z31.string().optional(),
+      fields: z31.lazy(
         () => getFieldSchemaInternal().array().min(1, "Item type requires at least one field")
       )
     });
     repeaterFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("repeater"),
-      itemLabel: z30.string().default("Item"),
-      itemLabelSource: z30.string().optional(),
-      showSummary: z30.boolean().optional(),
-      summaryFields: z30.string().array().optional(),
-      summaryMaxChars: z30.number().int().positive().optional(),
-      minItems: z30.number().int().min(0).default(0),
-      maxItems: z30.number().int().positive().optional(),
+      type: z31.literal("repeater"),
+      itemLabel: z31.string().default("Item"),
+      itemLabelSource: z31.string().optional(),
+      showSummary: z31.boolean().optional(),
+      summaryFields: z31.string().array().optional(),
+      summaryMaxChars: z31.number().int().positive().optional(),
+      minItems: z31.number().int().min(0).default(0),
+      maxItems: z31.number().int().positive().optional(),
       // Monomorphic mode
-      schema: z30.object({
-        fields: z30.lazy(
+      schema: z31.object({
+        fields: z31.lazy(
           () => getFieldSchemaInternal().array().min(1, "Repeater requires at least one field")
         )
       }).optional(),
       // Polymorphic mode
-      polymorphic: z30.boolean().optional(),
-      itemTypes: z30.record(z30.string(), itemTypeSchema).optional(),
-      allowConversion: z30.boolean().default(true)
+      polymorphic: z31.boolean().optional(),
+      itemTypes: z31.record(z31.string(), itemTypeSchema).optional(),
+      allowConversion: z31.boolean().default(true)
     }).refine(
       (data) => {
         const hasSchema = data.schema !== void 0;
@@ -18584,71 +19602,71 @@ var init_schema3 = __esm({
       }
     );
     groupFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("group"),
-      schema: z30.object({
-        fields: z30.lazy(
+      type: z31.literal("group"),
+      schema: z31.object({
+        fields: z31.lazy(
           () => getFieldSchemaInternal().array().min(1, "Group requires at least one field")
         )
       })
     });
     modalFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("modal"),
-      schema: z30.object({
-        fields: z30.lazy(
+      type: z31.literal("modal"),
+      schema: z31.object({
+        fields: z31.lazy(
           () => getFieldSchemaInternal().array().min(1, "Modal requires at least one field")
         )
       })
     });
     numberFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("number"),
-      min: z30.number().optional(),
-      max: z30.number().optional(),
-      step: z30.number().optional()
-    });
-    tabDefinitionSchema = z30.object({
-      id: z30.string().min(1),
-      label: z30.string().min(1),
-      icon: z30.string().optional(),
-      description: z30.string().optional(),
-      fields: z30.lazy(() => getFieldSchemaInternal().array()),
+      type: z31.literal("number"),
+      min: z31.number().optional(),
+      max: z31.number().optional(),
+      step: z31.number().optional()
+    });
+    tabDefinitionSchema = z31.object({
+      id: z31.string().min(1),
+      label: z31.string().min(1),
+      icon: z31.string().optional(),
+      description: z31.string().optional(),
+      fields: z31.lazy(() => getFieldSchemaInternal().array()),
       /** SDK section option that controls tab visibility based on site config */
-      sdkSectionOption: z30.enum(["backgroundColor", "backgroundGradient", "backgroundImage"]).optional()
+      sdkSectionOption: z31.enum(["backgroundColor", "backgroundGradient", "backgroundImage"]).optional()
     });
     tabGroupFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("tabGroup"),
-      tabs: z30.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
-      activeTabField: z30.string().optional()
+      type: z31.literal("tabGroup"),
+      tabs: z31.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
+      activeTabField: z31.string().optional()
     });
-    presetOptionSchema = z30.object({
-      value: z30.string(),
-      label: z30.string()
+    presetOptionSchema = z31.object({
+      value: z31.string(),
+      label: z31.string()
     });
     presetOrCustomFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("presetOrCustom"),
-      presets: z30.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
-      customInput: z30.object({
-        placeholder: z30.string().optional(),
-        pattern: z30.string().optional(),
-        helpText: z30.string().optional()
+      type: z31.literal("presetOrCustom"),
+      presets: z31.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
+      customInput: z31.object({
+        placeholder: z31.string().optional(),
+        pattern: z31.string().optional(),
+        helpText: z31.string().optional()
       }).optional()
     });
     contentTypeSelectFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("contentTypeSelect"),
+      type: z31.literal("contentTypeSelect"),
       /** Filter: all, routable (hasPages=true), nonRoutable (hasPages=false) */
-      filter: z30.enum(["all", "routable", "nonRoutable"]).default("all")
+      filter: z31.enum(["all", "routable", "nonRoutable"]).default("all")
     });
     entryPickerFieldSchema = baseFieldSchema.extend({
-      type: z30.literal("entryPicker"),
+      type: z31.literal("entryPicker"),
       // Note: these options also exist under `ui.*` (see uiSchema) because older manifests
       // and some authoring surfaces store widget-specific configuration there. We support
       // both locations so SDK/custom manifests can use the more ergonomic top-level fields
       // without breaking existing `ui.*` configs.
       /** Fixed content type to filter entries by (no sibling contentType field required) */
-      fixedContentType: z30.string().optional(),
+      fixedContentType: z31.string().optional(),
       /** Field ID that contains the content type to filter entries by */
-      contentTypeField: z30.string().optional(),
+      contentTypeField: z31.string().optional(),
       /** What value should be stored when an entry is selected */
-      valueFrom: z30.enum(["id", "identifier", "slug"]).optional()
+      valueFrom: z31.enum(["id", "identifier", "slug"]).optional()
     });
     _fieldSchemaInternal = null;
     fieldSchema = new Proxy({}, {
@@ -18662,14 +19680,14 @@ var init_schema3 = __esm({
         return prop in getFieldSchemaInternal();
       }
     });
-    slotSchema = z30.object({
-      id: z30.string().min(1),
-      label: z30.string().min(1),
-      allowedKinds: z30.array(z30.string()).default([]),
-      min: z30.number().int().min(0).default(0),
-      max: z30.number().int().positive().optional(),
-      help: z30.string().optional(),
-      visibleRoles: z30.array(z30.enum(visibilityLevels)).optional()
+    slotSchema = z31.object({
+      id: z31.string().min(1),
+      label: z31.string().min(1),
+      allowedKinds: z31.array(z31.string()).default([]),
+      min: z31.number().int().min(0).default(0),
+      max: z31.number().int().positive().optional(),
+      help: z31.string().optional(),
+      visibleRoles: z31.array(z31.enum(visibilityLevels)).optional()
     });
     typographyTokens = [
       "display",
@@ -18687,29 +19705,29 @@ var init_schema3 = __esm({
     ];
     spacingTokens = ["none", "xs", "sm", "md", "lg", "xl"];
     radiusTokens = ["none", "sm", "md", "lg", "full"];
-    styleTokenSchema = z30.object({
-      background: z30.enum(colorTokens).optional(),
-      foreground: z30.enum(colorTokens).optional(),
-      border: z30.enum(colorTokens).optional(),
-      typography: z30.enum(typographyTokens).optional(),
-      spacing: z30.enum(spacingTokens).optional(),
-      radius: z30.enum(radiusTokens).optional()
-    });
-    behaviourSchema = z30.object({
-      supportsThemeSwitching: z30.boolean().default(true),
-      inlineEditing: z30.boolean().default(false),
-      animation: z30.boolean().default(false),
+    styleTokenSchema = z31.object({
+      background: z31.enum(colorTokens).optional(),
+      foreground: z31.enum(colorTokens).optional(),
+      border: z31.enum(colorTokens).optional(),
+      typography: z31.enum(typographyTokens).optional(),
+      spacing: z31.enum(spacingTokens).optional(),
+      radius: z31.enum(radiusTokens).optional()
+    });
+    behaviourSchema = z31.object({
+      supportsThemeSwitching: z31.boolean().default(true),
+      inlineEditing: z31.boolean().default(false),
+      animation: z31.boolean().default(false),
       // Hide from block picker palettes (e.g., header/footer system blocks)
-      paletteHidden: z30.boolean().default(false),
+      paletteHidden: z31.boolean().default(false),
       // Block manages its own wrapper (for sticky/fixed positioning)
-      managesOwnWrapper: z30.boolean().optional()
+      managesOwnWrapper: z31.boolean().optional()
     });
-    quickFieldPrioritySchema = z30.array(z30.string().min(1)).min(1).superRefine((fieldIds, ctx) => {
+    quickFieldPrioritySchema = z31.array(z31.string().min(1)).min(1).superRefine((fieldIds, ctx) => {
       const seenFieldIds = /* @__PURE__ */ new Set();
       for (const [index, fieldId] of fieldIds.entries()) {
         if (seenFieldIds.has(fieldId)) {
           ctx.addIssue({
-            code: z30.ZodIssueCode.custom,
+            code: z31.ZodIssueCode.custom,
             path: [index],
             message: `Duplicate quick-field priority "${fieldId}"`
           });
@@ -18717,10 +19735,10 @@ var init_schema3 = __esm({
         seenFieldIds.add(fieldId);
       }
     });
-    previewCustomizeManifestCurationSchema = z30.object({
+    previewCustomizeManifestCurationSchema = z31.object({
       quickFieldPriority: quickFieldPrioritySchema
     });
-    blockCategoryEnum = z30.enum([
+    blockCategoryEnum = z31.enum([
       "marketing",
       "content",
       "blog",
@@ -18728,13 +19746,13 @@ var init_schema3 = __esm({
       "layout",
       "interactive"
     ]);
-    manifestSchema = z30.object({
-      name: z30.string().min(1),
-      version: z30.string().min(1),
-      title: z30.string().min(1),
-      titleSource: z30.union([z30.string().min(1), z30.array(z30.string().min(1)).min(1)]).optional(),
-      description: z30.string().optional(),
-      component: z30.string().min(1),
+    manifestSchema = z31.object({
+      name: z31.string().min(1),
+      version: z31.string().min(1),
+      title: z31.string().min(1),
+      titleSource: z31.union([z31.string().min(1), z31.array(z31.string().min(1)).min(1)]).optional(),
+      description: z31.string().optional(),
+      component: z31.string().min(1),
       fields: fieldSchema.array().default([]),
       slots: slotSchema.array().default([]),
       styleTokens: styleTokenSchema.optional(),
@@ -18748,29 +19766,29 @@ var init_schema3 = __esm({
        *
        * The original fields remain available in settings for power users.
        */
-      promotedFields: z30.array(z30.string().min(1)).optional(),
+      promotedFields: z31.array(z31.string().min(1)).optional(),
       // Block variants system
-      variants: z30.record(z30.string(), NodeTreeSchema).optional(),
-      defaultVariant: z30.string().optional(),
-      variantOptions: z30.record(
-        z30.string(),
-        z30.object({
-          label: z30.string().optional(),
-          description: z30.string().optional(),
-          icon: z30.string().optional()
+      variants: z31.record(z31.string(), NodeTreeSchema).optional(),
+      defaultVariant: z31.string().optional(),
+      variantOptions: z31.record(
+        z31.string(),
+        z31.object({
+          label: z31.string().optional(),
+          description: z31.string().optional(),
+          icon: z31.string().optional()
         }).optional()
       ).optional(),
       // Discovery metadata
       category: blockCategoryEnum.optional(),
-      contentTypes: z30.array(z30.string()).optional(),
-      tags: z30.array(z30.string()).optional(),
-      icon: z30.string().optional()
+      contentTypes: z31.array(z31.string()).optional(),
+      tags: z31.array(z31.string()).optional(),
+      icon: z31.string().optional()
     });
   }
 });
 
 // ../blocks/src/system/fragments/types.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function defineFragment(config) {
   const parsed = fragmentConfigSchema.parse(config);
   const fields = parseFieldDefinitions(parsed.fields);
@@ -18992,26 +20010,26 @@ var init_types15 = __esm({
     init_node();
     FRAGMENT_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
     FIELD_ID_PATTERN = /^[a-z][a-zA-Z0-9_-]*$/;
-    dataLoaderSchema = z31.object({
-      endpoint: z31.string().min(1, "Fragment data loader requires an endpoint"),
-      params: z31.record(z31.string(), z31.unknown()).default({}),
-      mode: z31.enum(["server", "client"]).default("server")
+    dataLoaderSchema = z32.object({
+      endpoint: z32.string().min(1, "Fragment data loader requires an endpoint"),
+      params: z32.record(z32.string(), z32.unknown()).default({}),
+      mode: z32.enum(["server", "client"]).default("server")
     });
-    fragmentDataSchema = z31.object({
-      key: z31.string().min(1, "Fragment data key is required"),
+    fragmentDataSchema = z32.object({
+      key: z32.string().min(1, "Fragment data key is required"),
       loader: dataLoaderSchema.optional()
     });
-    fragmentConfigSchema = z31.object({
-      id: z31.string().min(1, "Fragment id is required").regex(
+    fragmentConfigSchema = z32.object({
+      id: z32.string().min(1, "Fragment id is required").regex(
         FRAGMENT_ID_PATTERN,
         "Fragment id must be alphanumeric with optional . _ - separators"
       ),
-      title: z31.string().optional(),
-      description: z31.string().optional(),
-      category: z31.enum(["content", "media", "interactive", "layout"]).optional(),
-      icon: z31.string().optional(),
+      title: z32.string().optional(),
+      description: z32.string().optional(),
+      category: z32.enum(["content", "media", "interactive", "layout"]).optional(),
+      icon: z32.string().optional(),
       fields: fieldSchema.array().default([]),
-      layout: z31.union([NodeSchema, NodeSchema.array()]).transform(
+      layout: z32.union([NodeSchema, NodeSchema.array()]).transform(
         (value) => Array.isArray(value) ? value : [value]
       ),
       data: fragmentDataSchema.optional()
@@ -20517,8 +21535,23 @@ var init_heroLayoutControls = __esm({
     heroLayoutControlsFragment = defineFragment({
       id: "heroLayoutControls",
       title: "Hero Layout",
-      description: "Alignment and content width controls for hero layouts.",
+      description: "Title scale, alignment, and content width controls for hero layouts.",
       fields: [
+        {
+          id: "titleSize",
+          type: "select",
+          label: "Title size",
+          description: "Adjust the visual scale of the hero title.",
+          required: false,
+          ui: { intent: "display" },
+          options: [
+            { value: "auto", label: "Auto" },
+            { value: "quiet", label: "Normal" },
+            { value: "editorial", label: "Large" },
+            { value: "display", label: "Huge" },
+            { value: "poster", label: "Poster" }
+          ]
+        },
         {
           id: "contentAlignment",
           type: "select",
@@ -21633,88 +22666,88 @@ var init_defineBlock = __esm({
 });
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var publicPassProductSchema, publicMembershipProductSchema;
 var init_shop_shared = __esm({
   "../blocks/src/system/blocks/shop.shared.ts"() {
     "use strict";
-    publicPassProductSchema = z32.object({
-      id: z32.string(),
-      productUseCase: z32.enum(["event_pass", "appointment_package"]).default("event_pass"),
-      name: z32.string(),
-      description: z32.string().nullable(),
-      price: z32.number(),
-      currency: z32.string(),
-      creditsTotal: z32.number(),
-      pricePerCredit: z32.number(),
-      validDays: z32.number().nullable(),
-      eligibleCategoryIds: z32.array(z32.string()),
-      eligibleCategoryNames: z32.array(z32.string())
+    publicPassProductSchema = z33.object({
+      id: z33.string(),
+      productUseCase: z33.enum(["event_pass", "appointment_package"]).default("event_pass"),
+      name: z33.string(),
+      description: z33.string().nullable(),
+      price: z33.number(),
+      currency: z33.string(),
+      creditsTotal: z33.number(),
+      pricePerCredit: z33.number(),
+      validDays: z33.number().nullable(),
+      eligibleCategoryIds: z33.array(z33.string()),
+      eligibleCategoryNames: z33.array(z33.string())
     });
-    publicMembershipProductSchema = z32.object({
-      id: z32.string(),
-      name: z32.string(),
-      description: z32.string().nullable(),
-      price: z32.number(),
-      currency: z32.string(),
-      billingInterval: z32.enum(["month", "year"]),
-      eligibleCategoryIds: z32.array(z32.string()),
-      eligibleCategoryNames: z32.array(z32.string())
+    publicMembershipProductSchema = z33.object({
+      id: z33.string(),
+      name: z33.string(),
+      description: z33.string().nullable(),
+      price: z33.number(),
+      currency: z33.string(),
+      billingInterval: z33.enum(["month", "year"]),
+      eligibleCategoryIds: z33.array(z33.string()),
+      eligibleCategoryNames: z33.array(z33.string())
     });
   }
 });
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var publicProductVariantSchema, publicProductSchema, publicProductsResponseSchema;
 var init_shared5 = __esm({
   "../blocks/src/system/blocks/products/shared.ts"() {
     "use strict";
-    publicProductVariantSchema = z33.object({
-      id: z33.string(),
-      title: z33.string(),
-      sku: z33.string().nullable(),
-      priceCents: z33.number(),
-      stockQuantity: z33.number().nullable(),
-      soldOut: z33.boolean()
-    });
-    publicProductSchema = z33.object({
-      id: z33.string(),
-      contentEntryId: z33.string().nullable(),
-      title: z33.string(),
-      slug: z33.string(),
-      path: z33.string().nullable(),
-      status: z33.enum(["draft", "active"]),
-      priceCents: z33.number(),
-      currency: z33.string(),
-      productType: z33.enum(["physical", "digital"]),
-      requiresShipping: z33.boolean(),
-      hasVariants: z33.boolean(),
-      trackInventory: z33.boolean(),
-      soldOut: z33.boolean(),
-      category: z33.object({
-        id: z33.string(),
-        name: z33.string(),
-        slug: z33.string()
+    publicProductVariantSchema = z34.object({
+      id: z34.string(),
+      title: z34.string(),
+      sku: z34.string().nullable(),
+      priceCents: z34.number(),
+      stockQuantity: z34.number().nullable(),
+      soldOut: z34.boolean()
+    });
+    publicProductSchema = z34.object({
+      id: z34.string(),
+      contentEntryId: z34.string().nullable(),
+      title: z34.string(),
+      slug: z34.string(),
+      path: z34.string().nullable(),
+      status: z34.enum(["draft", "active"]),
+      priceCents: z34.number(),
+      currency: z34.string(),
+      productType: z34.enum(["physical", "digital"]),
+      requiresShipping: z34.boolean(),
+      hasVariants: z34.boolean(),
+      trackInventory: z34.boolean(),
+      soldOut: z34.boolean(),
+      category: z34.object({
+        id: z34.string(),
+        name: z34.string(),
+        slug: z34.string()
       }).nullable(),
-      summary: z33.string().nullable(),
-      body: z33.unknown().nullable(),
-      gallery: z33.array(
-        z33.object({
-          url: z33.string(),
-          alt: z33.string().nullable()
+      summary: z34.string().nullable(),
+      body: z34.unknown().nullable(),
+      gallery: z34.array(
+        z34.object({
+          url: z34.string(),
+          alt: z34.string().nullable()
         })
       ),
-      variants: z33.array(publicProductVariantSchema)
+      variants: z34.array(publicProductVariantSchema)
     });
-    publicProductsResponseSchema = z33.object({
-      products: z33.array(publicProductSchema)
+    publicProductsResponseSchema = z34.object({
+      products: z34.array(publicProductSchema)
     });
   }
 });
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 function toPositiveInteger(value) {
   return Math.max(1, Math.floor(value));
 }
@@ -21872,26 +22905,26 @@ var init_shop_commerce_shared = __esm({
   "../blocks/src/system/runtime/nodes/shop-commerce.shared.ts"() {
     "use strict";
     EMPTY_COMMERCE_CART_STATE = { items: [] };
-    storedProductCartItemSchema = z34.object({
-      kind: z34.literal("product"),
-      productId: z34.string().min(1),
-      productCategoryId: z34.string().min(1).optional().nullable(),
-      variantId: z34.string().min(1).optional().nullable(),
-      title: z34.string().min(1),
-      variantTitle: z34.string().optional().nullable(),
-      quantity: z34.number().finite(),
-      unitPriceCents: z34.number().finite(),
-      currency: z34.string().min(1),
-      imageUrl: z34.string().optional().nullable(),
-      soldOut: z34.boolean().optional()
-    });
-    storedPassCartItemSchema = z34.object({
-      kind: z34.literal("pass"),
-      passId: z34.string().min(1),
-      title: z34.string().min(1),
-      quantity: z34.number().finite().optional(),
-      unitPriceCents: z34.number().finite(),
-      currency: z34.string().min(1)
+    storedProductCartItemSchema = z35.object({
+      kind: z35.literal("product"),
+      productId: z35.string().min(1),
+      productCategoryId: z35.string().min(1).optional().nullable(),
+      variantId: z35.string().min(1).optional().nullable(),
+      title: z35.string().min(1),
+      variantTitle: z35.string().optional().nullable(),
+      quantity: z35.number().finite(),
+      unitPriceCents: z35.number().finite(),
+      currency: z35.string().min(1),
+      imageUrl: z35.string().optional().nullable(),
+      soldOut: z35.boolean().optional()
+    });
+    storedPassCartItemSchema = z35.object({
+      kind: z35.literal("pass"),
+      passId: z35.string().min(1),
+      title: z35.string().min(1),
+      quantity: z35.number().finite().optional(),
+      unitPriceCents: z35.number().finite(),
+      currency: z35.string().min(1)
     });
   }
 });
@@ -22103,7 +23136,7 @@ var init_display = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
@@ -22223,211 +23256,211 @@ var init_shop_interactive = __esm({
     init_islands();
     init_runtime();
     init_contract_schemas();
-    shopModeSchema = z35.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-    contentEntrySchema = z35.object({
-      id: z35.string().nullable().optional(),
-      slug: z35.string().nullable().optional()
+    shopModeSchema = z36.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+    contentEntrySchema = z36.object({
+      id: z36.string().nullable().optional(),
+      slug: z36.string().nullable().optional()
     }).nullable();
-    shopSourceSchema = z35.object({
-      className: z35.string().nullable().optional(),
+    shopSourceSchema = z36.object({
+      className: z36.string().nullable().optional(),
       mode: shopModeSchema.optional(),
-      heading: z35.string().nullable().optional(),
-      productSlug: z35.string().nullable().optional(),
-      showPasses: z35.boolean().optional(),
-      showMemberships: z35.boolean().optional(),
-      layout: z35.enum(["grid", "list"]).optional(),
-      columns: z35.string().optional(),
-      showDescriptions: z35.boolean().optional(),
-      showSummary: z35.boolean().optional(),
-      showBody: z35.boolean().optional(),
-      showPrices: z35.boolean().optional(),
-      showValidityPeriod: z35.boolean().optional(),
-      showPricePerCredit: z35.boolean().nullable().optional(),
-      passesHeading: z35.string().optional(),
-      membershipsHeading: z35.string().optional(),
-      buyButtonText: z35.string().optional(),
-      addButtonText: z35.string().optional(),
-      passPurchaseMode: z35.enum(["add_to_cart", "buy_now"]).optional(),
-      subscribeButtonText: z35.string().optional(),
-      emptyStateText: z35.string().optional(),
-      checkoutButtonText: z35.string().optional(),
-      clearButtonText: z35.string().optional(),
-      submitButtonText: z35.string().optional(),
+      heading: z36.string().nullable().optional(),
+      productSlug: z36.string().nullable().optional(),
+      showPasses: z36.boolean().optional(),
+      showMemberships: z36.boolean().optional(),
+      layout: z36.enum(["grid", "list"]).optional(),
+      columns: z36.string().optional(),
+      showDescriptions: z36.boolean().optional(),
+      showSummary: z36.boolean().optional(),
+      showBody: z36.boolean().optional(),
+      showPrices: z36.boolean().optional(),
+      showValidityPeriod: z36.boolean().optional(),
+      showPricePerCredit: z36.boolean().nullable().optional(),
+      passesHeading: z36.string().optional(),
+      membershipsHeading: z36.string().optional(),
+      buyButtonText: z36.string().optional(),
+      addButtonText: z36.string().optional(),
+      passPurchaseMode: z36.enum(["add_to_cart", "buy_now"]).optional(),
+      subscribeButtonText: z36.string().optional(),
+      emptyStateText: z36.string().optional(),
+      checkoutButtonText: z36.string().optional(),
+      clearButtonText: z36.string().optional(),
+      submitButtonText: z36.string().optional(),
       contentEntry: contentEntrySchema.optional(),
-      passes: z35.array(publicPassProductSchema).nullable().optional(),
-      memberships: z35.array(publicMembershipProductSchema).nullable().optional(),
-      products: z35.array(publicProductSchema).nullable().optional(),
-      siteId: z35.string().optional(),
-      apiBaseUrl: z35.string().optional(),
+      passes: z36.array(publicPassProductSchema).nullable().optional(),
+      memberships: z36.array(publicMembershipProductSchema).nullable().optional(),
+      products: z36.array(publicProductSchema).nullable().optional(),
+      siteId: z36.string().optional(),
+      apiBaseUrl: z36.string().optional(),
       stage: previewStageSchema.optional()
     });
-    productVariantOptionDisplaySchema = z35.object({
-      id: z35.string(),
-      label: z35.string(),
-      soldOut: z35.boolean()
-    });
-    productCardDisplaySchema = z35.object({
-      productId: z35.string(),
-      title: z35.string(),
-      path: z35.string().nullable(),
-      summary: z35.string().nullable(),
-      priceLabel: z35.string().nullable(),
-      image: z35.object({
-        url: z35.string(),
-        alt: z35.string().nullable()
+    productVariantOptionDisplaySchema = z36.object({
+      id: z36.string(),
+      label: z36.string(),
+      soldOut: z36.boolean()
+    });
+    productCardDisplaySchema = z36.object({
+      productId: z36.string(),
+      title: z36.string(),
+      path: z36.string().nullable(),
+      summary: z36.string().nullable(),
+      priceLabel: z36.string().nullable(),
+      image: z36.object({
+        url: z36.string(),
+        alt: z36.string().nullable()
       }).nullable(),
-      variantOptions: z35.array(productVariantOptionDisplaySchema),
-      selectedVariantId: z35.string().nullable(),
-      selectionLabel: z35.string(),
-      actionLabel: z35.string(),
-      soldOut: z35.boolean()
-    });
-    productListDisplaySchema = z35.object({
-      kind: z35.literal("product-list"),
-      state: z35.enum(["empty", "ready"]),
-      heading: z35.string().nullable(),
-      className: z35.string().nullable(),
-      layout: z35.enum(["grid", "list"]),
-      columns: z35.string(),
-      emptyMessage: z35.string(),
-      cards: z35.array(productCardDisplaySchema)
-    });
-    productDetailDisplaySchema = z35.discriminatedUnion("state", [
-      z35.object({
-        kind: z35.literal("product-detail"),
-        state: z35.literal("empty"),
-        heading: z35.string().nullable(),
-        className: z35.string().nullable(),
-        emptyMessage: z35.string()
+      variantOptions: z36.array(productVariantOptionDisplaySchema),
+      selectedVariantId: z36.string().nullable(),
+      selectionLabel: z36.string(),
+      actionLabel: z36.string(),
+      soldOut: z36.boolean()
+    });
+    productListDisplaySchema = z36.object({
+      kind: z36.literal("product-list"),
+      state: z36.enum(["empty", "ready"]),
+      heading: z36.string().nullable(),
+      className: z36.string().nullable(),
+      layout: z36.enum(["grid", "list"]),
+      columns: z36.string(),
+      emptyMessage: z36.string(),
+      cards: z36.array(productCardDisplaySchema)
+    });
+    productDetailDisplaySchema = z36.discriminatedUnion("state", [
+      z36.object({
+        kind: z36.literal("product-detail"),
+        state: z36.literal("empty"),
+        heading: z36.string().nullable(),
+        className: z36.string().nullable(),
+        emptyMessage: z36.string()
       }),
-      z35.object({
-        kind: z35.literal("product-detail"),
-        state: z35.literal("ready"),
-        heading: z35.string().nullable(),
-        className: z35.string().nullable(),
-        title: z35.string(),
-        priceLabel: z35.string(),
-        summary: z35.string().nullable(),
-        categoryLabel: z35.string().nullable(),
-        gallery: z35.array(z35.object({
-          url: z35.string(),
-          alt: z35.string().nullable()
+      z36.object({
+        kind: z36.literal("product-detail"),
+        state: z36.literal("ready"),
+        heading: z36.string().nullable(),
+        className: z36.string().nullable(),
+        title: z36.string(),
+        priceLabel: z36.string(),
+        summary: z36.string().nullable(),
+        categoryLabel: z36.string().nullable(),
+        gallery: z36.array(z36.object({
+          url: z36.string(),
+          alt: z36.string().nullable()
         })),
-        variantOptions: z35.array(productVariantOptionDisplaySchema),
-        selectedVariantId: z35.string().nullable(),
-        selectionLabel: z35.string(),
-        actionLabel: z35.string(),
-        soldOut: z35.boolean(),
-        body: z35.unknown().nullable()
+        variantOptions: z36.array(productVariantOptionDisplaySchema),
+        selectedVariantId: z36.string().nullable(),
+        selectionLabel: z36.string(),
+        actionLabel: z36.string(),
+        soldOut: z36.boolean(),
+        body: z36.unknown().nullable()
       })
     ]);
-    passCardDisplaySchema = z35.object({
-      id: z35.string(),
-      title: z35.string(),
-      description: z35.string().nullable(),
-      priceLabel: z35.string(),
-      creditsLabel: z35.string(),
-      perCreditLabel: z35.string().nullable(),
-      validityLabel: z35.string().nullable(),
-      actionLabel: z35.string()
-    });
-    membershipCardDisplaySchema = z35.object({
-      id: z35.string(),
-      title: z35.string(),
-      description: z35.string().nullable(),
-      priceLabel: z35.string(),
-      intervalLabel: z35.string(),
-      actionLabel: z35.string()
-    });
-    passesMembershipsDisplaySchema = z35.object({
-      kind: z35.literal("passes-memberships"),
-      state: z35.enum(["empty", "ready"]),
-      className: z35.string().nullable(),
-      layout: z35.enum(["grid", "list"]),
-      columns: z35.string(),
-      emptyMessage: z35.string(),
-      passesHeading: z35.string(),
-      membershipsHeading: z35.string(),
-      passes: z35.array(passCardDisplaySchema),
-      memberships: z35.array(membershipCardDisplaySchema)
-    });
-    cartLineDisplaySchema = z35.object({
-      key: z35.string(),
-      title: z35.string(),
-      priceLabel: z35.string(),
-      quantity: z35.number(),
-      quantityEditable: z35.boolean()
-    });
-    cartDisplaySchema = z35.object({
-      kind: z35.literal("cart"),
-      state: z35.enum(["empty", "ready"]),
-      heading: z35.string().nullable(),
-      className: z35.string().nullable(),
-      emptyMessage: z35.string(),
-      supportText: z35.string().nullable(),
-      items: z35.array(cartLineDisplaySchema),
-      subtotalLabel: z35.string().nullable(),
-      checkoutButtonText: z35.string(),
-      clearButtonText: z35.string()
-    });
-    checkoutDisplaySchema = z35.object({
-      kind: z35.literal("checkout"),
-      state: z35.enum(["empty", "blocked", "ready"]),
-      heading: z35.string().nullable(),
-      className: z35.string().nullable(),
-      message: z35.string().nullable(),
-      submitButtonText: z35.string()
-    });
-    passesMembershipsHydrationSchema = z35.object({
-      passes: z35.array(publicPassProductSchema),
-      memberships: z35.array(publicMembershipProductSchema),
-      passPurchaseMode: z35.enum(["add_to_cart", "buy_now"])
-    });
-    productListHydrationSchema = z35.object({
-      products: z35.array(publicProductSchema),
-      showSummary: z35.boolean(),
-      showPrices: z35.boolean(),
-      addButtonText: z35.string()
-    });
-    productDetailHydrationSchema = z35.object({
-      products: z35.array(publicProductSchema),
-      productId: z35.string().nullable(),
-      showSummary: z35.boolean(),
-      showBody: z35.boolean(),
-      addButtonText: z35.string()
-    });
-    cartHydrationSchema = z35.object({
-      emptyStateText: z35.string(),
-      checkoutButtonText: z35.string(),
-      clearButtonText: z35.string()
-    });
-    checkoutHydrationSchema = z35.object({
-      emptyStateText: z35.string(),
-      submitButtonText: z35.string()
-    });
-    passesMembershipsRenderSchema = z35.object({
+    passCardDisplaySchema = z36.object({
+      id: z36.string(),
+      title: z36.string(),
+      description: z36.string().nullable(),
+      priceLabel: z36.string(),
+      creditsLabel: z36.string(),
+      perCreditLabel: z36.string().nullable(),
+      validityLabel: z36.string().nullable(),
+      actionLabel: z36.string()
+    });
+    membershipCardDisplaySchema = z36.object({
+      id: z36.string(),
+      title: z36.string(),
+      description: z36.string().nullable(),
+      priceLabel: z36.string(),
+      intervalLabel: z36.string(),
+      actionLabel: z36.string()
+    });
+    passesMembershipsDisplaySchema = z36.object({
+      kind: z36.literal("passes-memberships"),
+      state: z36.enum(["empty", "ready"]),
+      className: z36.string().nullable(),
+      layout: z36.enum(["grid", "list"]),
+      columns: z36.string(),
+      emptyMessage: z36.string(),
+      passesHeading: z36.string(),
+      membershipsHeading: z36.string(),
+      passes: z36.array(passCardDisplaySchema),
+      memberships: z36.array(membershipCardDisplaySchema)
+    });
+    cartLineDisplaySchema = z36.object({
+      key: z36.string(),
+      title: z36.string(),
+      priceLabel: z36.string(),
+      quantity: z36.number(),
+      quantityEditable: z36.boolean()
+    });
+    cartDisplaySchema = z36.object({
+      kind: z36.literal("cart"),
+      state: z36.enum(["empty", "ready"]),
+      heading: z36.string().nullable(),
+      className: z36.string().nullable(),
+      emptyMessage: z36.string(),
+      supportText: z36.string().nullable(),
+      items: z36.array(cartLineDisplaySchema),
+      subtotalLabel: z36.string().nullable(),
+      checkoutButtonText: z36.string(),
+      clearButtonText: z36.string()
+    });
+    checkoutDisplaySchema = z36.object({
+      kind: z36.literal("checkout"),
+      state: z36.enum(["empty", "blocked", "ready"]),
+      heading: z36.string().nullable(),
+      className: z36.string().nullable(),
+      message: z36.string().nullable(),
+      submitButtonText: z36.string()
+    });
+    passesMembershipsHydrationSchema = z36.object({
+      passes: z36.array(publicPassProductSchema),
+      memberships: z36.array(publicMembershipProductSchema),
+      passPurchaseMode: z36.enum(["add_to_cart", "buy_now"])
+    });
+    productListHydrationSchema = z36.object({
+      products: z36.array(publicProductSchema),
+      showSummary: z36.boolean(),
+      showPrices: z36.boolean(),
+      addButtonText: z36.string()
+    });
+    productDetailHydrationSchema = z36.object({
+      products: z36.array(publicProductSchema),
+      productId: z36.string().nullable(),
+      showSummary: z36.boolean(),
+      showBody: z36.boolean(),
+      addButtonText: z36.string()
+    });
+    cartHydrationSchema = z36.object({
+      emptyStateText: z36.string(),
+      checkoutButtonText: z36.string(),
+      clearButtonText: z36.string()
+    });
+    checkoutHydrationSchema = z36.object({
+      emptyStateText: z36.string(),
+      submitButtonText: z36.string()
+    });
+    passesMembershipsRenderSchema = z36.object({
       display: passesMembershipsDisplaySchema,
       hydration: passesMembershipsHydrationSchema
     });
-    productListRenderSchema = z35.object({
+    productListRenderSchema = z36.object({
       display: productListDisplaySchema,
       hydration: productListHydrationSchema
     });
-    productDetailRenderSchema = z35.object({
+    productDetailRenderSchema = z36.object({
       display: productDetailDisplaySchema,
       hydration: productDetailHydrationSchema
     });
-    cartRenderSchema = z35.object({
+    cartRenderSchema = z36.object({
       display: cartDisplaySchema,
       hydration: cartHydrationSchema
     });
-    checkoutRenderSchema = z35.object({
+    checkoutRenderSchema = z36.object({
       display: checkoutDisplaySchema,
       hydration: checkoutHydrationSchema
     });
-    shopIslandMetaCodec = createZodCodec(z35.object({
-      siteId: z35.string().optional(),
-      apiBaseUrl: z35.string().optional(),
+    shopIslandMetaCodec = createZodCodec(z36.object({
+      siteId: z36.string().optional(),
+      apiBaseUrl: z36.string().optional(),
       stage: previewStageSchema.optional()
     }));
     shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -22599,25 +23632,25 @@ var init_shop_interactive = __esm({
 });
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var occurrenceContextSchema;
 var init_event_registration_shared = __esm({
   "../blocks/src/system/blocks/event-registration.shared.ts"() {
     "use strict";
-    occurrenceContextSchema = z36.object({
-      id: z36.string(),
-      seriesId: z36.string(),
-      startsAt: z36.string(),
-      endsAt: z36.string(),
-      timeZone: z36.string(),
-      capacityOverride: z36.number().nullable().optional(),
-      overrides: z36.record(z36.string(), z36.unknown()).nullable().optional()
+    occurrenceContextSchema = z37.object({
+      id: z37.string(),
+      seriesId: z37.string(),
+      startsAt: z37.string(),
+      endsAt: z37.string(),
+      timeZone: z37.string(),
+      capacityOverride: z37.number().nullable().optional(),
+      overrides: z37.record(z37.string(), z37.unknown()).nullable().optional()
     }).nullable();
   }
 });
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function buildCourseRegistrationDisplay(source) {
   return {
     kind: "course-registration",
@@ -22648,72 +23681,72 @@ var init_course_registration_interactive = __esm({
     init_islands();
     init_runtime();
     init_contract_schemas();
-    contentEntrySchema2 = z37.object({
-      id: z37.string(),
-      slug: z37.string(),
-      contentTypeSlug: z37.string()
-    });
-    courseEntrySubrouteContextSchema = z37.union([
-      z37.object({
-        kind: z37.literal("course-run"),
-        run: z37.object({
-          courseId: z37.string(),
-          seriesId: z37.string(),
-          runSlug: z37.string(),
-          runName: z37.string().nullable()
+    contentEntrySchema2 = z38.object({
+      id: z38.string(),
+      slug: z38.string(),
+      contentTypeSlug: z38.string()
+    });
+    courseEntrySubrouteContextSchema = z38.union([
+      z38.object({
+        kind: z38.literal("course-run"),
+        run: z38.object({
+          courseId: z38.string(),
+          seriesId: z38.string(),
+          runSlug: z38.string(),
+          runName: z38.string().nullable()
         })
       }),
-      z37.object({
-        kind: z37.literal("event-occurrence"),
+      z38.object({
+        kind: z38.literal("event-occurrence"),
         occurrence: occurrenceContextSchema
       })
     ]);
-    courseRegistrationSourceSchema = z37.object({
-      siteId: z37.string().optional(),
-      apiBaseUrl: z37.string().optional(),
-      portalToken: z37.string().nullable().optional(),
+    courseRegistrationSourceSchema = z38.object({
+      siteId: z38.string().optional(),
+      apiBaseUrl: z38.string().optional(),
+      portalToken: z38.string().nullable().optional(),
       contentEntry: contentEntrySchema2.nullable().optional(),
       entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-      courses: z37.array(publicCourseSchema).nullable().optional(),
-      className: z37.string().nullable().optional(),
-      showSessions: z37.boolean().optional(),
-      showPrice: z37.boolean().optional(),
-      showCapacity: z37.boolean().optional(),
-      showVenue: z37.boolean().optional(),
-      successMessage: z37.string().optional(),
-      waitlistMessage: z37.string().optional(),
-      membershipMessage: z37.string().optional(),
-      buttonText: z37.string().nullable().optional(),
+      courses: z38.array(publicCourseSchema).nullable().optional(),
+      className: z38.string().nullable().optional(),
+      showSessions: z38.boolean().optional(),
+      showPrice: z38.boolean().optional(),
+      showCapacity: z38.boolean().optional(),
+      showVenue: z38.boolean().optional(),
+      successMessage: z38.string().optional(),
+      waitlistMessage: z38.string().optional(),
+      membershipMessage: z38.string().optional(),
+      buttonText: z38.string().nullable().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
       stage: previewStageSchema.optional()
     });
-    courseRegistrationDisplaySchema = z37.object({
-      kind: z37.literal("course-registration"),
-      state: z37.literal("shell"),
-      className: z37.string().nullable(),
-      summaryButtonText: z37.string()
+    courseRegistrationDisplaySchema = z38.object({
+      kind: z38.literal("course-registration"),
+      state: z38.literal("shell"),
+      className: z38.string().nullable(),
+      summaryButtonText: z38.string()
     });
-    courseRegistrationHydrationSchema = z37.object({
+    courseRegistrationHydrationSchema = z38.object({
       contentEntry: contentEntrySchema2.nullable().optional(),
       entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-      courses: z37.array(publicCourseSchema).nullable().optional(),
-      showSessions: z37.boolean().optional(),
-      showPrice: z37.boolean().optional(),
-      showCapacity: z37.boolean().optional(),
-      showVenue: z37.boolean().optional(),
-      successMessage: z37.string().optional(),
-      waitlistMessage: z37.string().optional(),
-      membershipMessage: z37.string().optional(),
+      courses: z38.array(publicCourseSchema).nullable().optional(),
+      showSessions: z38.boolean().optional(),
+      showPrice: z38.boolean().optional(),
+      showCapacity: z38.boolean().optional(),
+      showVenue: z38.boolean().optional(),
+      successMessage: z38.string().optional(),
+      waitlistMessage: z38.string().optional(),
+      membershipMessage: z38.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional()
     });
-    courseRegistrationRenderSchema = z37.object({
+    courseRegistrationRenderSchema = z38.object({
       display: courseRegistrationDisplaySchema,
       hydration: courseRegistrationHydrationSchema
     });
-    courseRegistrationIslandMetaCodec = createZodCodec(z37.object({
-      siteId: z37.string().optional(),
-      apiBaseUrl: z37.string().optional(),
-      portalToken: z37.string().nullable().optional(),
+    courseRegistrationIslandMetaCodec = createZodCodec(z38.object({
+      siteId: z38.string().optional(),
+      apiBaseUrl: z38.string().optional(),
+      portalToken: z38.string().nullable().optional(),
       stage: previewStageSchema.optional()
     }));
     courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -22761,7 +23794,7 @@ var init_course_registration_interactive = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 function buildGiftingDisplay(source) {
   return {
     kind: "gifting",
@@ -22791,71 +23824,71 @@ var init_gifting_interactive = __esm({
     "use strict";
     init_islands();
     init_runtime();
-    publicGiftCardOfferSchema = z38.object({
-      id: z38.string(),
-      kind: z38.literal("gift_card"),
-      title: z38.string(),
-      description: z38.string().nullable(),
-      sortOrder: z38.number().int(),
-      giftCard: z38.object({
-        fixedDenominations: z38.array(z38.number().int().positive()),
-        customAmountEnabled: z38.boolean(),
-        customAmountMinCents: z38.number().int().positive(),
-        customAmountMaxCents: z38.number().int().positive()
+    publicGiftCardOfferSchema = z39.object({
+      id: z39.string(),
+      kind: z39.literal("gift_card"),
+      title: z39.string(),
+      description: z39.string().nullable(),
+      sortOrder: z39.number().int(),
+      giftCard: z39.object({
+        fixedDenominations: z39.array(z39.number().int().positive()),
+        customAmountEnabled: z39.boolean(),
+        customAmountMinCents: z39.number().int().positive(),
+        customAmountMaxCents: z39.number().int().positive()
       }),
-      voucher: z38.null()
+      voucher: z39.null()
     });
-    publicVoucherOfferSchema = z38.object({
-      id: z38.string(),
-      kind: z38.literal("voucher"),
-      title: z38.string(),
-      description: z38.string().nullable(),
-      sortOrder: z38.number().int(),
-      giftCard: z38.null(),
-      voucher: z38.object({
-        purchaseAmountCents: z38.number().int().positive()
+    publicVoucherOfferSchema = z39.object({
+      id: z39.string(),
+      kind: z39.literal("voucher"),
+      title: z39.string(),
+      description: z39.string().nullable(),
+      sortOrder: z39.number().int(),
+      giftCard: z39.null(),
+      voucher: z39.object({
+        purchaseAmountCents: z39.number().int().positive()
       })
     });
-    publicGiftingOffersResponseSchema = z38.object({
-      currency: z38.string(),
-      giftCards: z38.array(publicGiftCardOfferSchema),
-      vouchers: z38.array(publicVoucherOfferSchema)
+    publicGiftingOffersResponseSchema = z39.object({
+      currency: z39.string(),
+      giftCards: z39.array(publicGiftCardOfferSchema),
+      vouchers: z39.array(publicVoucherOfferSchema)
     });
-    giftingSourceSchema = z38.object({
-      siteId: z38.string().optional(),
-      apiBaseUrl: z38.string().optional(),
+    giftingSourceSchema = z39.object({
+      siteId: z39.string().optional(),
+      apiBaseUrl: z39.string().optional(),
       offers: publicGiftingOffersResponseSchema.nullable().optional(),
-      className: z38.string().nullable().optional(),
-      heading: z38.string().nullable().optional(),
-      intro: z38.string().nullable().optional(),
-      giftCardsHeading: z38.string().nullable().optional(),
-      vouchersHeading: z38.string().nullable().optional(),
-      emptyStateText: z38.string().nullable().optional(),
-      checkoutButtonText: z38.string().nullable().optional(),
-      successMessage: z38.string().nullable().optional()
-    });
-    giftingDisplaySchema = z38.object({
-      kind: z38.literal("gifting"),
-      state: z38.literal("ready"),
-      className: z38.string().nullable(),
-      heading: z38.string(),
-      intro: z38.string().nullable(),
-      giftCardsHeading: z38.string(),
-      vouchersHeading: z38.string(),
-      emptyStateText: z38.string()
+      className: z39.string().nullable().optional(),
+      heading: z39.string().nullable().optional(),
+      intro: z39.string().nullable().optional(),
+      giftCardsHeading: z39.string().nullable().optional(),
+      vouchersHeading: z39.string().nullable().optional(),
+      emptyStateText: z39.string().nullable().optional(),
+      checkoutButtonText: z39.string().nullable().optional(),
+      successMessage: z39.string().nullable().optional()
+    });
+    giftingDisplaySchema = z39.object({
+      kind: z39.literal("gifting"),
+      state: z39.literal("ready"),
+      className: z39.string().nullable(),
+      heading: z39.string(),
+      intro: z39.string().nullable(),
+      giftCardsHeading: z39.string(),
+      vouchersHeading: z39.string(),
+      emptyStateText: z39.string()
     });
-    giftingHydrationSchema = z38.object({
+    giftingHydrationSchema = z39.object({
       offers: publicGiftingOffersResponseSchema.nullable(),
-      checkoutButtonText: z38.string(),
-      successMessage: z38.string()
+      checkoutButtonText: z39.string(),
+      successMessage: z39.string()
     });
-    giftingRenderSchema = z38.object({
+    giftingRenderSchema = z39.object({
       display: giftingDisplaySchema,
       hydration: giftingHydrationSchema
     });
-    giftingIslandMetaCodec = createZodCodec(z38.object({
-      siteId: z38.string().optional(),
-      apiBaseUrl: z38.string().optional()
+    giftingIslandMetaCodec = createZodCodec(z39.object({
+      siteId: z39.string().optional(),
+      apiBaseUrl: z39.string().optional()
     }));
     giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
       "siteId",
@@ -22890,15 +23923,30 @@ var init_gifting_interactive = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function buildEventRegistrationDisplay(source) {
   return {
     kind: "event-registration",
-    state: "shell",
+    state: "generic-shell",
     className: source.className ?? null,
+    titleText: "Event registration",
+    bodyText: "Preparing dates, tickets, and booking details.",
+    stepLabels: EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS,
     summaryButtonText: source.buttonText?.trim() || "Register"
   };
 }
+function normalizeEventRegistrationEventInput(value) {
+  if (!isRecord7(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    pricing: resolveRuntimeEventPricing(value)
+  };
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function buildEventRegistrationInteractiveIslandProps(props2) {
   return buildInteractiveIslandProps({
     runtime: eventRegistrationBlockRuntime,
@@ -22913,68 +23961,86 @@ function buildEventRegistrationInteractiveIslandProps(props2) {
     source: props2
   });
 }
-var contentEntrySchema3, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationIslandMetaCodec, eventRegistrationIslandMetaKeys, eventRegistrationBlockRuntime, eventRegistrationInteractiveIslandPropsCodec;
+var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS, eventRegistrationGenericDateStepLabel, eventRegistrationGenericTicketsStepLabel, eventRegistrationGenericDetailsStepLabel, contentEntrySchema3, eventRegistrationPublicEventSchema, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationIslandMetaCodec, eventRegistrationIslandMetaKeys, eventRegistrationBlockRuntime, eventRegistrationInteractiveIslandPropsCodec;
 var init_event_registration_interactive = __esm({
   "../blocks/src/system/runtime/nodes/event-registration.interactive.ts"() {
     "use strict";
     init_schemas2();
     init_event_registration_shared();
+    init_pricing2();
     init_islands();
     init_runtime();
     init_contract_schemas();
-    contentEntrySchema3 = z39.object({
-      id: z39.string(),
-      slug: z39.string(),
-      contentTypeSlug: z39.string()
-    });
-    eventRegistrationSourceSchema = z39.object({
-      siteId: z39.string().optional(),
-      apiBaseUrl: z39.string().optional(),
-      portalToken: z39.string().nullable().optional(),
-      previewToken: z39.string().nullable().optional(),
+    EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
+    [
+      eventRegistrationGenericDateStepLabel,
+      eventRegistrationGenericTicketsStepLabel,
+      eventRegistrationGenericDetailsStepLabel
+    ] = EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
+    contentEntrySchema3 = z40.object({
+      id: z40.string(),
+      slug: z40.string(),
+      contentTypeSlug: z40.string()
+    });
+    eventRegistrationPublicEventSchema = z40.preprocess(
+      normalizeEventRegistrationEventInput,
+      publicEventSchema
+    );
+    eventRegistrationSourceSchema = z40.object({
+      siteId: z40.string().optional(),
+      apiBaseUrl: z40.string().optional(),
+      portalToken: z40.string().nullable().optional(),
+      previewToken: z40.string().nullable().optional(),
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema3.nullable().optional(),
-      events: z39.array(publicEventSchema).nullable().optional(),
-      className: z39.string().nullable().optional(),
-      buttonText: z39.string().nullable().optional(),
-      maxTickets: z39.string().nullable().optional(),
-      showVenue: z39.boolean().optional(),
-      showCapacity: z39.boolean().optional(),
-      successMessage: z39.string().optional(),
-      waitlistMessage: z39.string().optional(),
+      events: z40.array(eventRegistrationPublicEventSchema).nullable().optional(),
+      className: z40.string().nullable().optional(),
+      buttonText: z40.string().nullable().optional(),
+      maxTickets: z40.string().nullable().optional(),
+      showVenue: z40.boolean().optional(),
+      showCapacity: z40.boolean().optional(),
+      successMessage: z40.string().optional(),
+      waitlistMessage: z40.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
-      spamProtectionEnabled: z39.boolean().optional(),
+      spamProtectionEnabled: z40.boolean().optional(),
       stage: previewStageSchema.optional(),
-      supportEmail: z39.string().optional()
-    });
-    eventRegistrationDisplaySchema = z39.object({
-      kind: z39.literal("event-registration"),
-      state: z39.literal("shell"),
-      className: z39.string().nullable(),
-      summaryButtonText: z39.string()
+      supportEmail: z40.string().optional()
+    });
+    eventRegistrationDisplaySchema = z40.object({
+      kind: z40.literal("event-registration"),
+      state: z40.literal("generic-shell"),
+      className: z40.string().nullable(),
+      titleText: z40.string(),
+      bodyText: z40.string(),
+      stepLabels: z40.tuple([
+        z40.literal(eventRegistrationGenericDateStepLabel),
+        z40.literal(eventRegistrationGenericTicketsStepLabel),
+        z40.literal(eventRegistrationGenericDetailsStepLabel)
+      ]),
+      summaryButtonText: z40.string()
     });
-    eventRegistrationHydrationSchema = z39.object({
+    eventRegistrationHydrationSchema = z40.object({
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema3.nullable().optional(),
-      events: z39.array(publicEventSchema).nullable().optional(),
-      maxTickets: z39.string().optional(),
-      showVenue: z39.boolean().optional(),
-      showCapacity: z39.boolean().optional(),
-      successMessage: z39.string().optional(),
-      waitlistMessage: z39.string().optional(),
+      events: z40.array(eventRegistrationPublicEventSchema).nullable().optional(),
+      maxTickets: z40.string().optional(),
+      showVenue: z40.boolean().optional(),
+      showCapacity: z40.boolean().optional(),
+      successMessage: z40.string().optional(),
+      waitlistMessage: z40.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
-      spamProtectionEnabled: z39.boolean().optional(),
-      supportEmail: z39.string().optional()
+      spamProtectionEnabled: z40.boolean().optional(),
+      supportEmail: z40.string().optional()
     });
-    eventRegistrationRenderSchema = z39.object({
+    eventRegistrationRenderSchema = z40.object({
       display: eventRegistrationDisplaySchema,
       hydration: eventRegistrationHydrationSchema
     });
-    eventRegistrationIslandMetaCodec = createZodCodec(z39.object({
-      siteId: z39.string().optional(),
-      apiBaseUrl: z39.string().optional(),
-      portalToken: z39.string().nullable().optional(),
-      previewToken: z39.string().nullable().optional(),
+    eventRegistrationIslandMetaCodec = createZodCodec(z40.object({
+      siteId: z40.string().optional(),
+      apiBaseUrl: z40.string().optional(),
+      portalToken: z40.string().nullable().optional(),
+      previewToken: z40.string().nullable().optional(),
       stage: previewStageSchema.optional()
     }));
     eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -23058,7 +24124,7 @@ var init_form_layout = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/form.interactive.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function buildFormDisplay(source) {
   const form2 = source.value ?? null;
   const fields = form2?.schemaJson?.fields;
@@ -23092,75 +24158,75 @@ var init_form_interactive = __esm({
     init_islands();
     init_runtime();
     init_form_layout();
-    formFieldSchema = z41.object({
-      id: z41.string(),
-      label: z41.string().optional(),
-      type: z41.string().optional(),
-      required: z41.boolean().optional(),
-      placeholder: z41.string().optional(),
-      helpText: z41.string().optional(),
-      layout: z41.object({
-        width: z41.enum(["full", "half"]).optional()
+    formFieldSchema = z42.object({
+      id: z42.string(),
+      label: z42.string().optional(),
+      type: z42.string().optional(),
+      required: z42.boolean().optional(),
+      placeholder: z42.string().optional(),
+      helpText: z42.string().optional(),
+      layout: z42.object({
+        width: z42.enum(["full", "half"]).optional()
       }).optional(),
-      rows: z41.number().optional(),
-      options: z41.array(z41.object({
-        value: z41.string(),
-        label: z41.string()
+      rows: z42.number().optional(),
+      options: z42.array(z42.object({
+        value: z42.string(),
+        label: z42.string()
       })).optional(),
-      multiple: z41.boolean().optional(),
-      minLength: z41.number().optional(),
-      maxLength: z41.number().optional(),
-      pattern: z41.string().optional(),
-      min: z41.number().optional(),
-      max: z41.number().optional()
-    });
-    formRecordSchema = z41.object({
-      id: z41.string(),
-      schemaJson: z41.object({
-        fields: z41.array(formFieldSchema).optional()
+      multiple: z42.boolean().optional(),
+      minLength: z42.number().optional(),
+      maxLength: z42.number().optional(),
+      pattern: z42.string().optional(),
+      min: z42.number().optional(),
+      max: z42.number().optional()
+    });
+    formRecordSchema = z42.object({
+      id: z42.string(),
+      schemaJson: z42.object({
+        fields: z42.array(formFieldSchema).optional()
       }).optional()
     });
-    formFieldGroupSchema = z41.discriminatedUnion("type", [
-      z41.object({
-        type: z41.literal("single"),
-        key: z41.string(),
+    formFieldGroupSchema = z42.discriminatedUnion("type", [
+      z42.object({
+        type: z42.literal("single"),
+        key: z42.string(),
         field: formFieldSchema
       }),
-      z41.object({
-        type: z41.literal("row"),
-        key: z41.string(),
-        fields: z41.tuple([formFieldSchema, formFieldSchema])
+      z42.object({
+        type: z42.literal("row"),
+        key: z42.string(),
+        fields: z42.tuple([formFieldSchema, formFieldSchema])
       })
     ]);
-    formSourceSchema = z41.object({
+    formSourceSchema = z42.object({
       value: formRecordSchema.optional(),
-      siteId: z41.string().optional(),
-      apiBaseUrl: z41.string().optional(),
-      submitLabel: z41.string().optional(),
-      successMessage: z41.string().nullable().optional(),
-      className: z41.string().optional(),
-      spamProtectionEnabled: z41.boolean().optional()
-    });
-    formDisplaySchema = z41.object({
-      kind: z41.literal("form"),
-      state: z41.enum(["missing", "ready"]),
-      className: z41.string().nullable(),
-      formId: z41.string().nullable(),
-      submitLabel: z41.string(),
-      successMessage: z41.string().nullable(),
+      siteId: z42.string().optional(),
+      apiBaseUrl: z42.string().optional(),
+      submitLabel: z42.string().optional(),
+      successMessage: z42.string().nullable().optional(),
+      className: z42.string().optional(),
+      spamProtectionEnabled: z42.boolean().optional()
+    });
+    formDisplaySchema = z42.object({
+      kind: z42.literal("form"),
+      state: z42.enum(["missing", "ready"]),
+      className: z42.string().nullable(),
+      formId: z42.string().nullable(),
+      submitLabel: z42.string(),
+      successMessage: z42.string().nullable(),
       form: formRecordSchema.nullable(),
-      groups: z41.array(formFieldGroupSchema)
+      groups: z42.array(formFieldGroupSchema)
     });
-    formHydrationSchema = z41.object({
-      spamProtectionEnabled: z41.boolean().optional()
+    formHydrationSchema = z42.object({
+      spamProtectionEnabled: z42.boolean().optional()
     });
-    formRenderSchema = z41.object({
+    formRenderSchema = z42.object({
       display: formDisplaySchema,
       hydration: formHydrationSchema
     });
-    formIslandMetaCodec = createZodCodec(z41.object({
-      siteId: z41.string().optional(),
-      apiBaseUrl: z41.string().optional()
+    formIslandMetaCodec = createZodCodec(z42.object({
+      siteId: z42.string().optional(),
+      apiBaseUrl: z42.string().optional()
     }));
     formIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
     formBlockRuntime = defineProgressiveBlockRuntime({
@@ -23190,7 +24256,7 @@ var init_form_interactive = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 function buildEventCalendarDisplay(source) {
   const listLayout = source.listLayout ?? source.layout ?? "stack";
   return {
@@ -23306,14 +24372,14 @@ var init_EventCalendar_interactive = __esm({
     init_shared2();
     init_contract_schemas();
     init_listOptions();
-    eventBlockKindSchema2 = z43.enum(eventBlockKindValues);
-    eventSurfaceScopeSchema2 = z43.enum(eventSurfaceScopeValues);
-    eventScheduleScopeSchema3 = z43.enum(eventScheduleScopeValues);
-    eventCalendarSourceSchema = z43.object(
+    eventBlockKindSchema2 = z44.enum(eventBlockKindValues);
+    eventSurfaceScopeSchema2 = z44.enum(eventSurfaceScopeValues);
+    eventScheduleScopeSchema3 = z44.enum(eventScheduleScopeValues);
+    eventCalendarSourceSchema = z44.object(
       {
-        events: z43.array(publicEventSchema).nullable().optional(),
-        siteId: z43.string(),
-        apiBaseUrl: z43.string().optional(),
+        events: z44.array(publicEventSchema).nullable().optional(),
+        siteId: z44.string(),
+        apiBaseUrl: z44.string().optional(),
         stage: previewStageSchema.optional(),
         variant: eventCalendarDisplayModeSchema.nullable().optional(),
         displayMode: eventCalendarDisplayModeSchema.nullable().optional(),
@@ -23321,78 +24387,78 @@ var init_EventCalendar_interactive = __esm({
         listColumns: columnOptionSchema.optional(),
         layout: eventLayoutSchema.optional(),
         columns: columnOptionSchema.optional(),
-        eventsPerPage: z43.string().optional(),
-        paginationMode: z43.enum(["loadMore", "seeAllLink"]).optional(),
-        seeAllUrl: z43.string().optional(),
-        loadMoreText: z43.string().optional(),
+        eventsPerPage: z44.string().optional(),
+        paginationMode: z44.enum(["loadMore", "seeAllLink"]).optional(),
+        seeAllUrl: z44.string().optional(),
+        loadMoreText: z44.string().optional(),
         startOfWeek: weekStartSchema.optional(),
         calendarTabViews: calendarTabViewsSchema.optional(),
-        showFilters: z43.boolean().nullable().optional(),
+        showFilters: z44.boolean().nullable().optional(),
         showCategoryFilter: filterAutoShowSchema.optional(),
-        showVenueFilter: z43.boolean().nullable().optional(),
-        showStaffFilter: z43.boolean().nullable().optional(),
+        showVenueFilter: z44.boolean().nullable().optional(),
+        showStaffFilter: z44.boolean().nullable().optional(),
         kind: eventBlockKindSchema2.nullable().optional(),
         eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-        filterEventPresets: z43.union([z43.string(), z43.array(z43.string())]).nullable().optional(),
+        filterEventPresets: z44.union([z44.string(), z44.array(z44.string())]).nullable().optional(),
         scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-        filterCategoryIds: z43.union([z43.string(), z43.array(z43.string())]).nullable().optional(),
-        filterStaffMemberId: z43.string().nullable().optional(),
-        filterVenueId: z43.string().nullable().optional(),
+        filterCategoryIds: z44.union([z44.string(), z44.array(z44.string())]).nullable().optional(),
+        filterStaffMemberId: z44.string().nullable().optional(),
+        filterVenueId: z44.string().nullable().optional(),
         buttonVariant: eventButtonVariantSchema.optional(),
-        buttonText: z43.string().optional(),
-        showVenue: z43.boolean().nullable().optional(),
-        showMap: z43.boolean().nullable().optional(),
-        showCapacity: z43.boolean().nullable().optional(),
-        emptyMessage: z43.string().optional(),
-        className: z43.string().optional()
+        buttonText: z44.string().optional(),
+        showVenue: z44.boolean().nullable().optional(),
+        showMap: z44.boolean().nullable().optional(),
+        showCapacity: z44.boolean().nullable().optional(),
+        emptyMessage: z44.string().optional(),
+        className: z44.string().optional()
       }
     );
-    eventCalendarDisplaySchema = z43.object({
-      kind: z43.literal("event-calendar"),
+    eventCalendarDisplaySchema = z44.object({
+      kind: z44.literal("event-calendar"),
       displayMode: eventCalendarDisplayModeSchema,
-      className: z43.string().nullable(),
-      events: z43.array(publicEventSchema),
+      className: z44.string().nullable(),
+      events: z44.array(publicEventSchema),
       listLayout: eventLayoutSchema,
       listColumns: columnOptionSchema,
       eventsPerPage: eventPageSizeSchema,
       paginationAction: eventListPaginationActionSchema,
       startOfWeek: weekStartSchema,
       calendarTabViews: calendarTabViewsSchema,
-      showFilters: z43.boolean(),
+      showFilters: z44.boolean(),
       showCategoryFilter: filterAutoShowSchema,
-      showVenueFilter: z43.boolean(),
-      showStaffFilter: z43.boolean(),
+      showVenueFilter: z44.boolean(),
+      showStaffFilter: z44.boolean(),
       eventKind: eventBlockKindSchema2,
       eventSurface: eventSurfaceScopeSchema2,
-      filterEventPresets: z43.string().nullable(),
+      filterEventPresets: z44.string().nullable(),
       scheduleScope: eventScheduleScopeSchema3,
-      filterCategoryIds: z43.string().nullable(),
-      filterStaffMemberId: z43.string().nullable(),
-      filterVenueId: z43.string().nullable(),
+      filterCategoryIds: z44.string().nullable(),
+      filterStaffMemberId: z44.string().nullable(),
+      filterVenueId: z44.string().nullable(),
       buttonVariant: eventButtonVariantSchema,
-      buttonText: z43.string(),
-      showVenue: z43.boolean(),
-      showMap: z43.boolean(),
-      showCapacity: z43.boolean(),
-      emptyMessage: z43.string()
-    });
-    eventCalendarHydrationSchema = z43.object({
-      siteId: z43.string(),
+      buttonText: z44.string(),
+      showVenue: z44.boolean(),
+      showMap: z44.boolean(),
+      showCapacity: z44.boolean(),
+      emptyMessage: z44.string()
+    });
+    eventCalendarHydrationSchema = z44.object({
+      siteId: z44.string(),
       stage: previewStageSchema.optional(),
-      prefetchedEvents: z43.boolean(),
+      prefetchedEvents: z44.boolean(),
       eventKind: eventBlockKindSchema2,
       eventSurface: eventSurfaceScopeSchema2,
-      filterEventPresets: z43.string().nullable(),
+      filterEventPresets: z44.string().nullable(),
       scheduleScope: eventScheduleScopeSchema3
     });
-    eventCalendarRenderSchema = z43.object({
+    eventCalendarRenderSchema = z44.object({
       display: eventCalendarDisplaySchema,
       hydration: eventCalendarHydrationSchema
     });
     eventCalendarIslandMetaCodec = createZodCodec(
-      z43.object({
-        siteId: z43.string(),
-        apiBaseUrl: z43.string().optional(),
+      z44.object({
+        siteId: z44.string(),
+        apiBaseUrl: z44.string().optional(),
         stage: previewStageSchema.optional()
       })
     );
@@ -23435,7 +24501,7 @@ var init_EventCalendar_interactive = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function buildEventListingInteractiveIslandProps(props2) {
   return buildInteractiveIslandProps({
     runtime: eventListingBlockRuntime,
@@ -23460,89 +24526,89 @@ var init_EventListing_interactive = __esm({
     init_shared2();
     init_contract_schemas();
     init_listOptions();
-    legacyEventCardVariantSchema = z44.enum(["variant1", "variant2"]);
-    eventCardVariantInputSchema = z44.union([
+    legacyEventCardVariantSchema = z45.enum(["variant1", "variant2"]);
+    eventCardVariantInputSchema = z45.union([
       cardVariantRoleSchema,
       legacyEventCardVariantSchema
     ]);
-    cardOrientationSchema = z44.enum(["vertical", "horizontal"]);
-    eventBlockKindSchema3 = z44.enum(eventBlockKindValues);
-    eventSurfaceScopeSchema3 = z44.enum(eventSurfaceScopeValues);
-    eventScheduleScopeSchema4 = z44.enum(eventScheduleScopeValues);
-    eventListingSourceSchema = z44.object({
-      events: z44.array(publicEventSchema).nullable().optional(),
-      siteId: z44.string(),
-      apiBaseUrl: z44.string().optional(),
+    cardOrientationSchema = z45.enum(["vertical", "horizontal"]);
+    eventBlockKindSchema3 = z45.enum(eventBlockKindValues);
+    eventSurfaceScopeSchema3 = z45.enum(eventSurfaceScopeValues);
+    eventScheduleScopeSchema4 = z45.enum(eventScheduleScopeValues);
+    eventListingSourceSchema = z45.object({
+      events: z45.array(publicEventSchema).nullable().optional(),
+      siteId: z45.string(),
+      apiBaseUrl: z45.string().optional(),
       stage: previewStageSchema.optional(),
       layout: eventLayoutSchema.optional(),
       columns: columnOptionSchema.optional(),
-      eventsPerPage: z44.string().optional(),
-      paginationMode: z44.enum(["loadMore", "seeAllLink"]).optional(),
-      seeAllUrl: z44.string().optional(),
-      loadMoreText: z44.string().optional(),
+      eventsPerPage: z45.string().optional(),
+      paginationMode: z45.enum(["loadMore", "seeAllLink"]).optional(),
+      seeAllUrl: z45.string().optional(),
+      loadMoreText: z45.string().optional(),
       cardVariant: eventCardVariantInputSchema.optional(),
       buttonVariant: eventButtonVariantSchema.optional(),
-      buttonText: z44.string().optional(),
-      showVenue: z44.boolean().optional(),
-      showMap: z44.boolean().optional(),
-      showCapacity: z44.boolean().optional(),
-      emptyMessage: z44.string().optional(),
-      className: z44.string().optional(),
-      showFilters: z44.boolean().nullable().optional(),
+      buttonText: z45.string().optional(),
+      showVenue: z45.boolean().optional(),
+      showMap: z45.boolean().optional(),
+      showCapacity: z45.boolean().optional(),
+      emptyMessage: z45.string().optional(),
+      className: z45.string().optional(),
+      showFilters: z45.boolean().nullable().optional(),
       showCategoryFilter: filterAutoShowSchema.optional(),
-      showVenueFilter: z44.boolean().nullable().optional(),
-      showStaffFilter: z44.boolean().nullable().optional(),
+      showVenueFilter: z45.boolean().nullable().optional(),
+      showStaffFilter: z45.boolean().nullable().optional(),
       eventKind: eventBlockKindSchema3.nullable().optional(),
       eventSurface: eventSurfaceScopeSchema3.nullable().optional(),
-      filterEventPresets: z44.union([z44.string(), z44.array(z44.string())]).nullable().optional(),
+      filterEventPresets: z45.union([z45.string(), z45.array(z45.string())]).nullable().optional(),
       scheduleScope: eventScheduleScopeSchema4.nullable().optional(),
-      filterCategoryIds: z44.string().nullable().optional(),
-      filterStaffMemberId: z44.string().nullable().optional(),
-      filterVenueId: z44.string().nullable().optional()
+      filterCategoryIds: z45.string().nullable().optional(),
+      filterStaffMemberId: z45.string().nullable().optional(),
+      filterVenueId: z45.string().nullable().optional()
     });
-    eventListingDisplaySchema = z44.object({
-      kind: z44.literal("event-listing"),
-      state: z44.enum(["loading", "empty", "ready"]),
+    eventListingDisplaySchema = z45.object({
+      kind: z45.literal("event-listing"),
+      state: z45.enum(["loading", "empty", "ready"]),
       listLayout: eventLayoutSchema,
-      className: z44.string().nullable(),
-      emptyMessage: z44.string(),
-      loadingMessage: z44.string(),
-      containerClass: z44.string(),
+      className: z45.string().nullable(),
+      emptyMessage: z45.string(),
+      loadingMessage: z45.string(),
+      containerClass: z45.string(),
       cardVariant: cardVariantRoleSchema,
       buttonVariant: eventButtonVariantSchema,
-      buttonText: z44.string(),
-      showVenue: z44.boolean(),
-      showMap: z44.boolean(),
-      showCapacity: z44.boolean(),
+      buttonText: z45.string(),
+      showVenue: z45.boolean(),
+      showMap: z45.boolean(),
+      showCapacity: z45.boolean(),
       orientation: cardOrientationSchema,
-      events: z44.array(publicEventSchema)
+      events: z45.array(publicEventSchema)
     });
-    eventListingHydrationSchema = z44.object({
-      siteId: z44.string(),
+    eventListingHydrationSchema = z45.object({
+      siteId: z45.string(),
       stage: previewStageSchema.optional(),
       eventsPerPage: eventPageSizeSchema,
       paginationAction: eventListPaginationActionSchema,
-      showFilters: z44.boolean(),
+      showFilters: z45.boolean(),
       showCategoryFilter: filterAutoShowSchema,
-      showVenueFilter: z44.boolean(),
-      showStaffFilter: z44.boolean(),
+      showVenueFilter: z45.boolean(),
+      showStaffFilter: z45.boolean(),
       eventKind: eventBlockKindSchema3,
       eventSurface: eventSurfaceScopeSchema3,
-      filterEventPresets: z44.string().nullable(),
+      filterEventPresets: z45.string().nullable(),
       scheduleScope: eventScheduleScopeSchema4,
-      filterCategoryIds: z44.string().nullable().optional(),
-      filterStaffMemberId: z44.string().nullable().optional(),
-      filterVenueId: z44.string().nullable().optional(),
-      fetchInitialEventsOnMount: z44.boolean()
+      filterCategoryIds: z45.string().nullable().optional(),
+      filterStaffMemberId: z45.string().nullable().optional(),
+      filterVenueId: z45.string().nullable().optional(),
+      fetchInitialEventsOnMount: z45.boolean()
     });
-    eventListingRenderSchema = z44.object({
+    eventListingRenderSchema = z45.object({
       display: eventListingDisplaySchema,
       hydration: eventListingHydrationSchema
     });
     eventListingIslandMetaCodec = createZodCodec(
-      z44.object({
-        siteId: z44.string(),
-        apiBaseUrl: z44.string().optional(),
+      z45.object({
+        siteId: z45.string(),
+        apiBaseUrl: z45.string().optional(),
         stage: previewStageSchema.optional()
       })
     );
@@ -23682,7 +24748,7 @@ var init_newsletter_form_types = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 function buildNewsletterDisplay(source) {
   const preset = source.preset ?? "emailOnly";
   const includePhone = source.includePhone ?? false;
@@ -23713,49 +24779,49 @@ var init_newsletter_form_interactive = __esm({
     init_islands();
     init_runtime();
     init_newsletter_form_types();
-    newsletterPresetSchema = z45.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-    newsletterFieldSchema = z45.object({
-      id: z45.string(),
-      type: z45.enum(["email", "text"]),
-      label: z45.string(),
-      required: z45.boolean(),
-      placeholder: z45.string().optional()
-    });
-    newsletterSourceSchema = z45.object({
-      siteId: z45.string().optional(),
-      apiBaseUrl: z45.string().optional(),
-      listId: z45.string().nullable().optional(),
+    newsletterPresetSchema = z46.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+    newsletterFieldSchema = z46.object({
+      id: z46.string(),
+      type: z46.enum(["email", "text"]),
+      label: z46.string(),
+      required: z46.boolean(),
+      placeholder: z46.string().optional()
+    });
+    newsletterSourceSchema = z46.object({
+      siteId: z46.string().optional(),
+      apiBaseUrl: z46.string().optional(),
+      listId: z46.string().nullable().optional(),
       preset: newsletterPresetSchema.optional(),
-      includePhone: z45.boolean().optional(),
-      buttonLabel: z45.string().nullable().optional(),
-      successMessage: z45.string().nullable().optional(),
-      privacyNote: z45.string().nullable().optional(),
-      tags: z45.string().nullable().optional(),
-      spamProtectionEnabled: z45.boolean().optional(),
-      className: z45.string().nullable().optional()
-    });
-    newsletterDisplaySchema = z45.object({
-      kind: z45.literal("newsletter-form"),
-      className: z45.string().nullable(),
-      buttonLabel: z45.string(),
-      successMessage: z45.string().nullable(),
-      privacyNote: z45.string().nullable(),
-      fields: z45.array(newsletterFieldSchema)
-    });
-    newsletterHydrationSchema = z45.object({
-      listId: z45.string().nullable().optional(),
+      includePhone: z46.boolean().optional(),
+      buttonLabel: z46.string().nullable().optional(),
+      successMessage: z46.string().nullable().optional(),
+      privacyNote: z46.string().nullable().optional(),
+      tags: z46.string().nullable().optional(),
+      spamProtectionEnabled: z46.boolean().optional(),
+      className: z46.string().nullable().optional()
+    });
+    newsletterDisplaySchema = z46.object({
+      kind: z46.literal("newsletter-form"),
+      className: z46.string().nullable(),
+      buttonLabel: z46.string(),
+      successMessage: z46.string().nullable(),
+      privacyNote: z46.string().nullable(),
+      fields: z46.array(newsletterFieldSchema)
+    });
+    newsletterHydrationSchema = z46.object({
+      listId: z46.string().nullable().optional(),
       preset: newsletterPresetSchema,
-      includePhone: z45.boolean(),
-      tags: z45.string().nullable().optional(),
-      spamProtectionEnabled: z45.boolean().optional()
+      includePhone: z46.boolean(),
+      tags: z46.string().nullable().optional(),
+      spamProtectionEnabled: z46.boolean().optional()
     });
-    newsletterRenderSchema = z45.object({
+    newsletterRenderSchema = z46.object({
       display: newsletterDisplaySchema,
       hydration: newsletterHydrationSchema
     });
-    newsletterIslandMetaCodec = createZodCodec(z45.object({
-      siteId: z45.string().optional(),
-      apiBaseUrl: z45.string().optional()
+    newsletterIslandMetaCodec = createZodCodec(z46.object({
+      siteId: z46.string().optional(),
+      apiBaseUrl: z46.string().optional()
     }));
     newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
     newsletterFormBlockRuntime = defineProgressiveBlockRuntime({
@@ -24193,7 +25259,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z48(e) {
+function z49(e) {
   if (L) {
     if (/* @__PURE__ */ Te(P) !== null)
       throw Tt(), Je;
@@ -26222,12 +27288,12 @@ function ha(e, t) {
   var mt = we(Dr, 2);
   let Pr;
   var We = X2(mt);
-  en(We), We.__change = ui, z48(mt);
+  en(We), We.__change = ui, z49(mt);
   var Ut = we(mt, 2), wi = X2(Ut);
   {
     var pi = (n) => {
       var u = na(), _ = Gr(u), y = X2(_);
-      Ge(y, () => c(re).verified), z48(_);
+      Ge(y, () => c(re).verified), z49(_);
       var T = we(_, 2);
       en(T), Pe(() => {
         se(T, "name", V()), jo(T, c(Le));
@@ -26236,10 +27302,10 @@ function ha(e, t) {
       {
         var _ = (T) => {
           var E = ia(), p = X2(E);
-          Ge(p, () => c(re).verifying), z48(E), ne(T, E);
+          Ge(p, () => c(re).verifying), z49(E), ne(T, E);
         }, y = (T) => {
           var E = oa(), p = X2(E);
-          Ge(p, () => c(re).label), z48(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
+          Ge(p, () => c(re).label), z49(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
         };
         $e(
           n,
@@ -26254,18 +27320,18 @@ function ha(e, t) {
       c(C) === b.VERIFIED ? n(pi) : n(bi, false);
     });
   }
-  z48(Ut);
+  z49(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n) => {
       var u = aa(), _ = X2(u);
-      se(_, "href", sr), z48(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
+      se(_, "href", sr), z49(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
     };
     $e(yi, (n) => {
       (N() !== true || c(Dt)) && n(Ei);
     });
   }
-  z48(Mt);
+  z49(Mt);
   var Or = we(Mt, 2);
   {
     var xi = (n) => {
@@ -26273,16 +27339,16 @@ function ha(e, t) {
       {
         var y = (E) => {
           var p = la(), x = X2(p);
-          Ge(x, () => c(re).expired), z48(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).expired), z49(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         }, T = (E) => {
           var p = sa(), x = X2(p);
-          Ge(x, () => c(re).error), z48(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).error), z49(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         };
         $e(_, (E) => {
           c(C) === b.EXPIRED ? E(y) : E(T, false);
         });
       }
-      z48(u), ne(n, u);
+      z49(u), ne(n, u);
     };
     $e(Or, (n) => {
       (c(He) || c(C) === b.EXPIRED) && n(xi);
@@ -26292,7 +27358,7 @@ function ha(e, t) {
   {
     var $i = (n) => {
       var u = ua(), _ = X2(u), y = X2(_);
-      Ge(y, () => c(re).footer), z48(_), z48(u), ne(n, u);
+      Ge(y, () => c(re).footer), z49(_), z49(u), ne(n, u);
     };
     $e(Fr, (n) => {
       c(re).footer && (k() !== true || c(Dt)) && n($i);
@@ -26308,7 +27374,7 @@ function ha(e, t) {
       v() && n(Ci);
     });
   }
-  return z48(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
+  return z49(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
     (n) => {
       se(ot, "data-state", c(C)), se(ot, "data-floating", v()), Pr = Fo(mt, 1, "altcha-checkbox", null, Pr, n), se(We, "id", c(cr)), We.required = r2() !== "onsubmit" && (!v() || r2() !== "off");
     },
@@ -31502,6 +32568,87 @@ var init_registrationStateMachine = __esm({
   }
 });
 
+// ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.state.ts
+function getRegistrableStatuses(isPreview) {
+  return isPreview ? ["active", "draft"] : ["active"];
+}
+function normalizeEventRegistrationMaxTickets(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.floor(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_EVENT_REGISTRATION_MAX_TICKETS;
+  }
+  return DEFAULT_EVENT_REGISTRATION_MAX_TICKETS;
+}
+function resolveEventRegistrationSubmitPlan(input) {
+  const selection = input.paymentSelection.method ? input.paymentSelection : void 0;
+  if (input.canJoinWaitlist) {
+    return { ok: true, args: withOptionalSelection({ method: "free" }, selection) };
+  }
+  switch (input.paymentSelection.method) {
+    case "pass":
+      return input.paymentSelection.passId ? {
+        ok: true,
+        args: withOptionalSelection(
+          { method: "pass", passId: input.paymentSelection.passId },
+          selection
+        )
+      } : missingPaymentSelection();
+    case "membership":
+      return input.paymentSelection.membershipId ? {
+        ok: true,
+        args: withOptionalSelection(
+          { method: "membership", membershipId: input.paymentSelection.membershipId },
+          selection
+        )
+      } : missingPaymentSelection();
+    case "free":
+      return { ok: true, args: withOptionalSelection({ method: "free" }, selection) };
+    case null:
+      return input.eventRequiresPayment ? missingPaymentSelection() : { ok: true, args: { method: "free" } };
+    case "pass_bundle":
+      return input.paymentSelection.bundlePassId ? {
+        ok: true,
+        args: withOptionalSelection(
+          { method: "pass_bundle", passId: input.paymentSelection.bundlePassId },
+          selection
+        )
+      } : missingPaymentSelection();
+    case "membership_bundle":
+      return input.paymentSelection.bundleMembershipId ? {
+        ok: true,
+        args: withOptionalSelection(
+          {
+            method: "membership_bundle",
+            membershipId: input.paymentSelection.bundleMembershipId
+          },
+          selection
+        )
+      } : missingPaymentSelection();
+    case "stripe":
+      return { ok: true, args: withOptionalSelection({ method: "stripe" }, selection) };
+  }
+}
+function withOptionalSelection(args, selection) {
+  return selection ? { ...args, selection } : args;
+}
+function missingPaymentSelection() {
+  return {
+    ok: false,
+    reason: "payment-selection-required",
+    message: "Select a payment option to continue."
+  };
+}
+var DEFAULT_EVENT_REGISTRATION_MAX_TICKETS;
+var init_event_registration_headless_state = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.state.ts"() {
+    "use strict";
+    DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/event-registration/types.ts
 var init_types17 = __esm({
   "../blocks/src/system/runtime/nodes/event-registration/types.ts"() {
@@ -31567,7 +32714,7 @@ function transformEligibilityResponse(response) {
     waitlistEnabled: eligibility.waitlistEnabled,
     canJoinWaitlist: eligibility.canJoinWaitlist,
     price: eligibility.eventPrice,
-    currency: eligibility.eventPriceCurrency ?? DEFAULT_EVENT_CURRENCY,
+    currency: eligibility.eventPriceCurrency ?? DEFAULT_EVENT_CURRENCY2,
     requiresAuthForPasses: eligibility.requiresAuthForPasses,
     requiresAuthForMemberships: eligibility.requiresAuthForMemberships,
     eligiblePasses,
@@ -31598,7 +32745,7 @@ function getTicketTypeAvailabilityLabel(ticketType) {
 }
 function getVisibleTicketTypes(input) {
   const eligibilityTicketTypes = input.eligibility?.ticketTypes;
-  const eventTicketTypes = input.event ? publicEventTicketTypes(input.event.pricing) : [];
+  const eventTicketTypes = input.event ? publicEventTicketTypes(resolveRuntimeEventPricing(input.event)) : [];
   const source = eligibilityTicketTypes && eligibilityTicketTypes.length > 0 ? eligibilityTicketTypes : eventTicketTypes;
   return source.filter(
     (ticketType) => ticketType.isActive && (!input.selectedAttendanceMode || (ticketType.attendanceScope ?? "both") === "both" || (ticketType.attendanceScope ?? "both") === input.selectedAttendanceMode)
@@ -31617,13 +32764,14 @@ function findSelectedTicketType(input) {
     selectedAttendanceMode: input.selectedAttendanceMode
   }).find((ticketType) => ticketType.id === input.selectedTicketTypeId) ?? null;
 }
-var DEFAULT_EVENT_CURRENCY, ENTITLEMENT_SINGLE_TICKET_TOOLTIP;
+var DEFAULT_EVENT_CURRENCY2, ENTITLEMENT_SINGLE_TICKET_TOOLTIP;
 var init_utils3 = __esm({
   "../blocks/src/system/runtime/nodes/event-registration/utils.ts"() {
     "use strict";
     init_src();
+    init_pricing2();
     init_shared6();
-    DEFAULT_EVENT_CURRENCY = "usd";
+    DEFAULT_EVENT_CURRENCY2 = "usd";
     ENTITLEMENT_SINGLE_TICKET_TOOLTIP = "Only available for single-ticket bookings";
   }
 });
@@ -32199,6 +33347,7 @@ var init_TicketSelectionStep = __esm({
     "use strict";
     "use client";
     init_src();
+    init_pricing2();
     init_utils3();
     TicketSelectionStep = ({
       event,
@@ -32218,8 +33367,9 @@ var init_TicketSelectionStep = __esm({
       const waitlistEnabled = selectedModeAvailability?.waitlistEnabled ?? event?.waitlistEnabled ?? false;
       const isSoldOut = availableSpots === 0;
       const canJoinWaitlist = isSoldOut && waitlistEnabled === true;
-      const eventPricingMode = event ? publicEventPricingMode(event.pricing) : void 0;
-      const eventPricingCurrency = event ? publicEventPricingCurrency(event.pricing) : null;
+      const eventPricing = event ? resolveRuntimeEventPricing(event) : null;
+      const eventPricingMode = eventPricing ? publicEventPricingMode(eventPricing) : void 0;
+      const eventPricingCurrency = eventPricing ? publicEventPricingCurrency(eventPricing) : null;
       const usesTicketTypes = eventPricingMode === "ticket_types" && !canJoinWaitlist;
       const visibleTicketTypes = usesTicketTypes ? getVisibleTicketTypes({
         event,
@@ -32284,7 +33434,7 @@ var init_TicketSelectionStep = __esm({
               const availabilityLabel = getTicketTypeAvailabilityLabel(ticketType);
               const disabled = ticketType.availability.kind === "unavailable";
               const isSelected = selectedTicketTypeId === ticketType.id;
-              const priceLabel = ticketType.priceAmount > 0 ? formatPrice(ticketType.priceAmount, eventPricingCurrency ?? DEFAULT_EVENT_CURRENCY) : "Free";
+              const priceLabel = ticketType.priceAmount > 0 ? formatPrice(ticketType.priceAmount, eventPricingCurrency ?? DEFAULT_EVENT_CURRENCY2) : "Free";
               return /* @__PURE__ */ jsx75("div", { role: "listitem", children: /* @__PURE__ */ jsxs51(
                 "button",
                 {
@@ -33333,18 +34483,8 @@ function EventRegistrationWizardActions(props2) {
     }
     case "select-payment": {
       const { status, canContinue, buttonText } = wizard.paymentStepState;
-      const selection = wizard.paymentSelection;
       const handlePaymentContinue = () => {
-        if (!selection.method) return;
-        if (selection.method === "free") {
-          void wizard.handlePaymentSelect("free");
-          return;
-        }
-        void wizard.handlePaymentSelect(
-          selection.method,
-          selection.passId ?? selection.bundlePassId,
-          selection.membershipId ?? selection.bundleMembershipId
-        );
+        void wizard.handlePaymentSelect();
       };
       return /* @__PURE__ */ jsxs61("div", { className: "er-actions", children: [
         /* @__PURE__ */ jsx87("button", { type: "button", onClick: () => wizard.setStep("enter-details"), className: "er-back-btn", children: "\u2190 Back" }),
@@ -33385,7 +34525,7 @@ function EventRegistrationSummaryBar(props2) {
   const occurrenceOverrideTitle = wizard.occurrenceContext?.overrides?.title;
   const summaryTitle = occurrenceOverrideTitle ?? summaryEvent?.title ?? "";
   const summaryPrice = wizard.selectedTicketType?.priceAmount ?? wizard.eligibility?.price ?? (summaryEvent ? publicEventScalarPrice(summaryEvent.pricing) : null) ?? 0;
-  const summaryCurrency = (summaryEvent ? publicEventPricingCurrency(summaryEvent.pricing) : null) ?? DEFAULT_EVENT_CURRENCY;
+  const summaryCurrency = (summaryEvent ? publicEventPricingCurrency(summaryEvent.pricing) : null) ?? DEFAULT_EVENT_CURRENCY2;
   const teamMemberNames = (summaryEvent?.teamMembers ?? []).map((teamMember) => teamMember.name).filter(Boolean);
   const subtotalCents = Math.max(0, summaryPrice * wizard.ticketsCount);
   const autoAppliedDiscount = wizard.discountCode.trim().length > 0 ? null : wizard.autoAppliedDiscount;
@@ -33408,7 +34548,7 @@ function EventRegistrationSummaryBar(props2) {
         ),
         wizard.paymentSelection.productInterval && /* @__PURE__ */ jsx88("div", { className: "er-summary-bar-product-detail", children: wizard.paymentSelection.productInterval })
       ] }),
-      /* @__PURE__ */ jsx88("div", { className: "er-summary-bar-product-price", children: wizard.paymentSelection.method === "pass" || wizard.paymentSelection.method === "membership" ? /* @__PURE__ */ jsx88("span", { className: "er-summary-bar-included", children: "Included" }) : wizard.paymentSelection.productPrice ? formatPrice(wizard.paymentSelection.productPrice, wizard.paymentSelection.productCurrency ?? DEFAULT_EVENT_CURRENCY) : null })
+      /* @__PURE__ */ jsx88("div", { className: "er-summary-bar-product-price", children: wizard.paymentSelection.method === "pass" || wizard.paymentSelection.method === "membership" ? /* @__PURE__ */ jsx88("span", { className: "er-summary-bar-included", children: "Included" }) : wizard.paymentSelection.productPrice ? formatPrice(wizard.paymentSelection.productPrice, wizard.paymentSelection.productCurrency ?? DEFAULT_EVENT_CURRENCY2) : null })
     ] }),
     /* @__PURE__ */ jsxs62("div", { className: "er-summary-bar", children: [
       /* @__PURE__ */ jsxs62("div", { className: "er-summary-bar-info", children: [
@@ -33730,9 +34870,15 @@ var init_useEventRegistrationStripeReturn = __esm({
 
 // ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationSubmit.ts
 function useEventRegistrationSubmit(options) {
-  return async (method, passId, membershipId, selection) => {
+  return async (method, passId, membershipId, selection, submitOptions) => {
     const submitOccurrenceId = options.registrationTarget?.occurrenceId;
-    if (!submitOccurrenceId) return;
+    if (!submitOccurrenceId) {
+      return {
+        ok: false,
+        reason: "missing-target",
+        message: "Select an event to continue."
+      };
+    }
     options.setStep("submitting");
     try {
       const isBundle = method === "pass_bundle" || method === "membership_bundle";
@@ -33800,7 +34946,7 @@ function useEventRegistrationSubmit(options) {
         if (checkoutResult.bypassed) {
           options.setRegistrationResult({ status: "confirmed" });
           options.setStep("success");
-          return;
+          return { ok: true, outcome: { kind: "completed" } };
         }
         if (!checkoutResult.checkoutUrl) {
           throw new Error("Checkout URL missing");
@@ -33817,8 +34963,17 @@ function useEventRegistrationSubmit(options) {
             paymentSelection: selectionSnapshot
           });
         }
+        if (submitOptions?.redirect === "manual") {
+          return {
+            ok: true,
+            outcome: {
+              kind: "checkout_redirect",
+              checkoutUrl: checkoutResult.checkoutUrl
+            }
+          };
+        }
         window.location.href = checkoutResult.checkoutUrl;
-        return;
+        return { ok: true, outcome: { kind: "checkout_redirect", checkoutUrl: checkoutResult.checkoutUrl } };
       }
       if (result.alreadyRegistered) {
         const title = result.status === "waitlist" ? "Already waitlisted" : "Already registered";
@@ -33840,9 +34995,16 @@ function useEventRegistrationSubmit(options) {
         options.setRegistrationResult({ status: result.status });
       }
       options.setStep("success");
+      return { ok: true, outcome: { kind: "completed" } };
     } catch (error) {
-      options.setErrorMessage(error instanceof Error ? error.message : "Registration failed");
+      const message = error instanceof Error ? error.message : "Registration failed";
+      options.setErrorMessage(message);
       options.setStep("error");
+      return {
+        ok: false,
+        reason: "submission-failed",
+        message
+      };
     }
   };
 }
@@ -33897,7 +35059,7 @@ function resolveEventRequiresPayment(input) {
   if (!input.event) {
     return false;
   }
-  return publicEventPricingType(input.event.pricing) !== "free";
+  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) !== "free";
 }
 function resolveDiscountContext(input) {
   const selection = input.paymentSelection.method ? input.paymentSelection : null;
@@ -33927,6 +35089,7 @@ var init_registrationDerivations = __esm({
   "../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts"() {
     "use strict";
     init_src();
+    init_pricing2();
   }
 });
 
@@ -33934,6 +35097,7 @@ var init_registrationDerivations = __esm({
 function toRegistrationEvent(event) {
   return {
     ...event,
+    pricing: resolveRuntimeEventPricing(event),
     publicEventId: event.id,
     registrationOccurrenceId: event.occurrenceId
   };
@@ -33944,6 +35108,7 @@ function toRegistrationEvents(events) {
 var init_registrationEventAdapter = __esm({
   "../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts"() {
     "use strict";
+    init_pricing2();
   }
 });
 
@@ -34166,7 +35331,7 @@ function useEventRegistrationWizard(options) {
   );
   const ticketTypeSelectionRequired = useMemo7(() => {
     const event = selectedEvent ?? preSelectedEvent;
-    if (!event || publicEventPricingMode(event.pricing) !== "ticket_types") {
+    if (!event || publicEventPricingMode(resolveRuntimeEventPricing(event)) !== "ticket_types") {
       return false;
     }
     if ((event.deliveryMode ?? "in_person") === "hybrid" && !selectedAttendanceMode) {
@@ -34181,7 +35346,7 @@ function useEventRegistrationWizard(options) {
   );
   useEffect14(() => {
     const event = selectedEvent ?? preSelectedEvent;
-    if (!event || publicEventPricingMode(event.pricing) !== "ticket_types") {
+    if (!event || publicEventPricingMode(resolveRuntimeEventPricing(event)) !== "ticket_types") {
       if (selectedTicketTypeId !== null) {
         setSelectedTicketTypeId(null);
       }
@@ -34254,30 +35419,45 @@ function useEventRegistrationWizard(options) {
       setStep("error");
       return;
     }
-    if (eligibility?.canJoinWaitlist) {
-      await handleSubmit("free", void 0, void 0, paymentSelection.method ? paymentSelection : void 0);
-      return;
-    }
-    if (paymentSelection.method === "pass" && paymentSelection.passId) {
-      await handleSubmit("pass", paymentSelection.passId, void 0, paymentSelection);
+    const shouldCollectPayment = !eligibility?.canJoinWaitlist && requiresPaymentStep({ eventRequiresPayment, paymentSelection });
+    if (shouldCollectPayment) {
+      setStep("select-payment");
       return;
     }
-    if (paymentSelection.method === "membership" && paymentSelection.membershipId) {
-      await handleSubmit("membership", void 0, paymentSelection.membershipId, paymentSelection);
+    const submitPlan = resolveEventRegistrationSubmitPlan({
+      paymentSelection,
+      eventRequiresPayment,
+      canJoinWaitlist: eligibility?.canJoinWaitlist
+    });
+    if (!submitPlan.ok) {
+      setErrorMessage(submitPlan.message);
+      setStep("error");
       return;
     }
-    if (paymentSelection.method === "free" || !eventRequiresPayment) {
-      await handleSubmit("free", void 0, void 0, paymentSelection.method ? paymentSelection : void 0);
+    await handleSubmit(
+      submitPlan.args.method,
+      submitPlan.args.passId,
+      submitPlan.args.membershipId,
+      submitPlan.args.selection
+    );
+  };
+  const handlePaymentSelect = async () => {
+    const submitPlan = resolveEventRegistrationSubmitPlan({
+      paymentSelection,
+      eventRequiresPayment,
+      canJoinWaitlist: eligibility?.canJoinWaitlist
+    });
+    if (!submitPlan.ok) {
+      setErrorMessage(submitPlan.message);
+      setStep("error");
       return;
     }
-    if (requiresPaymentStep({ eventRequiresPayment: true, paymentSelection })) {
-      setStep("select-payment");
-    } else {
-      await handleSubmit("stripe", void 0, void 0, paymentSelection.method ? paymentSelection : void 0);
-    }
-  };
-  const handlePaymentSelect = async (method, passId, membershipId) => {
-    await handleSubmit(method, passId, membershipId, paymentSelection.method ? paymentSelection : void 0);
+    await handleSubmit(
+      submitPlan.args.method,
+      submitPlan.args.passId,
+      submitPlan.args.membershipId,
+      submitPlan.args.selection
+    );
   };
   const handleUseCardInsteadOfPass = () => {
     dispatchFlow({ type: "use-card-instead-of-pass" });
@@ -34301,7 +35481,7 @@ function useEventRegistrationWizard(options) {
   const discountSubtotalCents = useMemo7(() => {
     if (discountContext?.type !== "event") return void 0;
     const event = selectedEvent ?? preSelectedEvent;
-    const eventPriceCents = selectedTicketType?.priceAmount ?? eligibility?.price ?? (event ? publicEventScalarPrice(event.pricing) : null) ?? 0;
+    const eventPriceCents = selectedTicketType?.priceAmount ?? eligibility?.price ?? (event ? publicEventScalarPrice(resolveRuntimeEventPricing(event)) : null) ?? 0;
     return Math.max(0, eventPriceCents * ticketsCount);
   }, [discountContext, selectedTicketType, eligibility, selectedEvent, preSelectedEvent, ticketsCount]);
   const discountUi = useDiscountCodeUi({ api, discountContext, subtotalCents: discountSubtotalCents });
@@ -34389,6 +35569,7 @@ function useEventRegistrationWizard(options) {
     altchaSolution,
     setAltchaSolution,
     portalAuthState,
+    portalProfile,
     showMagicLinkModal,
     setShowMagicLinkModal,
     handleLogout,
@@ -34403,6 +35584,7 @@ function useEventRegistrationWizard(options) {
     eligibilityError,
     existingRegistration: existingRegistrationResult.registration,
     existingRegistrationLoading: existingRegistrationResult.isLoading,
+    existingRegistrationState: existingRegistrationResult.state,
     hasEligibility,
     hasMembershipEligibility,
     requireGuestDetails,
@@ -34433,6 +35615,7 @@ var init_useEventRegistrationWizard = __esm({
     init_src();
     init_api();
     init_events();
+    init_pricing2();
     init_validation3();
     init_hooks();
     init_portalLogout();
@@ -34442,6 +35625,7 @@ var init_useEventRegistrationWizard = __esm({
     init_useDiscountCodeUi();
     init_utils3();
     init_registrationStateMachine();
+    init_event_registration_headless_state();
     init_registrationDerivations();
     init_registrationEventAdapter();
   }
@@ -34568,7 +35752,7 @@ function EventRegistrationWizard(props2) {
     spamProtectionEnabled,
     supportEmail
   } = props2;
-  const maxTicketsNum = parseInt(maxTickets, 10) || 5;
+  const maxTicketsNum = normalizeEventRegistrationMaxTickets(maxTickets);
   const showSpamProtection = spamProtectionEnabled ?? isSpamProtectionEnabled();
   const buttonClass = themeButtonClassName({ variant: buttonVariant, size: "md" });
   const wizard = useEventRegistrationWizard({
@@ -34581,7 +35765,7 @@ function EventRegistrationWizard(props2) {
   if (wizard.scopedEvents.length === 0 && !wizard.occurrenceContext) {
     return /* @__PURE__ */ jsx90("div", { id: EVENT_REGISTRATION_ANCHOR_ID, className: `event-registration ${className || ""}`, "data-block": "event-registration", children: /* @__PURE__ */ jsx90("div", { className: "er-empty", children: /* @__PURE__ */ jsx90("p", { className: "er-empty__text", children: "No events available for registration." }) }) });
   }
-  const allowedStatuses = wizard.api.config.isPreview ? ["active", "draft"] : ["active"];
+  const allowedStatuses = getRegistrableStatuses(wizard.api.config.isPreview);
   const hasRegistrableEvents = wizard.scopedEvents.some((event) => !event.status || allowedStatuses.includes(event.status));
   if (!hasRegistrableEvents && !wizard.occurrenceContext) {
     return /* @__PURE__ */ jsx90("div", { id: EVENT_REGISTRATION_ANCHOR_ID, className: `event-registration ${className || ""}`, "data-block": "event-registration", children: /* @__PURE__ */ jsx90("div", { className: "er-empty", children: /* @__PURE__ */ jsx90("p", { className: "er-empty__text", children: "Registration is not currently available for this event." }) }) });
@@ -34712,6 +35896,7 @@ var init_EventRegistrationWizard = __esm({
     init_StepIndicator2();
     init_wizardSteps2();
     init_registrationStateMachine();
+    init_event_registration_headless_state();
     init_EventRegistrationWizardContent();
     init_EventRegistrationWizardActions();
     init_EventRegistrationSummaryBar();
@@ -38260,7 +39445,7 @@ var init_embla_carousel_autoplay_esm = __esm({
 function isObject(subject) {
   return Object.prototype.toString.call(subject) === "[object Object]";
 }
-function isRecord6(subject) {
+function isRecord8(subject) {
   return isObject(subject) || Array.isArray(subject);
 }
 function canUseDOM() {
@@ -38277,7 +39462,7 @@ function areOptionsEqual(optionsA, optionsB) {
     const valueA = optionsA[key];
     const valueB = optionsB[key];
     if (typeof valueA === "function") return `${valueA}` === `${valueB}`;
-    if (!isRecord6(valueA) || !isRecord6(valueB)) return valueA === valueB;
+    if (!isRecord8(valueA) || !isRecord8(valueB)) return valueA === valueB;
     return areOptionsEqual(valueA, valueB);
   });
 }
@@ -44665,7 +45850,7 @@ var init_newsletter_form_client = __esm({
 });
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 var eventDetailsManifest, occurrenceContextSchema2, eventAutoApplyDiscountPreviewBaseSchema, eventAutoApplyDiscountPreviewSchema, eventDetailsBlockDefinition;
 var init_event_details = __esm({
   "../blocks/src/system/blocks/event-details.ts"() {
@@ -44808,40 +45993,40 @@ var init_event_details = __esm({
         })
       ]
     });
-    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()
+    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()
     }).nullable();
-    eventAutoApplyDiscountPreviewBaseSchema = z49.object({
-      id: z49.string(),
-      publicLabel: z49.string(),
-      description: z49.string().nullable(),
-      minTicketsRequired: z49.number().nullable()
+    eventAutoApplyDiscountPreviewBaseSchema = z50.object({
+      id: z50.string(),
+      publicLabel: z50.string(),
+      description: z50.string().nullable(),
+      minTicketsRequired: z50.number().nullable()
     });
-    eventAutoApplyDiscountPreviewSchema = z49.discriminatedUnion("discountType", [
+    eventAutoApplyDiscountPreviewSchema = z50.discriminatedUnion("discountType", [
       eventAutoApplyDiscountPreviewBaseSchema.extend({
-        discountType: z49.literal("percent"),
-        discountPercent: z49.number(),
-        discountAmountCents: z49.null()
+        discountType: z50.literal("percent"),
+        discountPercent: z50.number(),
+        discountAmountCents: z50.null()
       }),
       eventAutoApplyDiscountPreviewBaseSchema.extend({
-        discountType: z49.literal("fixed"),
-        discountPercent: z49.null(),
-        discountAmountCents: z49.number()
+        discountType: z50.literal("fixed"),
+        discountPercent: z50.null(),
+        discountAmountCents: z50.number()
       })
     ]);
     eventDetailsBlockDefinition = {
       manifest: eventDetailsManifest,
       dataSchemas: {
-        eventDetailsData: z49.object({
+        eventDetailsData: z50.object({
           events: publicEventsArraySchema,
-          sitePasses: z49.object({ passes: z49.array(publicPassProductSchema) }),
-          siteMemberships: z49.object({ memberships: z49.array(publicMembershipProductSchema) }),
+          sitePasses: z50.object({ passes: z50.array(publicPassProductSchema) }),
+          siteMemberships: z50.object({ memberships: z50.array(publicMembershipProductSchema) }),
           autoApplyDiscount: eventAutoApplyDiscountPreviewSchema.nullable().optional().default(null)
         }).optional(),
         occurrenceContext: occurrenceContextSchema2.optional()
@@ -44865,7 +46050,7 @@ var init_event_details = __esm({
 });
 
 // ../blocks/src/contracts/non-block-islands.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var accordionIslandSchema, headerSectionIslandSchema, responsiveSlidesToShowSchema, carouselIslandSchema, eventDetailsOccurrenceContextSchema, eventDetailsContentEntrySchema, eventDetailsIslandSchema, locationMapIslandSchema, accordionIslandPropsCodec, headerSectionIslandPropsCodec, carouselIslandPropsCodec, eventDetailsIslandPropsCodec, locationMapIslandPropsCodec;
 var init_non_block_islands = __esm({
   "../blocks/src/contracts/non-block-islands.ts"() {
@@ -44874,71 +46059,71 @@ var init_non_block_islands = __esm({
     init_shop_shared();
     init_schemas2();
     init_event_details();
-    accordionIslandSchema = z50.object({
-      type: z50.enum(["single", "multiple"]).optional(),
-      defaultValue: z50.union([z50.string(), z50.array(z50.string())]).optional(),
-      collapsible: z50.boolean().optional()
-    });
-    headerSectionIslandSchema = z50.object({
-      enabled: z50.boolean().optional(),
-      scrollEnabled: z50.boolean().optional()
-    });
-    responsiveSlidesToShowSchema = z50.object({
-      mobile: z50.union([z50.number(), z50.string()]).optional(),
-      tablet: z50.union([z50.number(), z50.string()]).optional(),
-      desktop: z50.union([z50.number(), z50.string()]).optional()
-    });
-    carouselIslandSchema = z50.object({
-      slidesToShow: z50.union([z50.number(), z50.string(), responsiveSlidesToShowSchema]).optional(),
-      transition: z50.enum(["slide", "fade"]).optional(),
-      showControls: z50.union([z50.boolean(), z50.string()]).optional(),
-      showDots: z50.union([z50.boolean(), z50.string()]).optional(),
-      arrowVisibility: z50.enum(["always", "hover", "never"]).optional(),
-      autoplay: z50.union([z50.boolean(), z50.string()]).optional(),
-      autoplayDelay: z50.union([z50.number(), z50.string()]).optional(),
-      loop: z50.union([z50.boolean(), z50.string()]).optional()
-    });
-    eventDetailsOccurrenceContextSchema = z50.object({
-      id: z50.string(),
-      seriesId: z50.string(),
-      startsAt: z50.string(),
-      endsAt: z50.string(),
-      timeZone: z50.string()
-    });
-    eventDetailsContentEntrySchema = z50.object({
-      id: z50.string(),
-      slug: z50.string(),
-      contentTypeSlug: z50.string()
-    });
-    eventDetailsIslandSchema = z50.object({
+    accordionIslandSchema = z51.object({
+      type: z51.enum(["single", "multiple"]).optional(),
+      defaultValue: z51.union([z51.string(), z51.array(z51.string())]).optional(),
+      collapsible: z51.boolean().optional()
+    });
+    headerSectionIslandSchema = z51.object({
+      enabled: z51.boolean().optional(),
+      scrollEnabled: z51.boolean().optional()
+    });
+    responsiveSlidesToShowSchema = z51.object({
+      mobile: z51.union([z51.number(), z51.string()]).optional(),
+      tablet: z51.union([z51.number(), z51.string()]).optional(),
+      desktop: z51.union([z51.number(), z51.string()]).optional()
+    });
+    carouselIslandSchema = z51.object({
+      slidesToShow: z51.union([z51.number(), z51.string(), responsiveSlidesToShowSchema]).optional(),
+      transition: z51.enum(["slide", "fade"]).optional(),
+      showControls: z51.union([z51.boolean(), z51.string()]).optional(),
+      showDots: z51.union([z51.boolean(), z51.string()]).optional(),
+      arrowVisibility: z51.enum(["always", "hover", "never"]).optional(),
+      autoplay: z51.union([z51.boolean(), z51.string()]).optional(),
+      autoplayDelay: z51.union([z51.number(), z51.string()]).optional(),
+      loop: z51.union([z51.boolean(), z51.string()]).optional()
+    });
+    eventDetailsOccurrenceContextSchema = z51.object({
+      id: z51.string(),
+      seriesId: z51.string(),
+      startsAt: z51.string(),
+      endsAt: z51.string(),
+      timeZone: z51.string()
+    });
+    eventDetailsContentEntrySchema = z51.object({
+      id: z51.string(),
+      slug: z51.string(),
+      contentTypeSlug: z51.string()
+    });
+    eventDetailsIslandSchema = z51.object({
       occurrenceContext: eventDetailsOccurrenceContextSchema.nullable().optional(),
       contentEntry: eventDetailsContentEntrySchema.nullable().optional(),
-      events: z50.array(publicEventSchema).nullable().optional(),
-      showVenue: z50.boolean().optional(),
-      showMap: z50.boolean().optional(),
-      showOtherDates: z50.boolean().optional(),
-      otherDatesLimit: z50.string().optional(),
-      showCost: z50.boolean().optional(),
-      showAcceptedPasses: z50.boolean().optional(),
-      showAcceptedMemberships: z50.boolean().optional(),
-      sitePasses: z50.object({ passes: z50.array(publicPassProductSchema) }).nullable().optional(),
-      siteMemberships: z50.object({ memberships: z50.array(publicMembershipProductSchema) }).nullable().optional(),
+      events: z51.array(publicEventSchema).nullable().optional(),
+      showVenue: z51.boolean().optional(),
+      showMap: z51.boolean().optional(),
+      showOtherDates: z51.boolean().optional(),
+      otherDatesLimit: z51.string().optional(),
+      showCost: z51.boolean().optional(),
+      showAcceptedPasses: z51.boolean().optional(),
+      showAcceptedMemberships: z51.boolean().optional(),
+      sitePasses: z51.object({ passes: z51.array(publicPassProductSchema) }).nullable().optional(),
+      siteMemberships: z51.object({ memberships: z51.array(publicMembershipProductSchema) }).nullable().optional(),
       autoApplyDiscount: eventAutoApplyDiscountPreviewSchema.nullable().optional(),
-      className: z50.string().nullable().optional(),
-      nowIso: z50.string().optional()
-    });
-    locationMapIslandSchema = z50.object({
-      location: z50.object({
-        addressText: z50.string().nullable(),
-        lat: z50.number().nullable(),
-        lng: z50.number().nullable()
+      className: z51.string().nullable().optional(),
+      nowIso: z51.string().optional()
+    });
+    locationMapIslandSchema = z51.object({
+      location: z51.object({
+        addressText: z51.string().nullable(),
+        lat: z51.number().nullable(),
+        lng: z51.number().nullable()
       }).nullable().optional(),
-      zoom: z50.number().nullable().optional(),
-      heightPx: z50.number().nullable().optional(),
-      showAddressText: z50.boolean().optional(),
-      showDirections: z50.boolean().optional(),
-      directionsLabel: z50.string().nullable().optional(),
-      className: z50.string().nullable().optional()
+      zoom: z51.number().nullable().optional(),
+      heightPx: z51.number().nullable().optional(),
+      showAddressText: z51.boolean().optional(),
+      showDirections: z51.boolean().optional(),
+      directionsLabel: z51.string().nullable().optional(),
+      className: z51.string().nullable().optional()
     });
     accordionIslandPropsCodec = createZodCodec(accordionIslandSchema);
     headerSectionIslandPropsCodec = createZodCodec(headerSectionIslandSchema);
@@ -49571,7 +50756,7 @@ init_shared3();
 init_defineBlock();
 init_event_registration_shared();
 init_event_registration_interactive();
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var eventRegistrationManifest = createBlockManifest({
   id: "block.event-registration",
   version: "1.0.0",
@@ -49735,7 +50920,7 @@ var eventRegistrationBlockDefinition = {
   manifest: eventRegistrationManifest,
   runtime: eventRegistrationBlockRuntime,
   dataSchemas: {
-    events: z40.array(publicEventSchema).optional(),
+    events: z41.array(publicEventSchema).optional(),
     occurrenceContext: occurrenceContextSchema.optional()
   },
   dataLoaders: {
@@ -49765,7 +50950,7 @@ init_defineBlock();
 init_fragments2();
 init_form_interactive();
 init_builder();
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var formComposition = composeFragments([
   { fragment: formCopyFragment },
   { fragment: formEmbedFragment }
@@ -49858,16 +51043,16 @@ var formManifest = createBlockManifest({
   tags: ["form", "contact", "input", "submit", "fields", "signup", "lead-capture"],
   icon: "FormInput"
 });
-var formDataSchema = z42.object({
-  id: z42.string(),
-  siteId: z42.string(),
-  userId: z42.string(),
-  name: z42.string(),
-  slug: z42.string(),
-  schemaJson: z42.any(),
-  settingsJson: z42.any().optional(),
-  createdAt: z42.string(),
-  updatedAt: z42.string()
+var formDataSchema = z43.object({
+  id: z43.string(),
+  siteId: z43.string(),
+  userId: z43.string(),
+  name: z43.string(),
+  slug: z43.string(),
+  schemaJson: z43.any(),
+  settingsJson: z43.any().optional(),
+  createdAt: z43.string(),
+  updatedAt: z43.string()
 });
 var formBlockDefinition = {
   manifest: formManifest,
@@ -51016,7 +52201,7 @@ init_api_bindings();
 init_defineBlock();
 init_shop_interactive();
 init_shared5();
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -51149,7 +52334,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z46.object({
+var productListDataSchema = z47.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -51162,7 +52347,7 @@ init_api_bindings();
 init_defineBlock();
 init_shop_shared();
 init_shop_interactive();
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var shopManifest = createBlockManifest({
   id: "block.shop",
   version: "1.0.0",
@@ -51358,9 +52543,9 @@ var shopBlockDefinition = {
   runtime: shopBlockRuntime,
   dataSchemas: {
     // listPublicPasses returns { passes: [...] }
-    passes: z47.object({ passes: z47.array(publicPassProductSchema) }).optional(),
+    passes: z48.object({ passes: z48.array(publicPassProductSchema) }).optional(),
     // listPublicMemberships returns { memberships: [...] }
-    memberships: z47.object({ memberships: z47.array(publicMembershipProductSchema) }).optional()
+    memberships: z48.object({ memberships: z48.array(publicMembershipProductSchema) }).optional()
   },
   dataLoaders: {
     // Load passes for display
@@ -52033,6 +53218,9 @@ var EventListingSSR = (props2) => {
 // ../blocks/src/system/runtime/nodes/event-registration.server.tsx
 init_event_registration_interactive();
 import { jsx as jsx47, jsxs as jsxs32 } from "react/jsx-runtime";
+function cx(...classes) {
+  return classes.filter((className) => Boolean(className)).join(" ");
+}
 function EventRegistrationSSR({
   blockId,
   siteId,
@@ -52075,6 +53263,7 @@ function EventRegistrationSSR({
     stage,
     supportEmail
   });
+  const display = islandProps.render.display;
   return /* @__PURE__ */ jsxs32(
     "div",
     {
@@ -52086,12 +53275,52 @@ function EventRegistrationSSR({
       ...getIslandRootProps("event-registration", blockId),
       children: [
         /* @__PURE__ */ jsx47(IslandPropsScript, { value: islandProps }),
-        /* @__PURE__ */ jsx47("div", { className: "event-registration__summary", children: /* @__PURE__ */ jsx47("strong", { children: "Loading booking options..." }) }),
+        /* @__PURE__ */ jsx47(EventRegistrationShell, { display }),
         children
       ]
     }
   );
 }
+function EventRegistrationShell({
+  display
+}) {
+  return /* @__PURE__ */ jsx47("div", { className: "er-container er-registration-shell", "aria-busy": "true", role: "status", children: /* @__PURE__ */ jsxs32("div", { className: "er-payment-layout er-payment-layout--no-sidebar", children: [
+    /* @__PURE__ */ jsxs32("div", { className: "er-payment-layout-main", children: [
+      /* @__PURE__ */ jsx47("div", { className: "er-steps-nav er-registration-shell__steps", "aria-hidden": "true", children: /* @__PURE__ */ jsx47("ol", { className: "er-steps", children: display.stepLabels.map((label, index) => {
+        const isActive = index === 0;
+        return /* @__PURE__ */ jsxs32("li", { className: "er-step", children: [
+          /* @__PURE__ */ jsx47("span", { className: cx("er-step-circle", isActive && "er-step-circle--active"), children: index + 1 }),
+          /* @__PURE__ */ jsx47("span", { className: cx("er-step-label", isActive && "er-step-label--active"), children: label }),
+          index < display.stepLabels.length - 1 ? /* @__PURE__ */ jsx47("span", { className: "er-step-connector" }) : null
+        ] }, label);
+      }) }) }),
+      /* @__PURE__ */ jsxs32("div", { className: "er-stack", children: [
+        /* @__PURE__ */ jsxs32("div", { children: [
+          /* @__PURE__ */ jsx47("p", { className: "er-registration-shell__eyebrow", children: "Registration" }),
+          /* @__PURE__ */ jsx47("h3", { className: "er-title er-registration-shell__title", children: display.titleText }),
+          /* @__PURE__ */ jsx47("p", { className: "er-text er-text--muted er-registration-shell__copy", children: display.bodyText })
+        ] }),
+        /* @__PURE__ */ jsxs32("div", { className: "er-event-grid er-registration-shell__cards", "aria-hidden": "true", children: [
+          /* @__PURE__ */ jsxs32("div", { className: "er-event-card er-registration-shell__card", children: [
+            /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--lg" }),
+            /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--sm" })
+          ] }),
+          /* @__PURE__ */ jsxs32("div", { className: "er-event-card er-registration-shell__card", children: [
+            /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--md" }),
+            /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--xs" })
+          ] })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx47("div", { className: "er-payment-layout-footer", children: /* @__PURE__ */ jsxs32("div", { className: "er-summary-bar er-registration-shell__summary", "aria-hidden": "true", children: [
+      /* @__PURE__ */ jsxs32("div", { className: "er-summary-bar-info", children: [
+        /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--md" }),
+        /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__line er-registration-shell__line--xs" })
+      ] }),
+      /* @__PURE__ */ jsx47("div", { className: "er-registration-shell__button-placeholder", children: display.summaryButtonText })
+    ] }) })
+  ] }) });
+}
 var event_registration_server_default = EventRegistrationSSR;
 
 // ../blocks/src/system/runtime/nodes/form.server.tsx
@@ -54353,7 +55582,7 @@ var MediaNode = ({
 
 // ../blocks/src/system/runtime/components/registry.client.tsx
 init_newsletter_form_client();
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null;
 }
 function buildRenderFromLooseProps(runtime, mode, props2) {
@@ -54373,14 +55602,14 @@ function withRuntimeBackedEnvelope(source, runtime, render) {
 function normalizeLegacyInteractiveRenderProps(runtime, mode, props2) {
   const source = props2;
   const render = props2["render"];
-  if (!isRecord7(render)) {
+  if (!isRecord9(render)) {
     return withRuntimeBackedEnvelope(
       source,
       runtime,
       buildRenderFromLooseProps(runtime, mode, props2)
     );
   }
-  if (isRecord7(render["hydration"])) {
+  if (isRecord9(render["hydration"])) {
     return withRuntimeBackedEnvelope(
       source,
       runtime,
@@ -54390,7 +55619,7 @@ function normalizeLegacyInteractiveRenderProps(runtime, mode, props2) {
       }
     );
   }
-  if (!isRecord7(render["display"])) {
+  if (!isRecord9(render["display"])) {
     return withRuntimeBackedEnvelope(
       source,
       runtime,
@@ -54520,6 +55749,7 @@ init_curatedSiteStyles();
 // ../theme-core/src/inputs/generateInputCss.ts
 init_types11();
 init_constants();
+init_colorStyles();
 
 // ../theme-core/src/header/generateHeaderCss.ts
 init_resolver();
@@ -54718,6 +55948,11 @@ ${root} {
   --er-event-card-bg: rgb(var(--tb-surface));
   --er-event-card-border-width: var(--rb-border-width, 1px);
   --er-event-card-hover-opacity: 1;
+  --er-control-bg: rgb(var(--tb-background, var(--tb-surface)));
+  --er-control-text: rgb(var(--tb-foreground, var(--tb-text)));
+  --er-radius: var(--rb-block-radius);
+  --er-surface-muted: rgba(var(--tb-muted, 241 245 249), 0.42);
+  --er-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
 
   /* Step indicator */
   --er-step-active: rgb(var(--tb-primary));